drivers/bus/dpaa/base/fman/fman.c

   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         rte_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, &regs_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 }