1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * DPAA2 Ethernet Switch driver 4 * 5 * Copyright 2014-2016 Freescale Semiconductor Inc. 6 * Copyright 2017-2021 NXP 7 * 8 */ 9 10 #include <linux/module.h> 11 12 #include <linux/interrupt.h> 13 #include <linux/msi.h> 14 #include <linux/kthread.h> 15 #include <linux/workqueue.h> 16 #include <linux/iommu.h> 17 18 #include <linux/fsl/mc.h> 19 20 #include "dpaa2-switch.h" 21 22 /* Minimal supported DPSW version */ 23 #define DPSW_MIN_VER_MAJOR 8 24 #define DPSW_MIN_VER_MINOR 9 25 26 #define DEFAULT_VLAN_ID 1 27 28 static u16 dpaa2_switch_port_get_fdb_id(struct ethsw_port_priv *port_priv) 29 { 30 return port_priv->fdb->fdb_id; 31 } 32 33 static struct dpaa2_switch_fdb *dpaa2_switch_fdb_get_unused(struct ethsw_core *ethsw) 34 { 35 int i; 36 37 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) 38 if (!ethsw->fdbs[i].in_use) 39 return ðsw->fdbs[i]; 40 return NULL; 41 } 42 43 static u16 dpaa2_switch_port_set_fdb(struct ethsw_port_priv *port_priv, 44 struct net_device *bridge_dev) 45 { 46 struct ethsw_port_priv *other_port_priv = NULL; 47 struct dpaa2_switch_fdb *fdb; 48 struct net_device *other_dev; 49 struct list_head *iter; 50 51 /* If we leave a bridge (bridge_dev is NULL), find an unused 52 * FDB and use that. 53 */ 54 if (!bridge_dev) { 55 fdb = dpaa2_switch_fdb_get_unused(port_priv->ethsw_data); 56 57 /* If there is no unused FDB, we must be the last port that 58 * leaves the last bridge, all the others are standalone. We 59 * can just keep the FDB that we already have. 60 */ 61 62 if (!fdb) { 63 port_priv->fdb->bridge_dev = NULL; 64 return 0; 65 } 66 67 port_priv->fdb = fdb; 68 port_priv->fdb->in_use = true; 69 port_priv->fdb->bridge_dev = NULL; 70 return 0; 71 } 72 73 /* The below call to netdev_for_each_lower_dev() demands the RTNL lock 74 * being held. Assert on it so that it's easier to catch new code 75 * paths that reach this point without the RTNL lock. 76 */ 77 ASSERT_RTNL(); 78 79 /* If part of a bridge, use the FDB of the first dpaa2 switch interface 80 * to be present in that bridge 81 */ 82 netdev_for_each_lower_dev(bridge_dev, other_dev, iter) { 83 if (!dpaa2_switch_port_dev_check(other_dev)) 84 continue; 85 86 if (other_dev == port_priv->netdev) 87 continue; 88 89 other_port_priv = netdev_priv(other_dev); 90 break; 91 } 92 93 /* The current port is about to change its FDB to the one used by the 94 * first port that joined the bridge. 95 */ 96 if (other_port_priv) { 97 /* The previous FDB is about to become unused, since the 98 * interface is no longer standalone. 99 */ 100 port_priv->fdb->in_use = false; 101 port_priv->fdb->bridge_dev = NULL; 102 103 /* Get a reference to the new FDB */ 104 port_priv->fdb = other_port_priv->fdb; 105 } 106 107 /* Keep track of the new upper bridge device */ 108 port_priv->fdb->bridge_dev = bridge_dev; 109 110 return 0; 111 } 112 113 static void *dpaa2_iova_to_virt(struct iommu_domain *domain, 114 dma_addr_t iova_addr) 115 { 116 phys_addr_t phys_addr; 117 118 phys_addr = domain ? iommu_iova_to_phys(domain, iova_addr) : iova_addr; 119 120 return phys_to_virt(phys_addr); 121 } 122 123 static int dpaa2_switch_add_vlan(struct ethsw_port_priv *port_priv, u16 vid) 124 { 125 struct ethsw_core *ethsw = port_priv->ethsw_data; 126 struct dpsw_vlan_cfg vcfg = {0}; 127 int err; 128 129 vcfg.fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 130 err = dpsw_vlan_add(ethsw->mc_io, 0, 131 ethsw->dpsw_handle, vid, &vcfg); 132 if (err) { 133 dev_err(ethsw->dev, "dpsw_vlan_add err %d\n", err); 134 return err; 135 } 136 ethsw->vlans[vid] = ETHSW_VLAN_MEMBER; 137 138 return 0; 139 } 140 141 static bool dpaa2_switch_port_is_up(struct ethsw_port_priv *port_priv) 142 { 143 struct net_device *netdev = port_priv->netdev; 144 struct dpsw_link_state state; 145 int err; 146 147 err = dpsw_if_get_link_state(port_priv->ethsw_data->mc_io, 0, 148 port_priv->ethsw_data->dpsw_handle, 149 port_priv->idx, &state); 150 if (err) { 151 netdev_err(netdev, "dpsw_if_get_link_state() err %d\n", err); 152 return true; 153 } 154 155 WARN_ONCE(state.up > 1, "Garbage read into link_state"); 156 157 return state.up ? true : false; 158 } 159 160 static int dpaa2_switch_port_set_pvid(struct ethsw_port_priv *port_priv, u16 pvid) 161 { 162 struct ethsw_core *ethsw = port_priv->ethsw_data; 163 struct net_device *netdev = port_priv->netdev; 164 struct dpsw_tci_cfg tci_cfg = { 0 }; 165 bool up; 166 int err, ret; 167 168 err = dpsw_if_get_tci(ethsw->mc_io, 0, ethsw->dpsw_handle, 169 port_priv->idx, &tci_cfg); 170 if (err) { 171 netdev_err(netdev, "dpsw_if_get_tci err %d\n", err); 172 return err; 173 } 174 175 tci_cfg.vlan_id = pvid; 176 177 /* Interface needs to be down to change PVID */ 178 up = dpaa2_switch_port_is_up(port_priv); 179 if (up) { 180 err = dpsw_if_disable(ethsw->mc_io, 0, 181 ethsw->dpsw_handle, 182 port_priv->idx); 183 if (err) { 184 netdev_err(netdev, "dpsw_if_disable err %d\n", err); 185 return err; 186 } 187 } 188 189 err = dpsw_if_set_tci(ethsw->mc_io, 0, ethsw->dpsw_handle, 190 port_priv->idx, &tci_cfg); 191 if (err) { 192 netdev_err(netdev, "dpsw_if_set_tci err %d\n", err); 193 goto set_tci_error; 194 } 195 196 /* Delete previous PVID info and mark the new one */ 197 port_priv->vlans[port_priv->pvid] &= ~ETHSW_VLAN_PVID; 198 port_priv->vlans[pvid] |= ETHSW_VLAN_PVID; 199 port_priv->pvid = pvid; 200 201 set_tci_error: 202 if (up) { 203 ret = dpsw_if_enable(ethsw->mc_io, 0, 204 ethsw->dpsw_handle, 205 port_priv->idx); 206 if (ret) { 207 netdev_err(netdev, "dpsw_if_enable err %d\n", ret); 208 return ret; 209 } 210 } 211 212 return err; 213 } 214 215 static int dpaa2_switch_port_add_vlan(struct ethsw_port_priv *port_priv, 216 u16 vid, u16 flags) 217 { 218 struct ethsw_core *ethsw = port_priv->ethsw_data; 219 struct net_device *netdev = port_priv->netdev; 220 struct dpsw_vlan_if_cfg vcfg = {0}; 221 int err; 222 223 if (port_priv->vlans[vid]) { 224 netdev_warn(netdev, "VLAN %d already configured\n", vid); 225 return -EEXIST; 226 } 227 228 /* If hit, this VLAN rule will lead the packet into the FDB table 229 * specified in the vlan configuration below 230 */ 231 vcfg.num_ifs = 1; 232 vcfg.if_id[0] = port_priv->idx; 233 vcfg.fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 234 vcfg.options |= DPSW_VLAN_ADD_IF_OPT_FDB_ID; 235 err = dpsw_vlan_add_if(ethsw->mc_io, 0, ethsw->dpsw_handle, vid, &vcfg); 236 if (err) { 237 netdev_err(netdev, "dpsw_vlan_add_if err %d\n", err); 238 return err; 239 } 240 241 port_priv->vlans[vid] = ETHSW_VLAN_MEMBER; 242 243 if (flags & BRIDGE_VLAN_INFO_UNTAGGED) { 244 err = dpsw_vlan_add_if_untagged(ethsw->mc_io, 0, 245 ethsw->dpsw_handle, 246 vid, &vcfg); 247 if (err) { 248 netdev_err(netdev, 249 "dpsw_vlan_add_if_untagged err %d\n", err); 250 return err; 251 } 252 port_priv->vlans[vid] |= ETHSW_VLAN_UNTAGGED; 253 } 254 255 if (flags & BRIDGE_VLAN_INFO_PVID) { 256 err = dpaa2_switch_port_set_pvid(port_priv, vid); 257 if (err) 258 return err; 259 } 260 261 return 0; 262 } 263 264 static int dpaa2_switch_port_set_stp_state(struct ethsw_port_priv *port_priv, u8 state) 265 { 266 struct dpsw_stp_cfg stp_cfg = { 267 .state = state, 268 }; 269 int err; 270 u16 vid; 271 272 if (!netif_running(port_priv->netdev) || state == port_priv->stp_state) 273 return 0; /* Nothing to do */ 274 275 for (vid = 0; vid <= VLAN_VID_MASK; vid++) { 276 if (port_priv->vlans[vid] & ETHSW_VLAN_MEMBER) { 277 stp_cfg.vlan_id = vid; 278 err = dpsw_if_set_stp(port_priv->ethsw_data->mc_io, 0, 279 port_priv->ethsw_data->dpsw_handle, 280 port_priv->idx, &stp_cfg); 281 if (err) { 282 netdev_err(port_priv->netdev, 283 "dpsw_if_set_stp err %d\n", err); 284 return err; 285 } 286 } 287 } 288 289 port_priv->stp_state = state; 290 291 return 0; 292 } 293 294 static int dpaa2_switch_dellink(struct ethsw_core *ethsw, u16 vid) 295 { 296 struct ethsw_port_priv *ppriv_local = NULL; 297 int i, err; 298 299 if (!ethsw->vlans[vid]) 300 return -ENOENT; 301 302 err = dpsw_vlan_remove(ethsw->mc_io, 0, ethsw->dpsw_handle, vid); 303 if (err) { 304 dev_err(ethsw->dev, "dpsw_vlan_remove err %d\n", err); 305 return err; 306 } 307 ethsw->vlans[vid] = 0; 308 309 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 310 ppriv_local = ethsw->ports[i]; 311 ppriv_local->vlans[vid] = 0; 312 } 313 314 return 0; 315 } 316 317 static int dpaa2_switch_port_fdb_add_uc(struct ethsw_port_priv *port_priv, 318 const unsigned char *addr) 319 { 320 struct dpsw_fdb_unicast_cfg entry = {0}; 321 u16 fdb_id; 322 int err; 323 324 entry.if_egress = port_priv->idx; 325 entry.type = DPSW_FDB_ENTRY_STATIC; 326 ether_addr_copy(entry.mac_addr, addr); 327 328 fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 329 err = dpsw_fdb_add_unicast(port_priv->ethsw_data->mc_io, 0, 330 port_priv->ethsw_data->dpsw_handle, 331 fdb_id, &entry); 332 if (err) 333 netdev_err(port_priv->netdev, 334 "dpsw_fdb_add_unicast err %d\n", err); 335 return err; 336 } 337 338 static int dpaa2_switch_port_fdb_del_uc(struct ethsw_port_priv *port_priv, 339 const unsigned char *addr) 340 { 341 struct dpsw_fdb_unicast_cfg entry = {0}; 342 u16 fdb_id; 343 int err; 344 345 entry.if_egress = port_priv->idx; 346 entry.type = DPSW_FDB_ENTRY_STATIC; 347 ether_addr_copy(entry.mac_addr, addr); 348 349 fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 350 err = dpsw_fdb_remove_unicast(port_priv->ethsw_data->mc_io, 0, 351 port_priv->ethsw_data->dpsw_handle, 352 fdb_id, &entry); 353 /* Silently discard error for calling multiple times the del command */ 354 if (err && err != -ENXIO) 355 netdev_err(port_priv->netdev, 356 "dpsw_fdb_remove_unicast err %d\n", err); 357 return err; 358 } 359 360 static int dpaa2_switch_port_fdb_add_mc(struct ethsw_port_priv *port_priv, 361 const unsigned char *addr) 362 { 363 struct dpsw_fdb_multicast_cfg entry = {0}; 364 u16 fdb_id; 365 int err; 366 367 ether_addr_copy(entry.mac_addr, addr); 368 entry.type = DPSW_FDB_ENTRY_STATIC; 369 entry.num_ifs = 1; 370 entry.if_id[0] = port_priv->idx; 371 372 fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 373 err = dpsw_fdb_add_multicast(port_priv->ethsw_data->mc_io, 0, 374 port_priv->ethsw_data->dpsw_handle, 375 fdb_id, &entry); 376 /* Silently discard error for calling multiple times the add command */ 377 if (err && err != -ENXIO) 378 netdev_err(port_priv->netdev, "dpsw_fdb_add_multicast err %d\n", 379 err); 380 return err; 381 } 382 383 static int dpaa2_switch_port_fdb_del_mc(struct ethsw_port_priv *port_priv, 384 const unsigned char *addr) 385 { 386 struct dpsw_fdb_multicast_cfg entry = {0}; 387 u16 fdb_id; 388 int err; 389 390 ether_addr_copy(entry.mac_addr, addr); 391 entry.type = DPSW_FDB_ENTRY_STATIC; 392 entry.num_ifs = 1; 393 entry.if_id[0] = port_priv->idx; 394 395 fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 396 err = dpsw_fdb_remove_multicast(port_priv->ethsw_data->mc_io, 0, 397 port_priv->ethsw_data->dpsw_handle, 398 fdb_id, &entry); 399 /* Silently discard error for calling multiple times the del command */ 400 if (err && err != -ENAVAIL) 401 netdev_err(port_priv->netdev, 402 "dpsw_fdb_remove_multicast err %d\n", err); 403 return err; 404 } 405 406 static void dpaa2_switch_port_get_stats(struct net_device *netdev, 407 struct rtnl_link_stats64 *stats) 408 { 409 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 410 u64 tmp; 411 int err; 412 413 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 414 port_priv->ethsw_data->dpsw_handle, 415 port_priv->idx, 416 DPSW_CNT_ING_FRAME, &stats->rx_packets); 417 if (err) 418 goto error; 419 420 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 421 port_priv->ethsw_data->dpsw_handle, 422 port_priv->idx, 423 DPSW_CNT_EGR_FRAME, &stats->tx_packets); 424 if (err) 425 goto error; 426 427 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 428 port_priv->ethsw_data->dpsw_handle, 429 port_priv->idx, 430 DPSW_CNT_ING_BYTE, &stats->rx_bytes); 431 if (err) 432 goto error; 433 434 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 435 port_priv->ethsw_data->dpsw_handle, 436 port_priv->idx, 437 DPSW_CNT_EGR_BYTE, &stats->tx_bytes); 438 if (err) 439 goto error; 440 441 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 442 port_priv->ethsw_data->dpsw_handle, 443 port_priv->idx, 444 DPSW_CNT_ING_FRAME_DISCARD, 445 &stats->rx_dropped); 446 if (err) 447 goto error; 448 449 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 450 port_priv->ethsw_data->dpsw_handle, 451 port_priv->idx, 452 DPSW_CNT_ING_FLTR_FRAME, 453 &tmp); 454 if (err) 455 goto error; 456 stats->rx_dropped += tmp; 457 458 err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 459 port_priv->ethsw_data->dpsw_handle, 460 port_priv->idx, 461 DPSW_CNT_EGR_FRAME_DISCARD, 462 &stats->tx_dropped); 463 if (err) 464 goto error; 465 466 return; 467 468 error: 469 netdev_err(netdev, "dpsw_if_get_counter err %d\n", err); 470 } 471 472 static bool dpaa2_switch_port_has_offload_stats(const struct net_device *netdev, 473 int attr_id) 474 { 475 return (attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT); 476 } 477 478 static int dpaa2_switch_port_get_offload_stats(int attr_id, 479 const struct net_device *netdev, 480 void *sp) 481 { 482 switch (attr_id) { 483 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 484 dpaa2_switch_port_get_stats((struct net_device *)netdev, sp); 485 return 0; 486 } 487 488 return -EINVAL; 489 } 490 491 static int dpaa2_switch_port_change_mtu(struct net_device *netdev, int mtu) 492 { 493 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 494 int err; 495 496 err = dpsw_if_set_max_frame_length(port_priv->ethsw_data->mc_io, 497 0, 498 port_priv->ethsw_data->dpsw_handle, 499 port_priv->idx, 500 (u16)ETHSW_L2_MAX_FRM(mtu)); 501 if (err) { 502 netdev_err(netdev, 503 "dpsw_if_set_max_frame_length() err %d\n", err); 504 return err; 505 } 506 507 netdev->mtu = mtu; 508 return 0; 509 } 510 511 static int dpaa2_switch_port_carrier_state_sync(struct net_device *netdev) 512 { 513 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 514 struct dpsw_link_state state; 515 int err; 516 517 /* Interrupts are received even though no one issued an 'ifconfig up' 518 * on the switch interface. Ignore these link state update interrupts 519 */ 520 if (!netif_running(netdev)) 521 return 0; 522 523 err = dpsw_if_get_link_state(port_priv->ethsw_data->mc_io, 0, 524 port_priv->ethsw_data->dpsw_handle, 525 port_priv->idx, &state); 526 if (err) { 527 netdev_err(netdev, "dpsw_if_get_link_state() err %d\n", err); 528 return err; 529 } 530 531 WARN_ONCE(state.up > 1, "Garbage read into link_state"); 532 533 if (state.up != port_priv->link_state) { 534 if (state.up) { 535 netif_carrier_on(netdev); 536 netif_tx_start_all_queues(netdev); 537 } else { 538 netif_carrier_off(netdev); 539 netif_tx_stop_all_queues(netdev); 540 } 541 port_priv->link_state = state.up; 542 } 543 544 return 0; 545 } 546 547 /* Manage all NAPI instances for the control interface. 548 * 549 * We only have one RX queue and one Tx Conf queue for all 550 * switch ports. Therefore, we only need to enable the NAPI instance once, the 551 * first time one of the switch ports runs .dev_open(). 552 */ 553 554 static void dpaa2_switch_enable_ctrl_if_napi(struct ethsw_core *ethsw) 555 { 556 int i; 557 558 /* Access to the ethsw->napi_users relies on the RTNL lock */ 559 ASSERT_RTNL(); 560 561 /* a new interface is using the NAPI instance */ 562 ethsw->napi_users++; 563 564 /* if there is already a user of the instance, return */ 565 if (ethsw->napi_users > 1) 566 return; 567 568 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 569 napi_enable(ðsw->fq[i].napi); 570 } 571 572 static void dpaa2_switch_disable_ctrl_if_napi(struct ethsw_core *ethsw) 573 { 574 int i; 575 576 /* Access to the ethsw->napi_users relies on the RTNL lock */ 577 ASSERT_RTNL(); 578 579 /* If we are not the last interface using the NAPI, return */ 580 ethsw->napi_users--; 581 if (ethsw->napi_users) 582 return; 583 584 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 585 napi_disable(ðsw->fq[i].napi); 586 } 587 588 static int dpaa2_switch_port_open(struct net_device *netdev) 589 { 590 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 591 struct ethsw_core *ethsw = port_priv->ethsw_data; 592 int err; 593 594 /* Explicitly set carrier off, otherwise 595 * netif_carrier_ok() will return true and cause 'ip link show' 596 * to report the LOWER_UP flag, even though the link 597 * notification wasn't even received. 598 */ 599 netif_carrier_off(netdev); 600 601 err = dpsw_if_enable(port_priv->ethsw_data->mc_io, 0, 602 port_priv->ethsw_data->dpsw_handle, 603 port_priv->idx); 604 if (err) { 605 netdev_err(netdev, "dpsw_if_enable err %d\n", err); 606 return err; 607 } 608 609 /* sync carrier state */ 610 err = dpaa2_switch_port_carrier_state_sync(netdev); 611 if (err) { 612 netdev_err(netdev, 613 "dpaa2_switch_port_carrier_state_sync err %d\n", err); 614 goto err_carrier_sync; 615 } 616 617 dpaa2_switch_enable_ctrl_if_napi(ethsw); 618 619 return 0; 620 621 err_carrier_sync: 622 dpsw_if_disable(port_priv->ethsw_data->mc_io, 0, 623 port_priv->ethsw_data->dpsw_handle, 624 port_priv->idx); 625 return err; 626 } 627 628 static int dpaa2_switch_port_stop(struct net_device *netdev) 629 { 630 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 631 struct ethsw_core *ethsw = port_priv->ethsw_data; 632 int err; 633 634 err = dpsw_if_disable(port_priv->ethsw_data->mc_io, 0, 635 port_priv->ethsw_data->dpsw_handle, 636 port_priv->idx); 637 if (err) { 638 netdev_err(netdev, "dpsw_if_disable err %d\n", err); 639 return err; 640 } 641 642 dpaa2_switch_disable_ctrl_if_napi(ethsw); 643 644 return 0; 645 } 646 647 static int dpaa2_switch_port_parent_id(struct net_device *dev, 648 struct netdev_phys_item_id *ppid) 649 { 650 struct ethsw_port_priv *port_priv = netdev_priv(dev); 651 652 ppid->id_len = 1; 653 ppid->id[0] = port_priv->ethsw_data->dev_id; 654 655 return 0; 656 } 657 658 static int dpaa2_switch_port_get_phys_name(struct net_device *netdev, char *name, 659 size_t len) 660 { 661 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 662 int err; 663 664 err = snprintf(name, len, "p%d", port_priv->idx); 665 if (err >= len) 666 return -EINVAL; 667 668 return 0; 669 } 670 671 struct ethsw_dump_ctx { 672 struct net_device *dev; 673 struct sk_buff *skb; 674 struct netlink_callback *cb; 675 int idx; 676 }; 677 678 static int dpaa2_switch_fdb_dump_nl(struct fdb_dump_entry *entry, 679 struct ethsw_dump_ctx *dump) 680 { 681 int is_dynamic = entry->type & DPSW_FDB_ENTRY_DINAMIC; 682 u32 portid = NETLINK_CB(dump->cb->skb).portid; 683 u32 seq = dump->cb->nlh->nlmsg_seq; 684 struct nlmsghdr *nlh; 685 struct ndmsg *ndm; 686 687 if (dump->idx < dump->cb->args[2]) 688 goto skip; 689 690 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 691 sizeof(*ndm), NLM_F_MULTI); 692 if (!nlh) 693 return -EMSGSIZE; 694 695 ndm = nlmsg_data(nlh); 696 ndm->ndm_family = AF_BRIDGE; 697 ndm->ndm_pad1 = 0; 698 ndm->ndm_pad2 = 0; 699 ndm->ndm_flags = NTF_SELF; 700 ndm->ndm_type = 0; 701 ndm->ndm_ifindex = dump->dev->ifindex; 702 ndm->ndm_state = is_dynamic ? NUD_REACHABLE : NUD_NOARP; 703 704 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, entry->mac_addr)) 705 goto nla_put_failure; 706 707 nlmsg_end(dump->skb, nlh); 708 709 skip: 710 dump->idx++; 711 return 0; 712 713 nla_put_failure: 714 nlmsg_cancel(dump->skb, nlh); 715 return -EMSGSIZE; 716 } 717 718 static int dpaa2_switch_port_fdb_valid_entry(struct fdb_dump_entry *entry, 719 struct ethsw_port_priv *port_priv) 720 { 721 int idx = port_priv->idx; 722 int valid; 723 724 if (entry->type & DPSW_FDB_ENTRY_TYPE_UNICAST) 725 valid = entry->if_info == port_priv->idx; 726 else 727 valid = entry->if_mask[idx / 8] & BIT(idx % 8); 728 729 return valid; 730 } 731 732 static int dpaa2_switch_fdb_iterate(struct ethsw_port_priv *port_priv, 733 dpaa2_switch_fdb_cb_t cb, void *data) 734 { 735 struct net_device *net_dev = port_priv->netdev; 736 struct ethsw_core *ethsw = port_priv->ethsw_data; 737 struct device *dev = net_dev->dev.parent; 738 struct fdb_dump_entry *fdb_entries; 739 struct fdb_dump_entry fdb_entry; 740 dma_addr_t fdb_dump_iova; 741 u16 num_fdb_entries; 742 u32 fdb_dump_size; 743 int err = 0, i; 744 u8 *dma_mem; 745 u16 fdb_id; 746 747 fdb_dump_size = ethsw->sw_attr.max_fdb_entries * sizeof(fdb_entry); 748 dma_mem = kzalloc(fdb_dump_size, GFP_KERNEL); 749 if (!dma_mem) 750 return -ENOMEM; 751 752 fdb_dump_iova = dma_map_single(dev, dma_mem, fdb_dump_size, 753 DMA_FROM_DEVICE); 754 if (dma_mapping_error(dev, fdb_dump_iova)) { 755 netdev_err(net_dev, "dma_map_single() failed\n"); 756 err = -ENOMEM; 757 goto err_map; 758 } 759 760 fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 761 err = dpsw_fdb_dump(ethsw->mc_io, 0, ethsw->dpsw_handle, fdb_id, 762 fdb_dump_iova, fdb_dump_size, &num_fdb_entries); 763 if (err) { 764 netdev_err(net_dev, "dpsw_fdb_dump() = %d\n", err); 765 goto err_dump; 766 } 767 768 dma_unmap_single(dev, fdb_dump_iova, fdb_dump_size, DMA_FROM_DEVICE); 769 770 fdb_entries = (struct fdb_dump_entry *)dma_mem; 771 for (i = 0; i < num_fdb_entries; i++) { 772 fdb_entry = fdb_entries[i]; 773 774 err = cb(port_priv, &fdb_entry, data); 775 if (err) 776 goto end; 777 } 778 779 end: 780 kfree(dma_mem); 781 782 return 0; 783 784 err_dump: 785 dma_unmap_single(dev, fdb_dump_iova, fdb_dump_size, DMA_TO_DEVICE); 786 err_map: 787 kfree(dma_mem); 788 return err; 789 } 790 791 static int dpaa2_switch_fdb_entry_dump(struct ethsw_port_priv *port_priv, 792 struct fdb_dump_entry *fdb_entry, 793 void *data) 794 { 795 if (!dpaa2_switch_port_fdb_valid_entry(fdb_entry, port_priv)) 796 return 0; 797 798 return dpaa2_switch_fdb_dump_nl(fdb_entry, data); 799 } 800 801 static int dpaa2_switch_port_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, 802 struct net_device *net_dev, 803 struct net_device *filter_dev, int *idx) 804 { 805 struct ethsw_port_priv *port_priv = netdev_priv(net_dev); 806 struct ethsw_dump_ctx dump = { 807 .dev = net_dev, 808 .skb = skb, 809 .cb = cb, 810 .idx = *idx, 811 }; 812 int err; 813 814 err = dpaa2_switch_fdb_iterate(port_priv, dpaa2_switch_fdb_entry_dump, &dump); 815 *idx = dump.idx; 816 817 return err; 818 } 819 820 static int dpaa2_switch_fdb_entry_fast_age(struct ethsw_port_priv *port_priv, 821 struct fdb_dump_entry *fdb_entry, 822 void *data __always_unused) 823 { 824 if (!dpaa2_switch_port_fdb_valid_entry(fdb_entry, port_priv)) 825 return 0; 826 827 if (!(fdb_entry->type & DPSW_FDB_ENTRY_TYPE_DYNAMIC)) 828 return 0; 829 830 if (fdb_entry->type & DPSW_FDB_ENTRY_TYPE_UNICAST) 831 dpaa2_switch_port_fdb_del_uc(port_priv, fdb_entry->mac_addr); 832 else 833 dpaa2_switch_port_fdb_del_mc(port_priv, fdb_entry->mac_addr); 834 835 return 0; 836 } 837 838 static void dpaa2_switch_port_fast_age(struct ethsw_port_priv *port_priv) 839 { 840 dpaa2_switch_fdb_iterate(port_priv, 841 dpaa2_switch_fdb_entry_fast_age, NULL); 842 } 843 844 static int dpaa2_switch_port_vlan_add(struct net_device *netdev, __be16 proto, 845 u16 vid) 846 { 847 struct switchdev_obj_port_vlan vlan = { 848 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 849 .vid = vid, 850 .obj.orig_dev = netdev, 851 /* This API only allows programming tagged, non-PVID VIDs */ 852 .flags = 0, 853 }; 854 855 return dpaa2_switch_port_vlans_add(netdev, &vlan); 856 } 857 858 static int dpaa2_switch_port_vlan_kill(struct net_device *netdev, __be16 proto, 859 u16 vid) 860 { 861 struct switchdev_obj_port_vlan vlan = { 862 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 863 .vid = vid, 864 .obj.orig_dev = netdev, 865 /* This API only allows programming tagged, non-PVID VIDs */ 866 .flags = 0, 867 }; 868 869 return dpaa2_switch_port_vlans_del(netdev, &vlan); 870 } 871 872 static int dpaa2_switch_port_set_mac_addr(struct ethsw_port_priv *port_priv) 873 { 874 struct ethsw_core *ethsw = port_priv->ethsw_data; 875 struct net_device *net_dev = port_priv->netdev; 876 struct device *dev = net_dev->dev.parent; 877 u8 mac_addr[ETH_ALEN]; 878 int err; 879 880 if (!(ethsw->features & ETHSW_FEATURE_MAC_ADDR)) 881 return 0; 882 883 /* Get firmware address, if any */ 884 err = dpsw_if_get_port_mac_addr(ethsw->mc_io, 0, ethsw->dpsw_handle, 885 port_priv->idx, mac_addr); 886 if (err) { 887 dev_err(dev, "dpsw_if_get_port_mac_addr() failed\n"); 888 return err; 889 } 890 891 /* First check if firmware has any address configured by bootloader */ 892 if (!is_zero_ether_addr(mac_addr)) { 893 memcpy(net_dev->dev_addr, mac_addr, net_dev->addr_len); 894 } else { 895 /* No MAC address configured, fill in net_dev->dev_addr 896 * with a random one 897 */ 898 eth_hw_addr_random(net_dev); 899 dev_dbg_once(dev, "device(s) have all-zero hwaddr, replaced with random\n"); 900 901 /* Override NET_ADDR_RANDOM set by eth_hw_addr_random(); for all 902 * practical purposes, this will be our "permanent" mac address, 903 * at least until the next reboot. This move will also permit 904 * register_netdevice() to properly fill up net_dev->perm_addr. 905 */ 906 net_dev->addr_assign_type = NET_ADDR_PERM; 907 } 908 909 return 0; 910 } 911 912 static void dpaa2_switch_free_fd(const struct ethsw_core *ethsw, 913 const struct dpaa2_fd *fd) 914 { 915 struct device *dev = ethsw->dev; 916 unsigned char *buffer_start; 917 struct sk_buff **skbh, *skb; 918 dma_addr_t fd_addr; 919 920 fd_addr = dpaa2_fd_get_addr(fd); 921 skbh = dpaa2_iova_to_virt(ethsw->iommu_domain, fd_addr); 922 923 skb = *skbh; 924 buffer_start = (unsigned char *)skbh; 925 926 dma_unmap_single(dev, fd_addr, 927 skb_tail_pointer(skb) - buffer_start, 928 DMA_TO_DEVICE); 929 930 /* Move on with skb release */ 931 dev_kfree_skb(skb); 932 } 933 934 static int dpaa2_switch_build_single_fd(struct ethsw_core *ethsw, 935 struct sk_buff *skb, 936 struct dpaa2_fd *fd) 937 { 938 struct device *dev = ethsw->dev; 939 struct sk_buff **skbh; 940 dma_addr_t addr; 941 u8 *buff_start; 942 void *hwa; 943 944 buff_start = PTR_ALIGN(skb->data - DPAA2_SWITCH_TX_DATA_OFFSET - 945 DPAA2_SWITCH_TX_BUF_ALIGN, 946 DPAA2_SWITCH_TX_BUF_ALIGN); 947 948 /* Clear FAS to have consistent values for TX confirmation. It is 949 * located in the first 8 bytes of the buffer's hardware annotation 950 * area 951 */ 952 hwa = buff_start + DPAA2_SWITCH_SWA_SIZE; 953 memset(hwa, 0, 8); 954 955 /* Store a backpointer to the skb at the beginning of the buffer 956 * (in the private data area) such that we can release it 957 * on Tx confirm 958 */ 959 skbh = (struct sk_buff **)buff_start; 960 *skbh = skb; 961 962 addr = dma_map_single(dev, buff_start, 963 skb_tail_pointer(skb) - buff_start, 964 DMA_TO_DEVICE); 965 if (unlikely(dma_mapping_error(dev, addr))) 966 return -ENOMEM; 967 968 /* Setup the FD fields */ 969 memset(fd, 0, sizeof(*fd)); 970 971 dpaa2_fd_set_addr(fd, addr); 972 dpaa2_fd_set_offset(fd, (u16)(skb->data - buff_start)); 973 dpaa2_fd_set_len(fd, skb->len); 974 dpaa2_fd_set_format(fd, dpaa2_fd_single); 975 976 return 0; 977 } 978 979 static netdev_tx_t dpaa2_switch_port_tx(struct sk_buff *skb, 980 struct net_device *net_dev) 981 { 982 struct ethsw_port_priv *port_priv = netdev_priv(net_dev); 983 struct ethsw_core *ethsw = port_priv->ethsw_data; 984 int retries = DPAA2_SWITCH_SWP_BUSY_RETRIES; 985 struct dpaa2_fd fd; 986 int err; 987 988 if (unlikely(skb_headroom(skb) < DPAA2_SWITCH_NEEDED_HEADROOM)) { 989 struct sk_buff *ns; 990 991 ns = skb_realloc_headroom(skb, DPAA2_SWITCH_NEEDED_HEADROOM); 992 if (unlikely(!ns)) { 993 net_err_ratelimited("%s: Error reallocating skb headroom\n", net_dev->name); 994 goto err_free_skb; 995 } 996 dev_consume_skb_any(skb); 997 skb = ns; 998 } 999 1000 /* We'll be holding a back-reference to the skb until Tx confirmation */ 1001 skb = skb_unshare(skb, GFP_ATOMIC); 1002 if (unlikely(!skb)) { 1003 /* skb_unshare() has already freed the skb */ 1004 net_err_ratelimited("%s: Error copying the socket buffer\n", net_dev->name); 1005 goto err_exit; 1006 } 1007 1008 /* At this stage, we do not support non-linear skbs so just try to 1009 * linearize the skb and if that's not working, just drop the packet. 1010 */ 1011 err = skb_linearize(skb); 1012 if (err) { 1013 net_err_ratelimited("%s: skb_linearize error (%d)!\n", net_dev->name, err); 1014 goto err_free_skb; 1015 } 1016 1017 err = dpaa2_switch_build_single_fd(ethsw, skb, &fd); 1018 if (unlikely(err)) { 1019 net_err_ratelimited("%s: ethsw_build_*_fd() %d\n", net_dev->name, err); 1020 goto err_free_skb; 1021 } 1022 1023 do { 1024 err = dpaa2_io_service_enqueue_qd(NULL, 1025 port_priv->tx_qdid, 1026 8, 0, &fd); 1027 retries--; 1028 } while (err == -EBUSY && retries); 1029 1030 if (unlikely(err < 0)) { 1031 dpaa2_switch_free_fd(ethsw, &fd); 1032 goto err_exit; 1033 } 1034 1035 return NETDEV_TX_OK; 1036 1037 err_free_skb: 1038 dev_kfree_skb(skb); 1039 err_exit: 1040 return NETDEV_TX_OK; 1041 } 1042 1043 static const struct net_device_ops dpaa2_switch_port_ops = { 1044 .ndo_open = dpaa2_switch_port_open, 1045 .ndo_stop = dpaa2_switch_port_stop, 1046 1047 .ndo_set_mac_address = eth_mac_addr, 1048 .ndo_get_stats64 = dpaa2_switch_port_get_stats, 1049 .ndo_change_mtu = dpaa2_switch_port_change_mtu, 1050 .ndo_has_offload_stats = dpaa2_switch_port_has_offload_stats, 1051 .ndo_get_offload_stats = dpaa2_switch_port_get_offload_stats, 1052 .ndo_fdb_dump = dpaa2_switch_port_fdb_dump, 1053 .ndo_vlan_rx_add_vid = dpaa2_switch_port_vlan_add, 1054 .ndo_vlan_rx_kill_vid = dpaa2_switch_port_vlan_kill, 1055 1056 .ndo_start_xmit = dpaa2_switch_port_tx, 1057 .ndo_get_port_parent_id = dpaa2_switch_port_parent_id, 1058 .ndo_get_phys_port_name = dpaa2_switch_port_get_phys_name, 1059 }; 1060 1061 bool dpaa2_switch_port_dev_check(const struct net_device *netdev) 1062 { 1063 return netdev->netdev_ops == &dpaa2_switch_port_ops; 1064 } 1065 1066 static void dpaa2_switch_links_state_update(struct ethsw_core *ethsw) 1067 { 1068 int i; 1069 1070 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 1071 dpaa2_switch_port_carrier_state_sync(ethsw->ports[i]->netdev); 1072 dpaa2_switch_port_set_mac_addr(ethsw->ports[i]); 1073 } 1074 } 1075 1076 static irqreturn_t dpaa2_switch_irq0_handler_thread(int irq_num, void *arg) 1077 { 1078 struct device *dev = (struct device *)arg; 1079 struct ethsw_core *ethsw = dev_get_drvdata(dev); 1080 1081 /* Mask the events and the if_id reserved bits to be cleared on read */ 1082 u32 status = DPSW_IRQ_EVENT_LINK_CHANGED | 0xFFFF0000; 1083 int err; 1084 1085 err = dpsw_get_irq_status(ethsw->mc_io, 0, ethsw->dpsw_handle, 1086 DPSW_IRQ_INDEX_IF, &status); 1087 if (err) { 1088 dev_err(dev, "Can't get irq status (err %d)\n", err); 1089 1090 err = dpsw_clear_irq_status(ethsw->mc_io, 0, ethsw->dpsw_handle, 1091 DPSW_IRQ_INDEX_IF, 0xFFFFFFFF); 1092 if (err) 1093 dev_err(dev, "Can't clear irq status (err %d)\n", err); 1094 goto out; 1095 } 1096 1097 if (status & DPSW_IRQ_EVENT_LINK_CHANGED) 1098 dpaa2_switch_links_state_update(ethsw); 1099 1100 out: 1101 return IRQ_HANDLED; 1102 } 1103 1104 static int dpaa2_switch_setup_irqs(struct fsl_mc_device *sw_dev) 1105 { 1106 struct device *dev = &sw_dev->dev; 1107 struct ethsw_core *ethsw = dev_get_drvdata(dev); 1108 u32 mask = DPSW_IRQ_EVENT_LINK_CHANGED; 1109 struct fsl_mc_device_irq *irq; 1110 int err; 1111 1112 err = fsl_mc_allocate_irqs(sw_dev); 1113 if (err) { 1114 dev_err(dev, "MC irqs allocation failed\n"); 1115 return err; 1116 } 1117 1118 if (WARN_ON(sw_dev->obj_desc.irq_count != DPSW_IRQ_NUM)) { 1119 err = -EINVAL; 1120 goto free_irq; 1121 } 1122 1123 err = dpsw_set_irq_enable(ethsw->mc_io, 0, ethsw->dpsw_handle, 1124 DPSW_IRQ_INDEX_IF, 0); 1125 if (err) { 1126 dev_err(dev, "dpsw_set_irq_enable err %d\n", err); 1127 goto free_irq; 1128 } 1129 1130 irq = sw_dev->irqs[DPSW_IRQ_INDEX_IF]; 1131 1132 err = devm_request_threaded_irq(dev, irq->msi_desc->irq, 1133 NULL, 1134 dpaa2_switch_irq0_handler_thread, 1135 IRQF_NO_SUSPEND | IRQF_ONESHOT, 1136 dev_name(dev), dev); 1137 if (err) { 1138 dev_err(dev, "devm_request_threaded_irq(): %d\n", err); 1139 goto free_irq; 1140 } 1141 1142 err = dpsw_set_irq_mask(ethsw->mc_io, 0, ethsw->dpsw_handle, 1143 DPSW_IRQ_INDEX_IF, mask); 1144 if (err) { 1145 dev_err(dev, "dpsw_set_irq_mask(): %d\n", err); 1146 goto free_devm_irq; 1147 } 1148 1149 err = dpsw_set_irq_enable(ethsw->mc_io, 0, ethsw->dpsw_handle, 1150 DPSW_IRQ_INDEX_IF, 1); 1151 if (err) { 1152 dev_err(dev, "dpsw_set_irq_enable(): %d\n", err); 1153 goto free_devm_irq; 1154 } 1155 1156 return 0; 1157 1158 free_devm_irq: 1159 devm_free_irq(dev, irq->msi_desc->irq, dev); 1160 free_irq: 1161 fsl_mc_free_irqs(sw_dev); 1162 return err; 1163 } 1164 1165 static void dpaa2_switch_teardown_irqs(struct fsl_mc_device *sw_dev) 1166 { 1167 struct device *dev = &sw_dev->dev; 1168 struct ethsw_core *ethsw = dev_get_drvdata(dev); 1169 int err; 1170 1171 err = dpsw_set_irq_enable(ethsw->mc_io, 0, ethsw->dpsw_handle, 1172 DPSW_IRQ_INDEX_IF, 0); 1173 if (err) 1174 dev_err(dev, "dpsw_set_irq_enable err %d\n", err); 1175 1176 fsl_mc_free_irqs(sw_dev); 1177 } 1178 1179 static int dpaa2_switch_port_attr_stp_state_set(struct net_device *netdev, 1180 u8 state) 1181 { 1182 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1183 1184 return dpaa2_switch_port_set_stp_state(port_priv, state); 1185 } 1186 1187 static int dpaa2_switch_port_attr_set(struct net_device *netdev, 1188 const struct switchdev_attr *attr, 1189 struct netlink_ext_ack *extack) 1190 { 1191 int err = 0; 1192 1193 switch (attr->id) { 1194 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 1195 err = dpaa2_switch_port_attr_stp_state_set(netdev, 1196 attr->u.stp_state); 1197 break; 1198 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 1199 if (!attr->u.vlan_filtering) { 1200 NL_SET_ERR_MSG_MOD(extack, 1201 "The DPAA2 switch does not support VLAN-unaware operation"); 1202 return -EOPNOTSUPP; 1203 } 1204 break; 1205 default: 1206 err = -EOPNOTSUPP; 1207 break; 1208 } 1209 1210 return err; 1211 } 1212 1213 int dpaa2_switch_port_vlans_add(struct net_device *netdev, 1214 const struct switchdev_obj_port_vlan *vlan) 1215 { 1216 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1217 struct ethsw_core *ethsw = port_priv->ethsw_data; 1218 struct dpsw_attr *attr = ðsw->sw_attr; 1219 int err = 0; 1220 1221 /* Make sure that the VLAN is not already configured 1222 * on the switch port 1223 */ 1224 if (port_priv->vlans[vlan->vid] & ETHSW_VLAN_MEMBER) 1225 return -EEXIST; 1226 1227 /* Check if there is space for a new VLAN */ 1228 err = dpsw_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 1229 ðsw->sw_attr); 1230 if (err) { 1231 netdev_err(netdev, "dpsw_get_attributes err %d\n", err); 1232 return err; 1233 } 1234 if (attr->max_vlans - attr->num_vlans < 1) 1235 return -ENOSPC; 1236 1237 /* Check if there is space for a new VLAN */ 1238 err = dpsw_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 1239 ðsw->sw_attr); 1240 if (err) { 1241 netdev_err(netdev, "dpsw_get_attributes err %d\n", err); 1242 return err; 1243 } 1244 if (attr->max_vlans - attr->num_vlans < 1) 1245 return -ENOSPC; 1246 1247 if (!port_priv->ethsw_data->vlans[vlan->vid]) { 1248 /* this is a new VLAN */ 1249 err = dpaa2_switch_add_vlan(port_priv, vlan->vid); 1250 if (err) 1251 return err; 1252 1253 port_priv->ethsw_data->vlans[vlan->vid] |= ETHSW_VLAN_GLOBAL; 1254 } 1255 1256 return dpaa2_switch_port_add_vlan(port_priv, vlan->vid, vlan->flags); 1257 } 1258 1259 static int dpaa2_switch_port_lookup_address(struct net_device *netdev, int is_uc, 1260 const unsigned char *addr) 1261 { 1262 struct netdev_hw_addr_list *list = (is_uc) ? &netdev->uc : &netdev->mc; 1263 struct netdev_hw_addr *ha; 1264 1265 netif_addr_lock_bh(netdev); 1266 list_for_each_entry(ha, &list->list, list) { 1267 if (ether_addr_equal(ha->addr, addr)) { 1268 netif_addr_unlock_bh(netdev); 1269 return 1; 1270 } 1271 } 1272 netif_addr_unlock_bh(netdev); 1273 return 0; 1274 } 1275 1276 static int dpaa2_switch_port_mdb_add(struct net_device *netdev, 1277 const struct switchdev_obj_port_mdb *mdb) 1278 { 1279 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1280 int err; 1281 1282 /* Check if address is already set on this port */ 1283 if (dpaa2_switch_port_lookup_address(netdev, 0, mdb->addr)) 1284 return -EEXIST; 1285 1286 err = dpaa2_switch_port_fdb_add_mc(port_priv, mdb->addr); 1287 if (err) 1288 return err; 1289 1290 err = dev_mc_add(netdev, mdb->addr); 1291 if (err) { 1292 netdev_err(netdev, "dev_mc_add err %d\n", err); 1293 dpaa2_switch_port_fdb_del_mc(port_priv, mdb->addr); 1294 } 1295 1296 return err; 1297 } 1298 1299 static int dpaa2_switch_port_obj_add(struct net_device *netdev, 1300 const struct switchdev_obj *obj) 1301 { 1302 int err; 1303 1304 switch (obj->id) { 1305 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1306 err = dpaa2_switch_port_vlans_add(netdev, 1307 SWITCHDEV_OBJ_PORT_VLAN(obj)); 1308 break; 1309 case SWITCHDEV_OBJ_ID_PORT_MDB: 1310 err = dpaa2_switch_port_mdb_add(netdev, 1311 SWITCHDEV_OBJ_PORT_MDB(obj)); 1312 break; 1313 default: 1314 err = -EOPNOTSUPP; 1315 break; 1316 } 1317 1318 return err; 1319 } 1320 1321 static int dpaa2_switch_port_del_vlan(struct ethsw_port_priv *port_priv, u16 vid) 1322 { 1323 struct ethsw_core *ethsw = port_priv->ethsw_data; 1324 struct net_device *netdev = port_priv->netdev; 1325 struct dpsw_vlan_if_cfg vcfg; 1326 int i, err; 1327 1328 if (!port_priv->vlans[vid]) 1329 return -ENOENT; 1330 1331 if (port_priv->vlans[vid] & ETHSW_VLAN_PVID) { 1332 /* If we are deleting the PVID of a port, use VLAN 4095 instead 1333 * as we are sure that neither the bridge nor the 8021q module 1334 * will use it 1335 */ 1336 err = dpaa2_switch_port_set_pvid(port_priv, 4095); 1337 if (err) 1338 return err; 1339 } 1340 1341 vcfg.num_ifs = 1; 1342 vcfg.if_id[0] = port_priv->idx; 1343 if (port_priv->vlans[vid] & ETHSW_VLAN_UNTAGGED) { 1344 err = dpsw_vlan_remove_if_untagged(ethsw->mc_io, 0, 1345 ethsw->dpsw_handle, 1346 vid, &vcfg); 1347 if (err) { 1348 netdev_err(netdev, 1349 "dpsw_vlan_remove_if_untagged err %d\n", 1350 err); 1351 } 1352 port_priv->vlans[vid] &= ~ETHSW_VLAN_UNTAGGED; 1353 } 1354 1355 if (port_priv->vlans[vid] & ETHSW_VLAN_MEMBER) { 1356 err = dpsw_vlan_remove_if(ethsw->mc_io, 0, ethsw->dpsw_handle, 1357 vid, &vcfg); 1358 if (err) { 1359 netdev_err(netdev, 1360 "dpsw_vlan_remove_if err %d\n", err); 1361 return err; 1362 } 1363 port_priv->vlans[vid] &= ~ETHSW_VLAN_MEMBER; 1364 1365 /* Delete VLAN from switch if it is no longer configured on 1366 * any port 1367 */ 1368 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) 1369 if (ethsw->ports[i]->vlans[vid] & ETHSW_VLAN_MEMBER) 1370 return 0; /* Found a port member in VID */ 1371 1372 ethsw->vlans[vid] &= ~ETHSW_VLAN_GLOBAL; 1373 1374 err = dpaa2_switch_dellink(ethsw, vid); 1375 if (err) 1376 return err; 1377 } 1378 1379 return 0; 1380 } 1381 1382 int dpaa2_switch_port_vlans_del(struct net_device *netdev, 1383 const struct switchdev_obj_port_vlan *vlan) 1384 { 1385 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1386 1387 if (netif_is_bridge_master(vlan->obj.orig_dev)) 1388 return -EOPNOTSUPP; 1389 1390 return dpaa2_switch_port_del_vlan(port_priv, vlan->vid); 1391 } 1392 1393 static int dpaa2_switch_port_mdb_del(struct net_device *netdev, 1394 const struct switchdev_obj_port_mdb *mdb) 1395 { 1396 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1397 int err; 1398 1399 if (!dpaa2_switch_port_lookup_address(netdev, 0, mdb->addr)) 1400 return -ENOENT; 1401 1402 err = dpaa2_switch_port_fdb_del_mc(port_priv, mdb->addr); 1403 if (err) 1404 return err; 1405 1406 err = dev_mc_del(netdev, mdb->addr); 1407 if (err) { 1408 netdev_err(netdev, "dev_mc_del err %d\n", err); 1409 return err; 1410 } 1411 1412 return err; 1413 } 1414 1415 static int dpaa2_switch_port_obj_del(struct net_device *netdev, 1416 const struct switchdev_obj *obj) 1417 { 1418 int err; 1419 1420 switch (obj->id) { 1421 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1422 err = dpaa2_switch_port_vlans_del(netdev, SWITCHDEV_OBJ_PORT_VLAN(obj)); 1423 break; 1424 case SWITCHDEV_OBJ_ID_PORT_MDB: 1425 err = dpaa2_switch_port_mdb_del(netdev, SWITCHDEV_OBJ_PORT_MDB(obj)); 1426 break; 1427 default: 1428 err = -EOPNOTSUPP; 1429 break; 1430 } 1431 return err; 1432 } 1433 1434 static int dpaa2_switch_port_attr_set_event(struct net_device *netdev, 1435 struct switchdev_notifier_port_attr_info *ptr) 1436 { 1437 int err; 1438 1439 err = switchdev_handle_port_attr_set(netdev, ptr, 1440 dpaa2_switch_port_dev_check, 1441 dpaa2_switch_port_attr_set); 1442 return notifier_from_errno(err); 1443 } 1444 1445 static int dpaa2_switch_fdb_set_egress_flood(struct ethsw_core *ethsw, u16 fdb_id) 1446 { 1447 struct dpsw_egress_flood_cfg flood_cfg; 1448 int i = 0, j; 1449 int err; 1450 1451 /* Add all the DPAA2 switch ports found in the same bridging domain to 1452 * the egress flooding domain 1453 */ 1454 for (j = 0; j < ethsw->sw_attr.num_ifs; j++) 1455 if (ethsw->ports[j] && ethsw->ports[j]->fdb->fdb_id == fdb_id) 1456 flood_cfg.if_id[i++] = ethsw->ports[j]->idx; 1457 1458 /* Add the CTRL interface to the egress flooding domain */ 1459 flood_cfg.if_id[i++] = ethsw->sw_attr.num_ifs; 1460 1461 /* Use the FDB of the first dpaa2 switch port added to the bridge */ 1462 flood_cfg.fdb_id = fdb_id; 1463 1464 /* Setup broadcast flooding domain */ 1465 flood_cfg.flood_type = DPSW_BROADCAST; 1466 flood_cfg.num_ifs = i; 1467 err = dpsw_set_egress_flood(ethsw->mc_io, 0, ethsw->dpsw_handle, 1468 &flood_cfg); 1469 if (err) { 1470 dev_err(ethsw->dev, "dpsw_set_egress_flood() = %d\n", err); 1471 return err; 1472 } 1473 1474 /* Setup unknown flooding domain */ 1475 flood_cfg.flood_type = DPSW_FLOODING; 1476 flood_cfg.num_ifs = i; 1477 err = dpsw_set_egress_flood(ethsw->mc_io, 0, ethsw->dpsw_handle, 1478 &flood_cfg); 1479 if (err) { 1480 dev_err(ethsw->dev, "dpsw_set_egress_flood() = %d\n", err); 1481 return err; 1482 } 1483 1484 return 0; 1485 } 1486 1487 static int dpaa2_switch_port_bridge_join(struct net_device *netdev, 1488 struct net_device *upper_dev) 1489 { 1490 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1491 struct ethsw_core *ethsw = port_priv->ethsw_data; 1492 struct ethsw_port_priv *other_port_priv; 1493 struct net_device *other_dev; 1494 struct list_head *iter; 1495 int err; 1496 1497 netdev_for_each_lower_dev(upper_dev, other_dev, iter) { 1498 if (!dpaa2_switch_port_dev_check(other_dev)) 1499 continue; 1500 1501 other_port_priv = netdev_priv(other_dev); 1502 if (other_port_priv->ethsw_data != port_priv->ethsw_data) { 1503 netdev_err(netdev, 1504 "Interface from a different DPSW is in the bridge already!\n"); 1505 return -EINVAL; 1506 } 1507 } 1508 1509 /* Delete the previously manually installed VLAN 1 */ 1510 err = dpaa2_switch_port_del_vlan(port_priv, 1); 1511 if (err) 1512 return err; 1513 1514 dpaa2_switch_port_set_fdb(port_priv, upper_dev); 1515 1516 /* Setup the egress flood policy (broadcast, unknown unicast) */ 1517 err = dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 1518 if (err) 1519 goto err_egress_flood; 1520 1521 return 0; 1522 1523 err_egress_flood: 1524 dpaa2_switch_port_set_fdb(port_priv, NULL); 1525 return err; 1526 } 1527 1528 static int dpaa2_switch_port_clear_rxvlan(struct net_device *vdev, int vid, void *arg) 1529 { 1530 __be16 vlan_proto = htons(ETH_P_8021Q); 1531 1532 if (vdev) 1533 vlan_proto = vlan_dev_vlan_proto(vdev); 1534 1535 return dpaa2_switch_port_vlan_kill(arg, vlan_proto, vid); 1536 } 1537 1538 static int dpaa2_switch_port_restore_rxvlan(struct net_device *vdev, int vid, void *arg) 1539 { 1540 __be16 vlan_proto = htons(ETH_P_8021Q); 1541 1542 if (vdev) 1543 vlan_proto = vlan_dev_vlan_proto(vdev); 1544 1545 return dpaa2_switch_port_vlan_add(arg, vlan_proto, vid); 1546 } 1547 1548 static int dpaa2_switch_port_bridge_leave(struct net_device *netdev) 1549 { 1550 struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1551 struct dpaa2_switch_fdb *old_fdb = port_priv->fdb; 1552 struct ethsw_core *ethsw = port_priv->ethsw_data; 1553 int err; 1554 1555 /* First of all, fast age any learn FDB addresses on this switch port */ 1556 dpaa2_switch_port_fast_age(port_priv); 1557 1558 /* Clear all RX VLANs installed through vlan_vid_add() either as VLAN 1559 * upper devices or otherwise from the FDB table that we are about to 1560 * leave 1561 */ 1562 err = vlan_for_each(netdev, dpaa2_switch_port_clear_rxvlan, netdev); 1563 if (err) 1564 netdev_err(netdev, "Unable to clear RX VLANs from old FDB table, err (%d)\n", err); 1565 1566 dpaa2_switch_port_set_fdb(port_priv, NULL); 1567 1568 /* Restore all RX VLANs into the new FDB table that we just joined */ 1569 err = vlan_for_each(netdev, dpaa2_switch_port_restore_rxvlan, netdev); 1570 if (err) 1571 netdev_err(netdev, "Unable to restore RX VLANs to the new FDB, err (%d)\n", err); 1572 1573 /* Setup the egress flood policy (broadcast, unknown unicast). 1574 * When the port is not under a bridge, only the CTRL interface is part 1575 * of the flooding domain besides the actual port 1576 */ 1577 err = dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 1578 if (err) 1579 return err; 1580 1581 /* Recreate the egress flood domain of the FDB that we just left */ 1582 err = dpaa2_switch_fdb_set_egress_flood(ethsw, old_fdb->fdb_id); 1583 if (err) 1584 return err; 1585 1586 /* Add the VLAN 1 as PVID when not under a bridge. We need this since 1587 * the dpaa2 switch interfaces are not capable to be VLAN unaware 1588 */ 1589 return dpaa2_switch_port_add_vlan(port_priv, DEFAULT_VLAN_ID, 1590 BRIDGE_VLAN_INFO_UNTAGGED | BRIDGE_VLAN_INFO_PVID); 1591 } 1592 1593 static int dpaa2_switch_prevent_bridging_with_8021q_upper(struct net_device *netdev) 1594 { 1595 struct net_device *upper_dev; 1596 struct list_head *iter; 1597 1598 /* RCU read lock not necessary because we have write-side protection 1599 * (rtnl_mutex), however a non-rcu iterator does not exist. 1600 */ 1601 netdev_for_each_upper_dev_rcu(netdev, upper_dev, iter) 1602 if (is_vlan_dev(upper_dev)) 1603 return -EOPNOTSUPP; 1604 1605 return 0; 1606 } 1607 1608 static int dpaa2_switch_port_netdevice_event(struct notifier_block *nb, 1609 unsigned long event, void *ptr) 1610 { 1611 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 1612 struct netdev_notifier_changeupper_info *info = ptr; 1613 struct netlink_ext_ack *extack; 1614 struct net_device *upper_dev; 1615 int err = 0; 1616 1617 if (!dpaa2_switch_port_dev_check(netdev)) 1618 return NOTIFY_DONE; 1619 1620 extack = netdev_notifier_info_to_extack(&info->info); 1621 1622 switch (event) { 1623 case NETDEV_PRECHANGEUPPER: 1624 upper_dev = info->upper_dev; 1625 if (!netif_is_bridge_master(upper_dev)) 1626 break; 1627 1628 if (!br_vlan_enabled(upper_dev)) { 1629 NL_SET_ERR_MSG_MOD(extack, "Cannot join a VLAN-unaware bridge"); 1630 err = -EOPNOTSUPP; 1631 goto out; 1632 } 1633 1634 err = dpaa2_switch_prevent_bridging_with_8021q_upper(netdev); 1635 if (err) { 1636 NL_SET_ERR_MSG_MOD(extack, 1637 "Cannot join a bridge while VLAN uppers are present"); 1638 goto out; 1639 } 1640 1641 break; 1642 case NETDEV_CHANGEUPPER: 1643 upper_dev = info->upper_dev; 1644 if (netif_is_bridge_master(upper_dev)) { 1645 if (info->linking) 1646 err = dpaa2_switch_port_bridge_join(netdev, upper_dev); 1647 else 1648 err = dpaa2_switch_port_bridge_leave(netdev); 1649 } 1650 break; 1651 } 1652 1653 out: 1654 return notifier_from_errno(err); 1655 } 1656 1657 struct ethsw_switchdev_event_work { 1658 struct work_struct work; 1659 struct switchdev_notifier_fdb_info fdb_info; 1660 struct net_device *dev; 1661 unsigned long event; 1662 }; 1663 1664 static void dpaa2_switch_event_work(struct work_struct *work) 1665 { 1666 struct ethsw_switchdev_event_work *switchdev_work = 1667 container_of(work, struct ethsw_switchdev_event_work, work); 1668 struct net_device *dev = switchdev_work->dev; 1669 struct switchdev_notifier_fdb_info *fdb_info; 1670 int err; 1671 1672 rtnl_lock(); 1673 fdb_info = &switchdev_work->fdb_info; 1674 1675 switch (switchdev_work->event) { 1676 case SWITCHDEV_FDB_ADD_TO_DEVICE: 1677 if (!fdb_info->added_by_user) 1678 break; 1679 if (is_unicast_ether_addr(fdb_info->addr)) 1680 err = dpaa2_switch_port_fdb_add_uc(netdev_priv(dev), 1681 fdb_info->addr); 1682 else 1683 err = dpaa2_switch_port_fdb_add_mc(netdev_priv(dev), 1684 fdb_info->addr); 1685 if (err) 1686 break; 1687 fdb_info->offloaded = true; 1688 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev, 1689 &fdb_info->info, NULL); 1690 break; 1691 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1692 if (!fdb_info->added_by_user) 1693 break; 1694 if (is_unicast_ether_addr(fdb_info->addr)) 1695 dpaa2_switch_port_fdb_del_uc(netdev_priv(dev), fdb_info->addr); 1696 else 1697 dpaa2_switch_port_fdb_del_mc(netdev_priv(dev), fdb_info->addr); 1698 break; 1699 } 1700 1701 rtnl_unlock(); 1702 kfree(switchdev_work->fdb_info.addr); 1703 kfree(switchdev_work); 1704 dev_put(dev); 1705 } 1706 1707 /* Called under rcu_read_lock() */ 1708 static int dpaa2_switch_port_event(struct notifier_block *nb, 1709 unsigned long event, void *ptr) 1710 { 1711 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1712 struct ethsw_port_priv *port_priv = netdev_priv(dev); 1713 struct ethsw_switchdev_event_work *switchdev_work; 1714 struct switchdev_notifier_fdb_info *fdb_info = ptr; 1715 struct ethsw_core *ethsw = port_priv->ethsw_data; 1716 1717 if (event == SWITCHDEV_PORT_ATTR_SET) 1718 return dpaa2_switch_port_attr_set_event(dev, ptr); 1719 1720 if (!dpaa2_switch_port_dev_check(dev)) 1721 return NOTIFY_DONE; 1722 1723 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 1724 if (!switchdev_work) 1725 return NOTIFY_BAD; 1726 1727 INIT_WORK(&switchdev_work->work, dpaa2_switch_event_work); 1728 switchdev_work->dev = dev; 1729 switchdev_work->event = event; 1730 1731 switch (event) { 1732 case SWITCHDEV_FDB_ADD_TO_DEVICE: 1733 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1734 memcpy(&switchdev_work->fdb_info, ptr, 1735 sizeof(switchdev_work->fdb_info)); 1736 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 1737 if (!switchdev_work->fdb_info.addr) 1738 goto err_addr_alloc; 1739 1740 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, 1741 fdb_info->addr); 1742 1743 /* Take a reference on the device to avoid being freed. */ 1744 dev_hold(dev); 1745 break; 1746 default: 1747 kfree(switchdev_work); 1748 return NOTIFY_DONE; 1749 } 1750 1751 queue_work(ethsw->workqueue, &switchdev_work->work); 1752 1753 return NOTIFY_DONE; 1754 1755 err_addr_alloc: 1756 kfree(switchdev_work); 1757 return NOTIFY_BAD; 1758 } 1759 1760 static int dpaa2_switch_port_obj_event(unsigned long event, 1761 struct net_device *netdev, 1762 struct switchdev_notifier_port_obj_info *port_obj_info) 1763 { 1764 int err = -EOPNOTSUPP; 1765 1766 if (!dpaa2_switch_port_dev_check(netdev)) 1767 return NOTIFY_DONE; 1768 1769 switch (event) { 1770 case SWITCHDEV_PORT_OBJ_ADD: 1771 err = dpaa2_switch_port_obj_add(netdev, port_obj_info->obj); 1772 break; 1773 case SWITCHDEV_PORT_OBJ_DEL: 1774 err = dpaa2_switch_port_obj_del(netdev, port_obj_info->obj); 1775 break; 1776 } 1777 1778 port_obj_info->handled = true; 1779 return notifier_from_errno(err); 1780 } 1781 1782 static int dpaa2_switch_port_blocking_event(struct notifier_block *nb, 1783 unsigned long event, void *ptr) 1784 { 1785 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1786 1787 switch (event) { 1788 case SWITCHDEV_PORT_OBJ_ADD: 1789 case SWITCHDEV_PORT_OBJ_DEL: 1790 return dpaa2_switch_port_obj_event(event, dev, ptr); 1791 case SWITCHDEV_PORT_ATTR_SET: 1792 return dpaa2_switch_port_attr_set_event(dev, ptr); 1793 } 1794 1795 return NOTIFY_DONE; 1796 } 1797 1798 /* Build a linear skb based on a single-buffer frame descriptor */ 1799 static struct sk_buff *dpaa2_switch_build_linear_skb(struct ethsw_core *ethsw, 1800 const struct dpaa2_fd *fd) 1801 { 1802 u16 fd_offset = dpaa2_fd_get_offset(fd); 1803 dma_addr_t addr = dpaa2_fd_get_addr(fd); 1804 u32 fd_length = dpaa2_fd_get_len(fd); 1805 struct device *dev = ethsw->dev; 1806 struct sk_buff *skb = NULL; 1807 void *fd_vaddr; 1808 1809 fd_vaddr = dpaa2_iova_to_virt(ethsw->iommu_domain, addr); 1810 dma_unmap_page(dev, addr, DPAA2_SWITCH_RX_BUF_SIZE, 1811 DMA_FROM_DEVICE); 1812 1813 skb = build_skb(fd_vaddr, DPAA2_SWITCH_RX_BUF_SIZE + 1814 SKB_DATA_ALIGN(sizeof(struct skb_shared_info))); 1815 if (unlikely(!skb)) { 1816 dev_err(dev, "build_skb() failed\n"); 1817 return NULL; 1818 } 1819 1820 skb_reserve(skb, fd_offset); 1821 skb_put(skb, fd_length); 1822 1823 ethsw->buf_count--; 1824 1825 return skb; 1826 } 1827 1828 static void dpaa2_switch_tx_conf(struct dpaa2_switch_fq *fq, 1829 const struct dpaa2_fd *fd) 1830 { 1831 dpaa2_switch_free_fd(fq->ethsw, fd); 1832 } 1833 1834 static void dpaa2_switch_rx(struct dpaa2_switch_fq *fq, 1835 const struct dpaa2_fd *fd) 1836 { 1837 struct ethsw_core *ethsw = fq->ethsw; 1838 struct ethsw_port_priv *port_priv; 1839 struct net_device *netdev; 1840 struct vlan_ethhdr *hdr; 1841 struct sk_buff *skb; 1842 u16 vlan_tci, vid; 1843 int if_id, err; 1844 1845 /* get switch ingress interface ID */ 1846 if_id = upper_32_bits(dpaa2_fd_get_flc(fd)) & 0x0000FFFF; 1847 1848 if (if_id >= ethsw->sw_attr.num_ifs) { 1849 dev_err(ethsw->dev, "Frame received from unknown interface!\n"); 1850 goto err_free_fd; 1851 } 1852 port_priv = ethsw->ports[if_id]; 1853 netdev = port_priv->netdev; 1854 1855 /* build the SKB based on the FD received */ 1856 if (dpaa2_fd_get_format(fd) != dpaa2_fd_single) { 1857 if (net_ratelimit()) { 1858 netdev_err(netdev, "Received invalid frame format\n"); 1859 goto err_free_fd; 1860 } 1861 } 1862 1863 skb = dpaa2_switch_build_linear_skb(ethsw, fd); 1864 if (unlikely(!skb)) 1865 goto err_free_fd; 1866 1867 skb_reset_mac_header(skb); 1868 1869 /* Remove the VLAN header if the packet that we just received has a vid 1870 * equal to the port PVIDs. Since the dpaa2-switch can operate only in 1871 * VLAN-aware mode and no alterations are made on the packet when it's 1872 * redirected/mirrored to the control interface, we are sure that there 1873 * will always be a VLAN header present. 1874 */ 1875 hdr = vlan_eth_hdr(skb); 1876 vid = ntohs(hdr->h_vlan_TCI) & VLAN_VID_MASK; 1877 if (vid == port_priv->pvid) { 1878 err = __skb_vlan_pop(skb, &vlan_tci); 1879 if (err) { 1880 dev_info(ethsw->dev, "__skb_vlan_pop() returned %d", err); 1881 goto err_free_fd; 1882 } 1883 } 1884 1885 skb->dev = netdev; 1886 skb->protocol = eth_type_trans(skb, skb->dev); 1887 1888 netif_receive_skb(skb); 1889 1890 return; 1891 1892 err_free_fd: 1893 dpaa2_switch_free_fd(ethsw, fd); 1894 } 1895 1896 static void dpaa2_switch_detect_features(struct ethsw_core *ethsw) 1897 { 1898 ethsw->features = 0; 1899 1900 if (ethsw->major > 8 || (ethsw->major == 8 && ethsw->minor >= 6)) 1901 ethsw->features |= ETHSW_FEATURE_MAC_ADDR; 1902 } 1903 1904 static int dpaa2_switch_setup_fqs(struct ethsw_core *ethsw) 1905 { 1906 struct dpsw_ctrl_if_attr ctrl_if_attr; 1907 struct device *dev = ethsw->dev; 1908 int i = 0; 1909 int err; 1910 1911 err = dpsw_ctrl_if_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 1912 &ctrl_if_attr); 1913 if (err) { 1914 dev_err(dev, "dpsw_ctrl_if_get_attributes() = %d\n", err); 1915 return err; 1916 } 1917 1918 ethsw->fq[i].fqid = ctrl_if_attr.rx_fqid; 1919 ethsw->fq[i].ethsw = ethsw; 1920 ethsw->fq[i++].type = DPSW_QUEUE_RX; 1921 1922 ethsw->fq[i].fqid = ctrl_if_attr.tx_err_conf_fqid; 1923 ethsw->fq[i].ethsw = ethsw; 1924 ethsw->fq[i++].type = DPSW_QUEUE_TX_ERR_CONF; 1925 1926 return 0; 1927 } 1928 1929 /* Free buffers acquired from the buffer pool or which were meant to 1930 * be released in the pool 1931 */ 1932 static void dpaa2_switch_free_bufs(struct ethsw_core *ethsw, u64 *buf_array, int count) 1933 { 1934 struct device *dev = ethsw->dev; 1935 void *vaddr; 1936 int i; 1937 1938 for (i = 0; i < count; i++) { 1939 vaddr = dpaa2_iova_to_virt(ethsw->iommu_domain, buf_array[i]); 1940 dma_unmap_page(dev, buf_array[i], DPAA2_SWITCH_RX_BUF_SIZE, 1941 DMA_FROM_DEVICE); 1942 free_pages((unsigned long)vaddr, 0); 1943 } 1944 } 1945 1946 /* Perform a single release command to add buffers 1947 * to the specified buffer pool 1948 */ 1949 static int dpaa2_switch_add_bufs(struct ethsw_core *ethsw, u16 bpid) 1950 { 1951 struct device *dev = ethsw->dev; 1952 u64 buf_array[BUFS_PER_CMD]; 1953 struct page *page; 1954 int retries = 0; 1955 dma_addr_t addr; 1956 int err; 1957 int i; 1958 1959 for (i = 0; i < BUFS_PER_CMD; i++) { 1960 /* Allocate one page for each Rx buffer. WRIOP sees 1961 * the entire page except for a tailroom reserved for 1962 * skb shared info 1963 */ 1964 page = dev_alloc_pages(0); 1965 if (!page) { 1966 dev_err(dev, "buffer allocation failed\n"); 1967 goto err_alloc; 1968 } 1969 1970 addr = dma_map_page(dev, page, 0, DPAA2_SWITCH_RX_BUF_SIZE, 1971 DMA_FROM_DEVICE); 1972 if (dma_mapping_error(dev, addr)) { 1973 dev_err(dev, "dma_map_single() failed\n"); 1974 goto err_map; 1975 } 1976 buf_array[i] = addr; 1977 } 1978 1979 release_bufs: 1980 /* In case the portal is busy, retry until successful or 1981 * max retries hit. 1982 */ 1983 while ((err = dpaa2_io_service_release(NULL, bpid, 1984 buf_array, i)) == -EBUSY) { 1985 if (retries++ >= DPAA2_SWITCH_SWP_BUSY_RETRIES) 1986 break; 1987 1988 cpu_relax(); 1989 } 1990 1991 /* If release command failed, clean up and bail out. */ 1992 if (err) { 1993 dpaa2_switch_free_bufs(ethsw, buf_array, i); 1994 return 0; 1995 } 1996 1997 return i; 1998 1999 err_map: 2000 __free_pages(page, 0); 2001 err_alloc: 2002 /* If we managed to allocate at least some buffers, 2003 * release them to hardware 2004 */ 2005 if (i) 2006 goto release_bufs; 2007 2008 return 0; 2009 } 2010 2011 static int dpaa2_switch_refill_bp(struct ethsw_core *ethsw) 2012 { 2013 int *count = ðsw->buf_count; 2014 int new_count; 2015 int err = 0; 2016 2017 if (unlikely(*count < DPAA2_ETHSW_REFILL_THRESH)) { 2018 do { 2019 new_count = dpaa2_switch_add_bufs(ethsw, ethsw->bpid); 2020 if (unlikely(!new_count)) { 2021 /* Out of memory; abort for now, we'll 2022 * try later on 2023 */ 2024 break; 2025 } 2026 *count += new_count; 2027 } while (*count < DPAA2_ETHSW_NUM_BUFS); 2028 2029 if (unlikely(*count < DPAA2_ETHSW_NUM_BUFS)) 2030 err = -ENOMEM; 2031 } 2032 2033 return err; 2034 } 2035 2036 static int dpaa2_switch_seed_bp(struct ethsw_core *ethsw) 2037 { 2038 int *count, i; 2039 2040 for (i = 0; i < DPAA2_ETHSW_NUM_BUFS; i += BUFS_PER_CMD) { 2041 count = ðsw->buf_count; 2042 *count += dpaa2_switch_add_bufs(ethsw, ethsw->bpid); 2043 2044 if (unlikely(*count < BUFS_PER_CMD)) 2045 return -ENOMEM; 2046 } 2047 2048 return 0; 2049 } 2050 2051 static void dpaa2_switch_drain_bp(struct ethsw_core *ethsw) 2052 { 2053 u64 buf_array[BUFS_PER_CMD]; 2054 int ret; 2055 2056 do { 2057 ret = dpaa2_io_service_acquire(NULL, ethsw->bpid, 2058 buf_array, BUFS_PER_CMD); 2059 if (ret < 0) { 2060 dev_err(ethsw->dev, 2061 "dpaa2_io_service_acquire() = %d\n", ret); 2062 return; 2063 } 2064 dpaa2_switch_free_bufs(ethsw, buf_array, ret); 2065 2066 } while (ret); 2067 } 2068 2069 static int dpaa2_switch_setup_dpbp(struct ethsw_core *ethsw) 2070 { 2071 struct dpsw_ctrl_if_pools_cfg dpsw_ctrl_if_pools_cfg = { 0 }; 2072 struct device *dev = ethsw->dev; 2073 struct fsl_mc_device *dpbp_dev; 2074 struct dpbp_attr dpbp_attrs; 2075 int err; 2076 2077 err = fsl_mc_object_allocate(to_fsl_mc_device(dev), FSL_MC_POOL_DPBP, 2078 &dpbp_dev); 2079 if (err) { 2080 if (err == -ENXIO) 2081 err = -EPROBE_DEFER; 2082 else 2083 dev_err(dev, "DPBP device allocation failed\n"); 2084 return err; 2085 } 2086 ethsw->dpbp_dev = dpbp_dev; 2087 2088 err = dpbp_open(ethsw->mc_io, 0, dpbp_dev->obj_desc.id, 2089 &dpbp_dev->mc_handle); 2090 if (err) { 2091 dev_err(dev, "dpbp_open() failed\n"); 2092 goto err_open; 2093 } 2094 2095 err = dpbp_reset(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2096 if (err) { 2097 dev_err(dev, "dpbp_reset() failed\n"); 2098 goto err_reset; 2099 } 2100 2101 err = dpbp_enable(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2102 if (err) { 2103 dev_err(dev, "dpbp_enable() failed\n"); 2104 goto err_enable; 2105 } 2106 2107 err = dpbp_get_attributes(ethsw->mc_io, 0, dpbp_dev->mc_handle, 2108 &dpbp_attrs); 2109 if (err) { 2110 dev_err(dev, "dpbp_get_attributes() failed\n"); 2111 goto err_get_attr; 2112 } 2113 2114 dpsw_ctrl_if_pools_cfg.num_dpbp = 1; 2115 dpsw_ctrl_if_pools_cfg.pools[0].dpbp_id = dpbp_attrs.id; 2116 dpsw_ctrl_if_pools_cfg.pools[0].buffer_size = DPAA2_SWITCH_RX_BUF_SIZE; 2117 dpsw_ctrl_if_pools_cfg.pools[0].backup_pool = 0; 2118 2119 err = dpsw_ctrl_if_set_pools(ethsw->mc_io, 0, ethsw->dpsw_handle, 2120 &dpsw_ctrl_if_pools_cfg); 2121 if (err) { 2122 dev_err(dev, "dpsw_ctrl_if_set_pools() failed\n"); 2123 goto err_get_attr; 2124 } 2125 ethsw->bpid = dpbp_attrs.id; 2126 2127 return 0; 2128 2129 err_get_attr: 2130 dpbp_disable(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2131 err_enable: 2132 err_reset: 2133 dpbp_close(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2134 err_open: 2135 fsl_mc_object_free(dpbp_dev); 2136 return err; 2137 } 2138 2139 static void dpaa2_switch_free_dpbp(struct ethsw_core *ethsw) 2140 { 2141 dpbp_disable(ethsw->mc_io, 0, ethsw->dpbp_dev->mc_handle); 2142 dpbp_close(ethsw->mc_io, 0, ethsw->dpbp_dev->mc_handle); 2143 fsl_mc_object_free(ethsw->dpbp_dev); 2144 } 2145 2146 static int dpaa2_switch_alloc_rings(struct ethsw_core *ethsw) 2147 { 2148 int i; 2149 2150 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) { 2151 ethsw->fq[i].store = 2152 dpaa2_io_store_create(DPAA2_SWITCH_STORE_SIZE, 2153 ethsw->dev); 2154 if (!ethsw->fq[i].store) { 2155 dev_err(ethsw->dev, "dpaa2_io_store_create failed\n"); 2156 while (--i >= 0) 2157 dpaa2_io_store_destroy(ethsw->fq[i].store); 2158 return -ENOMEM; 2159 } 2160 } 2161 2162 return 0; 2163 } 2164 2165 static void dpaa2_switch_destroy_rings(struct ethsw_core *ethsw) 2166 { 2167 int i; 2168 2169 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 2170 dpaa2_io_store_destroy(ethsw->fq[i].store); 2171 } 2172 2173 static int dpaa2_switch_pull_fq(struct dpaa2_switch_fq *fq) 2174 { 2175 int err, retries = 0; 2176 2177 /* Try to pull from the FQ while the portal is busy and we didn't hit 2178 * the maximum number fo retries 2179 */ 2180 do { 2181 err = dpaa2_io_service_pull_fq(NULL, fq->fqid, fq->store); 2182 cpu_relax(); 2183 } while (err == -EBUSY && retries++ < DPAA2_SWITCH_SWP_BUSY_RETRIES); 2184 2185 if (unlikely(err)) 2186 dev_err(fq->ethsw->dev, "dpaa2_io_service_pull err %d", err); 2187 2188 return err; 2189 } 2190 2191 /* Consume all frames pull-dequeued into the store */ 2192 static int dpaa2_switch_store_consume(struct dpaa2_switch_fq *fq) 2193 { 2194 struct ethsw_core *ethsw = fq->ethsw; 2195 int cleaned = 0, is_last; 2196 struct dpaa2_dq *dq; 2197 int retries = 0; 2198 2199 do { 2200 /* Get the next available FD from the store */ 2201 dq = dpaa2_io_store_next(fq->store, &is_last); 2202 if (unlikely(!dq)) { 2203 if (retries++ >= DPAA2_SWITCH_SWP_BUSY_RETRIES) { 2204 dev_err_once(ethsw->dev, 2205 "No valid dequeue response\n"); 2206 return -ETIMEDOUT; 2207 } 2208 continue; 2209 } 2210 2211 if (fq->type == DPSW_QUEUE_RX) 2212 dpaa2_switch_rx(fq, dpaa2_dq_fd(dq)); 2213 else 2214 dpaa2_switch_tx_conf(fq, dpaa2_dq_fd(dq)); 2215 cleaned++; 2216 2217 } while (!is_last); 2218 2219 return cleaned; 2220 } 2221 2222 /* NAPI poll routine */ 2223 static int dpaa2_switch_poll(struct napi_struct *napi, int budget) 2224 { 2225 int err, cleaned = 0, store_cleaned, work_done; 2226 struct dpaa2_switch_fq *fq; 2227 int retries = 0; 2228 2229 fq = container_of(napi, struct dpaa2_switch_fq, napi); 2230 2231 do { 2232 err = dpaa2_switch_pull_fq(fq); 2233 if (unlikely(err)) 2234 break; 2235 2236 /* Refill pool if appropriate */ 2237 dpaa2_switch_refill_bp(fq->ethsw); 2238 2239 store_cleaned = dpaa2_switch_store_consume(fq); 2240 cleaned += store_cleaned; 2241 2242 if (cleaned >= budget) { 2243 work_done = budget; 2244 goto out; 2245 } 2246 2247 } while (store_cleaned); 2248 2249 /* We didn't consume the entire budget, so finish napi and re-enable 2250 * data availability notifications 2251 */ 2252 napi_complete_done(napi, cleaned); 2253 do { 2254 err = dpaa2_io_service_rearm(NULL, &fq->nctx); 2255 cpu_relax(); 2256 } while (err == -EBUSY && retries++ < DPAA2_SWITCH_SWP_BUSY_RETRIES); 2257 2258 work_done = max(cleaned, 1); 2259 out: 2260 2261 return work_done; 2262 } 2263 2264 static void dpaa2_switch_fqdan_cb(struct dpaa2_io_notification_ctx *nctx) 2265 { 2266 struct dpaa2_switch_fq *fq; 2267 2268 fq = container_of(nctx, struct dpaa2_switch_fq, nctx); 2269 2270 napi_schedule(&fq->napi); 2271 } 2272 2273 static int dpaa2_switch_setup_dpio(struct ethsw_core *ethsw) 2274 { 2275 struct dpsw_ctrl_if_queue_cfg queue_cfg; 2276 struct dpaa2_io_notification_ctx *nctx; 2277 int err, i, j; 2278 2279 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) { 2280 nctx = ðsw->fq[i].nctx; 2281 2282 /* Register a new software context for the FQID. 2283 * By using NULL as the first parameter, we specify that we do 2284 * not care on which cpu are interrupts received for this queue 2285 */ 2286 nctx->is_cdan = 0; 2287 nctx->id = ethsw->fq[i].fqid; 2288 nctx->desired_cpu = DPAA2_IO_ANY_CPU; 2289 nctx->cb = dpaa2_switch_fqdan_cb; 2290 err = dpaa2_io_service_register(NULL, nctx, ethsw->dev); 2291 if (err) { 2292 err = -EPROBE_DEFER; 2293 goto err_register; 2294 } 2295 2296 queue_cfg.options = DPSW_CTRL_IF_QUEUE_OPT_DEST | 2297 DPSW_CTRL_IF_QUEUE_OPT_USER_CTX; 2298 queue_cfg.dest_cfg.dest_type = DPSW_CTRL_IF_DEST_DPIO; 2299 queue_cfg.dest_cfg.dest_id = nctx->dpio_id; 2300 queue_cfg.dest_cfg.priority = 0; 2301 queue_cfg.user_ctx = nctx->qman64; 2302 2303 err = dpsw_ctrl_if_set_queue(ethsw->mc_io, 0, 2304 ethsw->dpsw_handle, 2305 ethsw->fq[i].type, 2306 &queue_cfg); 2307 if (err) 2308 goto err_set_queue; 2309 } 2310 2311 return 0; 2312 2313 err_set_queue: 2314 dpaa2_io_service_deregister(NULL, nctx, ethsw->dev); 2315 err_register: 2316 for (j = 0; j < i; j++) 2317 dpaa2_io_service_deregister(NULL, ðsw->fq[j].nctx, 2318 ethsw->dev); 2319 2320 return err; 2321 } 2322 2323 static void dpaa2_switch_free_dpio(struct ethsw_core *ethsw) 2324 { 2325 int i; 2326 2327 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 2328 dpaa2_io_service_deregister(NULL, ðsw->fq[i].nctx, 2329 ethsw->dev); 2330 } 2331 2332 static int dpaa2_switch_ctrl_if_setup(struct ethsw_core *ethsw) 2333 { 2334 int err; 2335 2336 /* setup FQs for Rx and Tx Conf */ 2337 err = dpaa2_switch_setup_fqs(ethsw); 2338 if (err) 2339 return err; 2340 2341 /* setup the buffer pool needed on the Rx path */ 2342 err = dpaa2_switch_setup_dpbp(ethsw); 2343 if (err) 2344 return err; 2345 2346 err = dpaa2_switch_seed_bp(ethsw); 2347 if (err) 2348 goto err_free_dpbp; 2349 2350 err = dpaa2_switch_alloc_rings(ethsw); 2351 if (err) 2352 goto err_drain_dpbp; 2353 2354 err = dpaa2_switch_setup_dpio(ethsw); 2355 if (err) 2356 goto err_destroy_rings; 2357 2358 err = dpsw_ctrl_if_enable(ethsw->mc_io, 0, ethsw->dpsw_handle); 2359 if (err) { 2360 dev_err(ethsw->dev, "dpsw_ctrl_if_enable err %d\n", err); 2361 goto err_deregister_dpio; 2362 } 2363 2364 return 0; 2365 2366 err_deregister_dpio: 2367 dpaa2_switch_free_dpio(ethsw); 2368 err_destroy_rings: 2369 dpaa2_switch_destroy_rings(ethsw); 2370 err_drain_dpbp: 2371 dpaa2_switch_drain_bp(ethsw); 2372 err_free_dpbp: 2373 dpaa2_switch_free_dpbp(ethsw); 2374 2375 return err; 2376 } 2377 2378 static int dpaa2_switch_init(struct fsl_mc_device *sw_dev) 2379 { 2380 struct device *dev = &sw_dev->dev; 2381 struct ethsw_core *ethsw = dev_get_drvdata(dev); 2382 struct dpsw_vlan_if_cfg vcfg = {0}; 2383 struct dpsw_tci_cfg tci_cfg = {0}; 2384 struct dpsw_stp_cfg stp_cfg; 2385 int err; 2386 u16 i; 2387 2388 ethsw->dev_id = sw_dev->obj_desc.id; 2389 2390 err = dpsw_open(ethsw->mc_io, 0, ethsw->dev_id, ðsw->dpsw_handle); 2391 if (err) { 2392 dev_err(dev, "dpsw_open err %d\n", err); 2393 return err; 2394 } 2395 2396 err = dpsw_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 2397 ðsw->sw_attr); 2398 if (err) { 2399 dev_err(dev, "dpsw_get_attributes err %d\n", err); 2400 goto err_close; 2401 } 2402 2403 err = dpsw_get_api_version(ethsw->mc_io, 0, 2404 ðsw->major, 2405 ðsw->minor); 2406 if (err) { 2407 dev_err(dev, "dpsw_get_api_version err %d\n", err); 2408 goto err_close; 2409 } 2410 2411 /* Minimum supported DPSW version check */ 2412 if (ethsw->major < DPSW_MIN_VER_MAJOR || 2413 (ethsw->major == DPSW_MIN_VER_MAJOR && 2414 ethsw->minor < DPSW_MIN_VER_MINOR)) { 2415 dev_err(dev, "DPSW version %d:%d not supported. Use firmware 10.28.0 or greater.\n", 2416 ethsw->major, ethsw->minor); 2417 err = -EOPNOTSUPP; 2418 goto err_close; 2419 } 2420 2421 if (!dpaa2_switch_supports_cpu_traffic(ethsw)) { 2422 err = -EOPNOTSUPP; 2423 goto err_close; 2424 } 2425 2426 dpaa2_switch_detect_features(ethsw); 2427 2428 err = dpsw_reset(ethsw->mc_io, 0, ethsw->dpsw_handle); 2429 if (err) { 2430 dev_err(dev, "dpsw_reset err %d\n", err); 2431 goto err_close; 2432 } 2433 2434 stp_cfg.vlan_id = DEFAULT_VLAN_ID; 2435 stp_cfg.state = DPSW_STP_STATE_FORWARDING; 2436 2437 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 2438 err = dpsw_if_disable(ethsw->mc_io, 0, ethsw->dpsw_handle, i); 2439 if (err) { 2440 dev_err(dev, "dpsw_if_disable err %d\n", err); 2441 goto err_close; 2442 } 2443 2444 err = dpsw_if_set_stp(ethsw->mc_io, 0, ethsw->dpsw_handle, i, 2445 &stp_cfg); 2446 if (err) { 2447 dev_err(dev, "dpsw_if_set_stp err %d for port %d\n", 2448 err, i); 2449 goto err_close; 2450 } 2451 2452 /* Switch starts with all ports configured to VLAN 1. Need to 2453 * remove this setting to allow configuration at bridge join 2454 */ 2455 vcfg.num_ifs = 1; 2456 vcfg.if_id[0] = i; 2457 err = dpsw_vlan_remove_if_untagged(ethsw->mc_io, 0, ethsw->dpsw_handle, 2458 DEFAULT_VLAN_ID, &vcfg); 2459 if (err) { 2460 dev_err(dev, "dpsw_vlan_remove_if_untagged err %d\n", 2461 err); 2462 goto err_close; 2463 } 2464 2465 tci_cfg.vlan_id = 4095; 2466 err = dpsw_if_set_tci(ethsw->mc_io, 0, ethsw->dpsw_handle, i, &tci_cfg); 2467 if (err) { 2468 dev_err(dev, "dpsw_if_set_tci err %d\n", err); 2469 goto err_close; 2470 } 2471 2472 err = dpsw_vlan_remove_if(ethsw->mc_io, 0, ethsw->dpsw_handle, 2473 DEFAULT_VLAN_ID, &vcfg); 2474 if (err) { 2475 dev_err(dev, "dpsw_vlan_remove_if err %d\n", err); 2476 goto err_close; 2477 } 2478 } 2479 2480 err = dpsw_vlan_remove(ethsw->mc_io, 0, ethsw->dpsw_handle, DEFAULT_VLAN_ID); 2481 if (err) { 2482 dev_err(dev, "dpsw_vlan_remove err %d\n", err); 2483 goto err_close; 2484 } 2485 2486 ethsw->workqueue = alloc_ordered_workqueue("%s_%d_ordered", 2487 WQ_MEM_RECLAIM, "ethsw", 2488 ethsw->sw_attr.id); 2489 if (!ethsw->workqueue) { 2490 err = -ENOMEM; 2491 goto err_close; 2492 } 2493 2494 err = dpsw_fdb_remove(ethsw->mc_io, 0, ethsw->dpsw_handle, 0); 2495 if (err) 2496 goto err_destroy_ordered_workqueue; 2497 2498 err = dpaa2_switch_ctrl_if_setup(ethsw); 2499 if (err) 2500 goto err_destroy_ordered_workqueue; 2501 2502 return 0; 2503 2504 err_destroy_ordered_workqueue: 2505 destroy_workqueue(ethsw->workqueue); 2506 2507 err_close: 2508 dpsw_close(ethsw->mc_io, 0, ethsw->dpsw_handle); 2509 return err; 2510 } 2511 2512 static int dpaa2_switch_port_init(struct ethsw_port_priv *port_priv, u16 port) 2513 { 2514 struct switchdev_obj_port_vlan vlan = { 2515 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 2516 .vid = DEFAULT_VLAN_ID, 2517 .flags = BRIDGE_VLAN_INFO_UNTAGGED | BRIDGE_VLAN_INFO_PVID, 2518 }; 2519 struct net_device *netdev = port_priv->netdev; 2520 struct ethsw_core *ethsw = port_priv->ethsw_data; 2521 struct dpsw_fdb_cfg fdb_cfg = {0}; 2522 struct dpaa2_switch_fdb *fdb; 2523 struct dpsw_if_attr dpsw_if_attr; 2524 u16 fdb_id; 2525 int err; 2526 2527 /* Get the Tx queue for this specific port */ 2528 err = dpsw_if_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 2529 port_priv->idx, &dpsw_if_attr); 2530 if (err) { 2531 netdev_err(netdev, "dpsw_if_get_attributes err %d\n", err); 2532 return err; 2533 } 2534 port_priv->tx_qdid = dpsw_if_attr.qdid; 2535 2536 /* Create a FDB table for this particular switch port */ 2537 fdb_cfg.num_fdb_entries = ethsw->sw_attr.max_fdb_entries / ethsw->sw_attr.num_ifs; 2538 err = dpsw_fdb_add(ethsw->mc_io, 0, ethsw->dpsw_handle, 2539 &fdb_id, &fdb_cfg); 2540 if (err) { 2541 netdev_err(netdev, "dpsw_fdb_add err %d\n", err); 2542 return err; 2543 } 2544 2545 /* Find an unused dpaa2_switch_fdb structure and use it */ 2546 fdb = dpaa2_switch_fdb_get_unused(ethsw); 2547 fdb->fdb_id = fdb_id; 2548 fdb->in_use = true; 2549 fdb->bridge_dev = NULL; 2550 port_priv->fdb = fdb; 2551 2552 /* We need to add VLAN 1 as the PVID on this port until it is under a 2553 * bridge since the DPAA2 switch is not able to handle the traffic in a 2554 * VLAN unaware fashion 2555 */ 2556 err = dpaa2_switch_port_vlans_add(netdev, &vlan); 2557 if (err) 2558 return err; 2559 2560 /* Setup the egress flooding domains (broadcast, unknown unicast */ 2561 err = dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 2562 if (err) 2563 return err; 2564 2565 return err; 2566 } 2567 2568 static void dpaa2_switch_takedown(struct fsl_mc_device *sw_dev) 2569 { 2570 struct device *dev = &sw_dev->dev; 2571 struct ethsw_core *ethsw = dev_get_drvdata(dev); 2572 int err; 2573 2574 err = dpsw_close(ethsw->mc_io, 0, ethsw->dpsw_handle); 2575 if (err) 2576 dev_warn(dev, "dpsw_close err %d\n", err); 2577 } 2578 2579 static void dpaa2_switch_ctrl_if_teardown(struct ethsw_core *ethsw) 2580 { 2581 dpsw_ctrl_if_disable(ethsw->mc_io, 0, ethsw->dpsw_handle); 2582 dpaa2_switch_free_dpio(ethsw); 2583 dpaa2_switch_destroy_rings(ethsw); 2584 dpaa2_switch_drain_bp(ethsw); 2585 dpaa2_switch_free_dpbp(ethsw); 2586 } 2587 2588 static int dpaa2_switch_remove(struct fsl_mc_device *sw_dev) 2589 { 2590 struct ethsw_port_priv *port_priv; 2591 struct ethsw_core *ethsw; 2592 struct device *dev; 2593 int i; 2594 2595 dev = &sw_dev->dev; 2596 ethsw = dev_get_drvdata(dev); 2597 2598 dpaa2_switch_ctrl_if_teardown(ethsw); 2599 2600 dpaa2_switch_teardown_irqs(sw_dev); 2601 2602 dpsw_disable(ethsw->mc_io, 0, ethsw->dpsw_handle); 2603 2604 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 2605 port_priv = ethsw->ports[i]; 2606 unregister_netdev(port_priv->netdev); 2607 free_netdev(port_priv->netdev); 2608 } 2609 2610 kfree(ethsw->fdbs); 2611 kfree(ethsw->ports); 2612 2613 dpaa2_switch_takedown(sw_dev); 2614 2615 destroy_workqueue(ethsw->workqueue); 2616 2617 fsl_mc_portal_free(ethsw->mc_io); 2618 2619 kfree(ethsw); 2620 2621 dev_set_drvdata(dev, NULL); 2622 2623 return 0; 2624 } 2625 2626 static int dpaa2_switch_probe_port(struct ethsw_core *ethsw, 2627 u16 port_idx) 2628 { 2629 struct ethsw_port_priv *port_priv; 2630 struct device *dev = ethsw->dev; 2631 struct net_device *port_netdev; 2632 int err; 2633 2634 port_netdev = alloc_etherdev(sizeof(struct ethsw_port_priv)); 2635 if (!port_netdev) { 2636 dev_err(dev, "alloc_etherdev error\n"); 2637 return -ENOMEM; 2638 } 2639 2640 port_priv = netdev_priv(port_netdev); 2641 port_priv->netdev = port_netdev; 2642 port_priv->ethsw_data = ethsw; 2643 2644 port_priv->idx = port_idx; 2645 port_priv->stp_state = BR_STATE_FORWARDING; 2646 2647 SET_NETDEV_DEV(port_netdev, dev); 2648 port_netdev->netdev_ops = &dpaa2_switch_port_ops; 2649 port_netdev->ethtool_ops = &dpaa2_switch_port_ethtool_ops; 2650 2651 port_netdev->needed_headroom = DPAA2_SWITCH_NEEDED_HEADROOM; 2652 2653 /* Set MTU limits */ 2654 port_netdev->min_mtu = ETH_MIN_MTU; 2655 port_netdev->max_mtu = ETHSW_MAX_FRAME_LENGTH; 2656 2657 /* Populate the private port structure so that later calls to 2658 * dpaa2_switch_port_init() can use it. 2659 */ 2660 ethsw->ports[port_idx] = port_priv; 2661 2662 /* The DPAA2 switch's ingress path depends on the VLAN table, 2663 * thus we are not able to disable VLAN filtering. 2664 */ 2665 port_netdev->features = NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER; 2666 2667 err = dpaa2_switch_port_init(port_priv, port_idx); 2668 if (err) 2669 goto err_port_probe; 2670 2671 err = dpaa2_switch_port_set_mac_addr(port_priv); 2672 if (err) 2673 goto err_port_probe; 2674 2675 return 0; 2676 2677 err_port_probe: 2678 free_netdev(port_netdev); 2679 ethsw->ports[port_idx] = NULL; 2680 2681 return err; 2682 } 2683 2684 static int dpaa2_switch_probe(struct fsl_mc_device *sw_dev) 2685 { 2686 struct device *dev = &sw_dev->dev; 2687 struct ethsw_core *ethsw; 2688 int i, err; 2689 2690 /* Allocate switch core*/ 2691 ethsw = kzalloc(sizeof(*ethsw), GFP_KERNEL); 2692 2693 if (!ethsw) 2694 return -ENOMEM; 2695 2696 ethsw->dev = dev; 2697 ethsw->iommu_domain = iommu_get_domain_for_dev(dev); 2698 dev_set_drvdata(dev, ethsw); 2699 2700 err = fsl_mc_portal_allocate(sw_dev, FSL_MC_IO_ATOMIC_CONTEXT_PORTAL, 2701 ðsw->mc_io); 2702 if (err) { 2703 if (err == -ENXIO) 2704 err = -EPROBE_DEFER; 2705 else 2706 dev_err(dev, "fsl_mc_portal_allocate err %d\n", err); 2707 goto err_free_drvdata; 2708 } 2709 2710 err = dpaa2_switch_init(sw_dev); 2711 if (err) 2712 goto err_free_cmdport; 2713 2714 ethsw->ports = kcalloc(ethsw->sw_attr.num_ifs, sizeof(*ethsw->ports), 2715 GFP_KERNEL); 2716 if (!(ethsw->ports)) { 2717 err = -ENOMEM; 2718 goto err_takedown; 2719 } 2720 2721 ethsw->fdbs = kcalloc(ethsw->sw_attr.num_ifs, sizeof(*ethsw->fdbs), 2722 GFP_KERNEL); 2723 if (!ethsw->fdbs) { 2724 err = -ENOMEM; 2725 goto err_free_ports; 2726 } 2727 2728 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 2729 err = dpaa2_switch_probe_port(ethsw, i); 2730 if (err) 2731 goto err_free_netdev; 2732 } 2733 2734 /* Add a NAPI instance for each of the Rx queues. The first port's 2735 * net_device will be associated with the instances since we do not have 2736 * different queues for each switch ports. 2737 */ 2738 for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 2739 netif_napi_add(ethsw->ports[0]->netdev, 2740 ðsw->fq[i].napi, dpaa2_switch_poll, 2741 NAPI_POLL_WEIGHT); 2742 2743 err = dpsw_enable(ethsw->mc_io, 0, ethsw->dpsw_handle); 2744 if (err) { 2745 dev_err(ethsw->dev, "dpsw_enable err %d\n", err); 2746 goto err_free_netdev; 2747 } 2748 2749 /* Setup IRQs */ 2750 err = dpaa2_switch_setup_irqs(sw_dev); 2751 if (err) 2752 goto err_stop; 2753 2754 /* Register the netdev only when the entire setup is done and the 2755 * switch port interfaces are ready to receive traffic 2756 */ 2757 for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 2758 err = register_netdev(ethsw->ports[i]->netdev); 2759 if (err < 0) { 2760 dev_err(dev, "register_netdev error %d\n", err); 2761 goto err_unregister_ports; 2762 } 2763 } 2764 2765 return 0; 2766 2767 err_unregister_ports: 2768 for (i--; i >= 0; i--) 2769 unregister_netdev(ethsw->ports[i]->netdev); 2770 dpaa2_switch_teardown_irqs(sw_dev); 2771 err_stop: 2772 dpsw_disable(ethsw->mc_io, 0, ethsw->dpsw_handle); 2773 err_free_netdev: 2774 for (i--; i >= 0; i--) 2775 free_netdev(ethsw->ports[i]->netdev); 2776 kfree(ethsw->fdbs); 2777 err_free_ports: 2778 kfree(ethsw->ports); 2779 2780 err_takedown: 2781 dpaa2_switch_takedown(sw_dev); 2782 2783 err_free_cmdport: 2784 fsl_mc_portal_free(ethsw->mc_io); 2785 2786 err_free_drvdata: 2787 kfree(ethsw); 2788 dev_set_drvdata(dev, NULL); 2789 2790 return err; 2791 } 2792 2793 static const struct fsl_mc_device_id dpaa2_switch_match_id_table[] = { 2794 { 2795 .vendor = FSL_MC_VENDOR_FREESCALE, 2796 .obj_type = "dpsw", 2797 }, 2798 { .vendor = 0x0 } 2799 }; 2800 MODULE_DEVICE_TABLE(fslmc, dpaa2_switch_match_id_table); 2801 2802 static struct fsl_mc_driver dpaa2_switch_drv = { 2803 .driver = { 2804 .name = KBUILD_MODNAME, 2805 .owner = THIS_MODULE, 2806 }, 2807 .probe = dpaa2_switch_probe, 2808 .remove = dpaa2_switch_remove, 2809 .match_id_table = dpaa2_switch_match_id_table 2810 }; 2811 2812 static struct notifier_block dpaa2_switch_port_nb __read_mostly = { 2813 .notifier_call = dpaa2_switch_port_netdevice_event, 2814 }; 2815 2816 static struct notifier_block dpaa2_switch_port_switchdev_nb = { 2817 .notifier_call = dpaa2_switch_port_event, 2818 }; 2819 2820 static struct notifier_block dpaa2_switch_port_switchdev_blocking_nb = { 2821 .notifier_call = dpaa2_switch_port_blocking_event, 2822 }; 2823 2824 static int dpaa2_switch_register_notifiers(void) 2825 { 2826 int err; 2827 2828 err = register_netdevice_notifier(&dpaa2_switch_port_nb); 2829 if (err) { 2830 pr_err("dpaa2-switch: failed to register net_device notifier (%d)\n", err); 2831 return err; 2832 } 2833 2834 err = register_switchdev_notifier(&dpaa2_switch_port_switchdev_nb); 2835 if (err) { 2836 pr_err("dpaa2-switch: failed to register switchdev notifier (%d)\n", err); 2837 goto err_switchdev_nb; 2838 } 2839 2840 err = register_switchdev_blocking_notifier(&dpaa2_switch_port_switchdev_blocking_nb); 2841 if (err) { 2842 pr_err("dpaa2-switch: failed to register switchdev blocking notifier (%d)\n", err); 2843 goto err_switchdev_blocking_nb; 2844 } 2845 2846 return 0; 2847 2848 err_switchdev_blocking_nb: 2849 unregister_switchdev_notifier(&dpaa2_switch_port_switchdev_nb); 2850 err_switchdev_nb: 2851 unregister_netdevice_notifier(&dpaa2_switch_port_nb); 2852 2853 return err; 2854 } 2855 2856 static void dpaa2_switch_unregister_notifiers(void) 2857 { 2858 int err; 2859 2860 err = unregister_switchdev_blocking_notifier(&dpaa2_switch_port_switchdev_blocking_nb); 2861 if (err) 2862 pr_err("dpaa2-switch: failed to unregister switchdev blocking notifier (%d)\n", 2863 err); 2864 2865 err = unregister_switchdev_notifier(&dpaa2_switch_port_switchdev_nb); 2866 if (err) 2867 pr_err("dpaa2-switch: failed to unregister switchdev notifier (%d)\n", err); 2868 2869 err = unregister_netdevice_notifier(&dpaa2_switch_port_nb); 2870 if (err) 2871 pr_err("dpaa2-switch: failed to unregister net_device notifier (%d)\n", err); 2872 } 2873 2874 static int __init dpaa2_switch_driver_init(void) 2875 { 2876 int err; 2877 2878 err = fsl_mc_driver_register(&dpaa2_switch_drv); 2879 if (err) 2880 return err; 2881 2882 err = dpaa2_switch_register_notifiers(); 2883 if (err) { 2884 fsl_mc_driver_unregister(&dpaa2_switch_drv); 2885 return err; 2886 } 2887 2888 return 0; 2889 } 2890 2891 static void __exit dpaa2_switch_driver_exit(void) 2892 { 2893 dpaa2_switch_unregister_notifiers(); 2894 fsl_mc_driver_unregister(&dpaa2_switch_drv); 2895 } 2896 2897 module_init(dpaa2_switch_driver_init); 2898 module_exit(dpaa2_switch_driver_exit); 2899 2900 MODULE_LICENSE("GPL v2"); 2901 MODULE_DESCRIPTION("DPAA2 Ethernet Switch Driver"); 2902