1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0) 2 * 3 * Copyright 2010-2016 Freescale Semiconductor Inc. 4 * Copyright 2017-2020 NXP 5 * 6 */ 7 8 #include <sys/types.h> 9 #include <sys/ioctl.h> 10 #include <ifaddrs.h> 11 12 /* This header declares the driver interface we implement */ 13 #include <fman.h> 14 #include <dpaa_of.h> 15 #include <rte_malloc.h> 16 #include <rte_dpaa_logs.h> 17 #include <rte_string_fns.h> 18 19 #define QMI_PORT_REGS_OFFSET 0x400 20 21 /* CCSR map address to access ccsr based register */ 22 void *fman_ccsr_map; 23 /* fman version info */ 24 u16 fman_ip_rev; 25 static int get_once; 26 u32 fman_dealloc_bufs_mask_hi; 27 u32 fman_dealloc_bufs_mask_lo; 28 29 int fman_ccsr_map_fd = -1; 30 static COMPAT_LIST_HEAD(__ifs); 31 32 /* This is the (const) global variable that callers have read-only access to. 33 * Internally, we have read-write access directly to __ifs. 34 */ 35 const struct list_head *fman_if_list = &__ifs; 36 37 static void 38 if_destructor(struct __fman_if *__if) 39 { 40 struct fman_if_bpool *bp, *tmpbp; 41 42 if (!__if) 43 return; 44 45 if (__if->__if.mac_type == fman_offline) 46 goto cleanup; 47 48 list_for_each_entry_safe(bp, tmpbp, &__if->__if.bpool_list, node) { 49 list_del(&bp->node); 50 free(bp); 51 } 52 cleanup: 53 free(__if); 54 } 55 56 static int 57 fman_get_ip_rev(const struct device_node *fman_node) 58 { 59 const uint32_t *fman_addr; 60 uint64_t phys_addr; 61 uint64_t regs_size; 62 uint32_t ip_rev_1; 63 int _errno; 64 65 fman_addr = of_get_address(fman_node, 0, ®s_size, NULL); 66 if (!fman_addr) { 67 pr_err("of_get_address cannot return fman address\n"); 68 return -EINVAL; 69 } 70 phys_addr = of_translate_address(fman_node, fman_addr); 71 if (!phys_addr) { 72 pr_err("of_translate_address failed\n"); 73 return -EINVAL; 74 } 75 fman_ccsr_map = mmap(NULL, regs_size, PROT_READ | PROT_WRITE, 76 MAP_SHARED, fman_ccsr_map_fd, phys_addr); 77 if (fman_ccsr_map == MAP_FAILED) { 78 pr_err("Can not map FMan ccsr base"); 79 return -EINVAL; 80 } 81 82 ip_rev_1 = in_be32(fman_ccsr_map + FMAN_IP_REV_1); 83 fman_ip_rev = (ip_rev_1 & FMAN_IP_REV_1_MAJOR_MASK) >> 84 FMAN_IP_REV_1_MAJOR_SHIFT; 85 86 _errno = munmap(fman_ccsr_map, regs_size); 87 if (_errno) 88 pr_err("munmap() of FMan ccsr failed"); 89 90 return 0; 91 } 92 93 static int 94 fman_get_mac_index(uint64_t regs_addr_host, uint8_t *mac_idx) 95 { 96 int ret = 0; 97 98 /* 99 * MAC1 : E_0000h 100 * MAC2 : E_2000h 101 * MAC3 : E_4000h 102 * MAC4 : E_6000h 103 * MAC5 : E_8000h 104 * MAC6 : E_A000h 105 * MAC7 : E_C000h 106 * MAC8 : E_E000h 107 * MAC9 : F_0000h 108 * MAC10: F_2000h 109 */ 110 switch (regs_addr_host) { 111 case 0xE0000: 112 *mac_idx = 1; 113 break; 114 case 0xE2000: 115 *mac_idx = 2; 116 break; 117 case 0xE4000: 118 *mac_idx = 3; 119 break; 120 case 0xE6000: 121 *mac_idx = 4; 122 break; 123 case 0xE8000: 124 *mac_idx = 5; 125 break; 126 case 0xEA000: 127 *mac_idx = 6; 128 break; 129 case 0xEC000: 130 *mac_idx = 7; 131 break; 132 case 0xEE000: 133 *mac_idx = 8; 134 break; 135 case 0xF0000: 136 *mac_idx = 9; 137 break; 138 case 0xF2000: 139 *mac_idx = 10; 140 break; 141 default: 142 ret = -EINVAL; 143 } 144 145 return ret; 146 } 147 148 static void fman_if_vsp_init(struct __fman_if *__if) 149 { 150 const phandle *prop; 151 int cell_index; 152 const struct device_node *dev; 153 size_t lenp; 154 const uint8_t mac_idx[] = {-1, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1}; 155 156 if (__if->__if.mac_type == fman_mac_1g) { 157 for_each_compatible_node(dev, NULL, 158 "fsl,fman-port-1g-rx-extended-args") { 159 prop = of_get_property(dev, "cell-index", &lenp); 160 if (prop) { 161 cell_index = of_read_number( 162 &prop[0], 163 lenp / sizeof(phandle)); 164 if (cell_index == mac_idx[__if->__if.mac_idx]) { 165 prop = of_get_property( 166 dev, 167 "vsp-window", &lenp); 168 if (prop) { 169 __if->__if.num_profiles = 170 of_read_number( 171 &prop[0], 1); 172 __if->__if.base_profile_id = 173 of_read_number( 174 &prop[1], 1); 175 } 176 } 177 } 178 } 179 } else if (__if->__if.mac_type == fman_mac_10g) { 180 for_each_compatible_node(dev, NULL, 181 "fsl,fman-port-10g-rx-extended-args") { 182 prop = of_get_property(dev, "cell-index", &lenp); 183 if (prop) { 184 cell_index = of_read_number( 185 &prop[0], lenp / sizeof(phandle)); 186 if (cell_index == mac_idx[__if->__if.mac_idx]) { 187 prop = of_get_property( 188 dev, "vsp-window", &lenp); 189 if (prop) { 190 __if->__if.num_profiles = 191 of_read_number( 192 &prop[0], 1); 193 __if->__if.base_profile_id = 194 of_read_number( 195 &prop[1], 1); 196 } 197 } 198 } 199 } 200 } 201 } 202 203 static int 204 fman_if_init(const struct device_node *dpa_node) 205 { 206 const char *rprop, *mprop; 207 uint64_t phys_addr; 208 struct __fman_if *__if; 209 struct fman_if_bpool *bpool; 210 211 const phandle *mac_phandle, *ports_phandle, *pools_phandle; 212 const phandle *tx_channel_id = NULL, *mac_addr, *cell_idx; 213 const phandle *rx_phandle, *tx_phandle; 214 const phandle *port_cell_idx, *ext_args_cell_idx; 215 const struct device_node *parent_node_ext_args; 216 uint64_t tx_phandle_host[4] = {0}; 217 uint64_t rx_phandle_host[4] = {0}; 218 uint64_t regs_addr_host = 0; 219 uint64_t cell_idx_host = 0; 220 uint64_t port_cell_idx_val = 0; 221 uint64_t ext_args_cell_idx_val = 0; 222 223 const struct device_node *mac_node = NULL, *tx_node, *ext_args_node; 224 const struct device_node *pool_node, *fman_node, *rx_node; 225 const uint32_t *regs_addr = NULL; 226 const char *mname, *fname; 227 const char *dname = dpa_node->full_name; 228 size_t lenp; 229 int _errno, is_shared = 0; 230 const char *char_prop; 231 uint32_t na; 232 233 if (of_device_is_available(dpa_node) == false) 234 return 0; 235 236 if (!of_device_is_compatible(dpa_node, "fsl,dpa-ethernet-init") && 237 !of_device_is_compatible(dpa_node, "fsl,dpa-ethernet")) { 238 return 0; 239 } 240 241 rprop = "fsl,qman-frame-queues-rx"; 242 mprop = "fsl,fman-mac"; 243 244 /* Obtain the MAC node used by this interface except macless */ 245 mac_phandle = of_get_property(dpa_node, mprop, &lenp); 246 if (!mac_phandle) { 247 FMAN_ERR(-EINVAL, "%s: no %s\n", dname, mprop); 248 return -EINVAL; 249 } 250 assert(lenp == sizeof(phandle)); 251 mac_node = of_find_node_by_phandle(*mac_phandle); 252 if (!mac_node) { 253 FMAN_ERR(-ENXIO, "%s: bad 'fsl,fman-mac\n", dname); 254 return -ENXIO; 255 } 256 mname = mac_node->full_name; 257 258 /* Extract the Rx and Tx ports */ 259 ports_phandle = of_get_property(mac_node, "fsl,port-handles", 260 &lenp); 261 if (!ports_phandle) 262 ports_phandle = of_get_property(mac_node, "fsl,fman-ports", 263 &lenp); 264 if (!ports_phandle) { 265 FMAN_ERR(-EINVAL, "%s: no fsl,port-handles\n", 266 mname); 267 return -EINVAL; 268 } 269 assert(lenp == (2 * sizeof(phandle))); 270 rx_node = of_find_node_by_phandle(ports_phandle[0]); 271 if (!rx_node) { 272 FMAN_ERR(-ENXIO, "%s: bad fsl,port-handle[0]\n", mname); 273 return -ENXIO; 274 } 275 tx_node = of_find_node_by_phandle(ports_phandle[1]); 276 if (!tx_node) { 277 FMAN_ERR(-ENXIO, "%s: bad fsl,port-handle[1]\n", mname); 278 return -ENXIO; 279 } 280 281 /* Check if the port is shared interface */ 282 if (of_device_is_compatible(dpa_node, "fsl,dpa-ethernet")) { 283 port_cell_idx = of_get_property(rx_node, "cell-index", &lenp); 284 if (!port_cell_idx) { 285 FMAN_ERR(-ENXIO, 286 "%s: no cell-index for port\n", mname); 287 return -ENXIO; 288 } 289 assert(lenp == sizeof(*port_cell_idx)); 290 port_cell_idx_val = 291 of_read_number(port_cell_idx, lenp / sizeof(phandle)); 292 293 if (of_device_is_compatible(rx_node, "fsl,fman-port-1g-rx")) 294 port_cell_idx_val -= 0x8; 295 else if (of_device_is_compatible( 296 rx_node, "fsl,fman-port-10g-rx")) 297 port_cell_idx_val -= 0x10; 298 299 parent_node_ext_args = of_find_compatible_node(NULL, 300 NULL, "fsl,fman-extended-args"); 301 if (!parent_node_ext_args) 302 return 0; 303 304 for_each_child_node(parent_node_ext_args, ext_args_node) { 305 ext_args_cell_idx = of_get_property(ext_args_node, 306 "cell-index", &lenp); 307 if (!ext_args_cell_idx) { 308 FMAN_ERR(-ENXIO, 309 "%s: no cell-index for ext args\n", 310 mname); 311 return -ENXIO; 312 } 313 assert(lenp == sizeof(*ext_args_cell_idx)); 314 ext_args_cell_idx_val = 315 of_read_number(ext_args_cell_idx, lenp / 316 sizeof(phandle)); 317 318 if (port_cell_idx_val == ext_args_cell_idx_val) { 319 if (of_device_is_compatible(ext_args_node, 320 "fsl,fman-port-1g-rx-extended-args") && 321 of_device_is_compatible(rx_node, 322 "fsl,fman-port-1g-rx")) { 323 if (of_get_property(ext_args_node, 324 "vsp-window", &lenp)) 325 is_shared = 1; 326 break; 327 } 328 if (of_device_is_compatible(ext_args_node, 329 "fsl,fman-port-10g-rx-extended-args") && 330 of_device_is_compatible(rx_node, 331 "fsl,fman-port-10g-rx")) { 332 if (of_get_property(ext_args_node, 333 "vsp-window", &lenp)) 334 is_shared = 1; 335 break; 336 } 337 } 338 } 339 if (!is_shared) 340 return 0; 341 } 342 343 /* Allocate an object for this network interface */ 344 __if = rte_malloc(NULL, sizeof(*__if), RTE_CACHE_LINE_SIZE); 345 if (!__if) { 346 FMAN_ERR(-ENOMEM, "malloc(%zu)\n", sizeof(*__if)); 347 goto err; 348 } 349 memset(__if, 0, sizeof(*__if)); 350 INIT_LIST_HEAD(&__if->__if.bpool_list); 351 strlcpy(__if->node_name, dpa_node->name, IF_NAME_MAX_LEN - 1); 352 __if->node_name[IF_NAME_MAX_LEN - 1] = '\0'; 353 strlcpy(__if->node_path, dpa_node->full_name, PATH_MAX - 1); 354 __if->node_path[PATH_MAX - 1] = '\0'; 355 356 /* Map the CCSR regs for the MAC node */ 357 regs_addr = of_get_address(mac_node, 0, &__if->regs_size, NULL); 358 if (!regs_addr) { 359 FMAN_ERR(-EINVAL, "of_get_address(%s)\n", mname); 360 goto err; 361 } 362 phys_addr = of_translate_address(mac_node, regs_addr); 363 if (!phys_addr) { 364 FMAN_ERR(-EINVAL, "of_translate_address(%s, %p)\n", 365 mname, regs_addr); 366 goto err; 367 } 368 __if->ccsr_map = mmap(NULL, __if->regs_size, 369 PROT_READ | PROT_WRITE, MAP_SHARED, 370 fman_ccsr_map_fd, phys_addr); 371 if (__if->ccsr_map == MAP_FAILED) { 372 FMAN_ERR(-errno, "mmap(0x%"PRIx64")\n", phys_addr); 373 goto err; 374 } 375 na = of_n_addr_cells(mac_node); 376 /* Get rid of endianness (issues). Convert to host byte order */ 377 regs_addr_host = of_read_number(regs_addr, na); 378 379 /* Get the index of the Fman this i/f belongs to */ 380 fman_node = of_get_parent(mac_node); 381 na = of_n_addr_cells(mac_node); 382 if (!fman_node) { 383 FMAN_ERR(-ENXIO, "of_get_parent(%s)\n", mname); 384 goto err; 385 } 386 fname = fman_node->full_name; 387 cell_idx = of_get_property(fman_node, "cell-index", &lenp); 388 if (!cell_idx) { 389 FMAN_ERR(-ENXIO, "%s: no cell-index)\n", fname); 390 goto err; 391 } 392 assert(lenp == sizeof(*cell_idx)); 393 cell_idx_host = of_read_number(cell_idx, lenp / sizeof(phandle)); 394 __if->__if.fman_idx = cell_idx_host; 395 if (!get_once) { 396 _errno = fman_get_ip_rev(fman_node); 397 if (_errno) { 398 FMAN_ERR(-ENXIO, "%s: ip_rev is not available\n", 399 fname); 400 goto err; 401 } 402 } 403 404 if (fman_ip_rev >= FMAN_V3) { 405 /* 406 * Set A2V, OVOM, EBD bits in contextA to allow external 407 * buffer deallocation by fman. 408 */ 409 fman_dealloc_bufs_mask_hi = FMAN_V3_CONTEXTA_EN_A2V | 410 FMAN_V3_CONTEXTA_EN_OVOM; 411 fman_dealloc_bufs_mask_lo = FMAN_V3_CONTEXTA_EN_EBD; 412 } else { 413 fman_dealloc_bufs_mask_hi = 0; 414 fman_dealloc_bufs_mask_lo = 0; 415 } 416 /* Is the MAC node 1G, 2.5G, 10G? */ 417 __if->__if.is_memac = 0; 418 419 if (of_device_is_compatible(mac_node, "fsl,fman-1g-mac")) 420 __if->__if.mac_type = fman_mac_1g; 421 else if (of_device_is_compatible(mac_node, "fsl,fman-10g-mac")) 422 __if->__if.mac_type = fman_mac_10g; 423 else if (of_device_is_compatible(mac_node, "fsl,fman-memac")) { 424 __if->__if.is_memac = 1; 425 char_prop = of_get_property(mac_node, "phy-connection-type", 426 NULL); 427 if (!char_prop) { 428 printf("memac: unknown MII type assuming 1G\n"); 429 /* Right now forcing memac to 1g in case of error*/ 430 __if->__if.mac_type = fman_mac_1g; 431 } else { 432 if (strstr(char_prop, "sgmii-2500")) 433 __if->__if.mac_type = fman_mac_2_5g; 434 else if (strstr(char_prop, "sgmii")) 435 __if->__if.mac_type = fman_mac_1g; 436 else if (strstr(char_prop, "rgmii")) { 437 __if->__if.mac_type = fman_mac_1g; 438 __if->__if.is_rgmii = 1; 439 } else if (strstr(char_prop, "xgmii")) 440 __if->__if.mac_type = fman_mac_10g; 441 } 442 } else { 443 FMAN_ERR(-EINVAL, "%s: unknown MAC type\n", mname); 444 goto err; 445 } 446 447 /* 448 * For MAC ports, we cannot rely on cell-index. In 449 * T2080, two of the 10G ports on single FMAN have same 450 * duplicate cell-indexes as the other two 10G ports on 451 * same FMAN. Hence, we now rely upon addresses of the 452 * ports from device tree to deduce the index. 453 */ 454 455 _errno = fman_get_mac_index(regs_addr_host, &__if->__if.mac_idx); 456 if (_errno) { 457 FMAN_ERR(-EINVAL, "Invalid register address: %" PRIx64, 458 regs_addr_host); 459 goto err; 460 } 461 462 /* Extract the MAC address for private and shared interfaces */ 463 mac_addr = of_get_property(mac_node, "local-mac-address", 464 &lenp); 465 if (!mac_addr) { 466 FMAN_ERR(-EINVAL, "%s: no local-mac-address\n", 467 mname); 468 goto err; 469 } 470 memcpy(&__if->__if.mac_addr, mac_addr, ETHER_ADDR_LEN); 471 472 /* Extract the channel ID (from tx-port-handle) */ 473 tx_channel_id = of_get_property(tx_node, "fsl,qman-channel-id", 474 &lenp); 475 if (!tx_channel_id) { 476 FMAN_ERR(-EINVAL, "%s: no fsl-qman-channel-id\n", 477 tx_node->full_name); 478 goto err; 479 } 480 481 regs_addr = of_get_address(rx_node, 0, &__if->regs_size, NULL); 482 if (!regs_addr) { 483 FMAN_ERR(-EINVAL, "of_get_address(%s)\n", mname); 484 goto err; 485 } 486 phys_addr = of_translate_address(rx_node, regs_addr); 487 if (!phys_addr) { 488 FMAN_ERR(-EINVAL, "of_translate_address(%s, %p)\n", 489 mname, regs_addr); 490 goto err; 491 } 492 __if->bmi_map = mmap(NULL, __if->regs_size, 493 PROT_READ | PROT_WRITE, MAP_SHARED, 494 fman_ccsr_map_fd, phys_addr); 495 if (__if->bmi_map == MAP_FAILED) { 496 FMAN_ERR(-errno, "mmap(0x%"PRIx64")\n", phys_addr); 497 goto err; 498 } 499 500 /* No channel ID for MAC-less */ 501 assert(lenp == sizeof(*tx_channel_id)); 502 na = of_n_addr_cells(mac_node); 503 __if->__if.tx_channel_id = of_read_number(tx_channel_id, na); 504 505 /* Extract the Rx FQIDs. (Note, the device representation is silly, 506 * there are "counts" that must always be 1.) 507 */ 508 rx_phandle = of_get_property(dpa_node, rprop, &lenp); 509 if (!rx_phandle) { 510 FMAN_ERR(-EINVAL, "%s: no fsl,qman-frame-queues-rx\n", dname); 511 goto err; 512 } 513 514 assert(lenp >= (4 * sizeof(phandle))); 515 516 na = of_n_addr_cells(mac_node); 517 /* Get rid of endianness (issues). Convert to host byte order */ 518 rx_phandle_host[0] = of_read_number(&rx_phandle[0], na); 519 rx_phandle_host[1] = of_read_number(&rx_phandle[1], na); 520 rx_phandle_host[2] = of_read_number(&rx_phandle[2], na); 521 rx_phandle_host[3] = of_read_number(&rx_phandle[3], na); 522 523 assert((rx_phandle_host[1] == 1) && (rx_phandle_host[3] == 1)); 524 __if->__if.fqid_rx_err = rx_phandle_host[0]; 525 __if->__if.fqid_rx_def = rx_phandle_host[2]; 526 527 /* Extract the Tx FQIDs */ 528 tx_phandle = of_get_property(dpa_node, 529 "fsl,qman-frame-queues-tx", &lenp); 530 if (!tx_phandle) { 531 FMAN_ERR(-EINVAL, "%s: no fsl,qman-frame-queues-tx\n", dname); 532 goto err; 533 } 534 535 assert(lenp >= (4 * sizeof(phandle))); 536 /*TODO: Fix for other cases also */ 537 na = of_n_addr_cells(mac_node); 538 /* Get rid of endianness (issues). Convert to host byte order */ 539 tx_phandle_host[0] = of_read_number(&tx_phandle[0], na); 540 tx_phandle_host[1] = of_read_number(&tx_phandle[1], na); 541 tx_phandle_host[2] = of_read_number(&tx_phandle[2], na); 542 tx_phandle_host[3] = of_read_number(&tx_phandle[3], na); 543 assert((tx_phandle_host[1] == 1) && (tx_phandle_host[3] == 1)); 544 __if->__if.fqid_tx_err = tx_phandle_host[0]; 545 __if->__if.fqid_tx_confirm = tx_phandle_host[2]; 546 547 /* Obtain the buffer pool nodes used by this interface */ 548 pools_phandle = of_get_property(dpa_node, "fsl,bman-buffer-pools", 549 &lenp); 550 if (!pools_phandle) { 551 FMAN_ERR(-EINVAL, "%s: no fsl,bman-buffer-pools\n", dname); 552 goto err; 553 } 554 /* For each pool, parse the corresponding node and add a pool object 555 * to the interface's "bpool_list" 556 */ 557 assert(lenp && !(lenp % sizeof(phandle))); 558 while (lenp) { 559 size_t proplen; 560 const phandle *prop; 561 uint64_t bpid_host = 0; 562 uint64_t bpool_host[6] = {0}; 563 const char *pname; 564 /* Allocate an object for the pool */ 565 bpool = rte_malloc(NULL, sizeof(*bpool), RTE_CACHE_LINE_SIZE); 566 if (!bpool) { 567 FMAN_ERR(-ENOMEM, "malloc(%zu)\n", sizeof(*bpool)); 568 goto err; 569 } 570 /* Find the pool node */ 571 pool_node = of_find_node_by_phandle(*pools_phandle); 572 if (!pool_node) { 573 FMAN_ERR(-ENXIO, "%s: bad fsl,bman-buffer-pools\n", 574 dname); 575 rte_free(bpool); 576 goto err; 577 } 578 pname = pool_node->full_name; 579 /* Extract the BPID property */ 580 prop = of_get_property(pool_node, "fsl,bpid", &proplen); 581 if (!prop) { 582 FMAN_ERR(-EINVAL, "%s: no fsl,bpid\n", pname); 583 rte_free(bpool); 584 goto err; 585 } 586 assert(proplen == sizeof(*prop)); 587 na = of_n_addr_cells(mac_node); 588 /* Get rid of endianness (issues). 589 * Convert to host byte-order 590 */ 591 bpid_host = of_read_number(prop, na); 592 bpool->bpid = bpid_host; 593 /* Extract the cfg property (count/size/addr). "fsl,bpool-cfg" 594 * indicates for the Bman driver to seed the pool. 595 * "fsl,bpool-ethernet-cfg" is used by the network driver. The 596 * two are mutually exclusive, so check for either of them. 597 */ 598 prop = of_get_property(pool_node, "fsl,bpool-cfg", 599 &proplen); 600 if (!prop) 601 prop = of_get_property(pool_node, 602 "fsl,bpool-ethernet-cfg", 603 &proplen); 604 if (!prop) { 605 /* It's OK for there to be no bpool-cfg */ 606 bpool->count = bpool->size = bpool->addr = 0; 607 } else { 608 assert(proplen == (6 * sizeof(*prop))); 609 na = of_n_addr_cells(mac_node); 610 /* Get rid of endianness (issues). 611 * Convert to host byte order 612 */ 613 bpool_host[0] = of_read_number(&prop[0], na); 614 bpool_host[1] = of_read_number(&prop[1], na); 615 bpool_host[2] = of_read_number(&prop[2], na); 616 bpool_host[3] = of_read_number(&prop[3], na); 617 bpool_host[4] = of_read_number(&prop[4], na); 618 bpool_host[5] = of_read_number(&prop[5], na); 619 620 bpool->count = ((uint64_t)bpool_host[0] << 32) | 621 bpool_host[1]; 622 bpool->size = ((uint64_t)bpool_host[2] << 32) | 623 bpool_host[3]; 624 bpool->addr = ((uint64_t)bpool_host[4] << 32) | 625 bpool_host[5]; 626 } 627 /* Parsing of the pool is complete, add it to the interface 628 * list. 629 */ 630 list_add_tail(&bpool->node, &__if->__if.bpool_list); 631 lenp -= sizeof(phandle); 632 pools_phandle++; 633 } 634 635 if (is_shared) 636 __if->__if.is_shared_mac = 1; 637 638 fman_if_vsp_init(__if); 639 640 /* Parsing of the network interface is complete, add it to the list */ 641 DPAA_BUS_LOG(DEBUG, "Found %s, Tx Channel = %x, FMAN = %x," 642 "Port ID = %x", 643 dname, __if->__if.tx_channel_id, __if->__if.fman_idx, 644 __if->__if.mac_idx); 645 646 list_add_tail(&__if->__if.node, &__ifs); 647 return 0; 648 err: 649 if_destructor(__if); 650 return _errno; 651 } 652 653 int 654 fman_init(void) 655 { 656 const struct device_node *dpa_node, *parent_node; 657 int _errno; 658 659 /* If multiple dependencies try to initialise the Fman driver, don't 660 * panic. 661 */ 662 if (fman_ccsr_map_fd != -1) 663 return 0; 664 665 fman_ccsr_map_fd = open(FMAN_DEVICE_PATH, O_RDWR); 666 if (unlikely(fman_ccsr_map_fd < 0)) { 667 DPAA_BUS_LOG(ERR, "Unable to open (/dev/mem)"); 668 return fman_ccsr_map_fd; 669 } 670 671 parent_node = of_find_compatible_node(NULL, NULL, "fsl,dpaa"); 672 if (!parent_node) { 673 DPAA_BUS_LOG(ERR, "Unable to find fsl,dpaa node"); 674 return -ENODEV; 675 } 676 677 for_each_child_node(parent_node, dpa_node) { 678 _errno = fman_if_init(dpa_node); 679 if (_errno) { 680 FMAN_ERR(_errno, "if_init(%s)\n", dpa_node->full_name); 681 goto err; 682 } 683 } 684 685 return 0; 686 err: 687 fman_finish(); 688 return _errno; 689 } 690 691 void 692 fman_finish(void) 693 { 694 struct __fman_if *__if, *tmpif; 695 696 assert(fman_ccsr_map_fd != -1); 697 698 list_for_each_entry_safe(__if, tmpif, &__ifs, __if.node) { 699 int _errno; 700 701 /* disable Rx and Tx */ 702 if ((__if->__if.mac_type == fman_mac_1g) && 703 (!__if->__if.is_memac)) 704 out_be32(__if->ccsr_map + 0x100, 705 in_be32(__if->ccsr_map + 0x100) & ~(u32)0x5); 706 else 707 out_be32(__if->ccsr_map + 8, 708 in_be32(__if->ccsr_map + 8) & ~(u32)3); 709 /* release the mapping */ 710 _errno = munmap(__if->ccsr_map, __if->regs_size); 711 if (unlikely(_errno < 0)) 712 fprintf(stderr, "%s:%d:%s(): munmap() = %d (%s)\n", 713 __FILE__, __LINE__, __func__, 714 -errno, strerror(errno)); 715 printf("Tearing down %s\n", __if->node_path); 716 list_del(&__if->__if.node); 717 rte_free(__if); 718 } 719 720 close(fman_ccsr_map_fd); 721 fman_ccsr_map_fd = -1; 722 } 723