sys/dev/vnic/thunder_bgx_fdt.c

   1 /*-
   2  * Copyright (c) 2015 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Semihalf under
   6  * the sponsorship of the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/bitset.h>
  36 #include <sys/bitstring.h>
  37 #include <sys/bus.h>
  38 #include <sys/endian.h>
  39 #include <sys/kernel.h>
  40 #include <sys/malloc.h>
  41 #include <sys/module.h>
  42 #include <sys/rman.h>
  43 #include <sys/pciio.h>
  44 #include <sys/pcpu.h>
  45 #include <sys/proc.h>
  46 #include <sys/socket.h>
  47 #include <sys/cpuset.h>
  48 #include <sys/lock.h>
  49 #include <sys/mutex.h>
  50
  51 #include <net/ethernet.h>
  52 #include <net/if.h>
  53 #include <net/if_media.h>
  54
  55 #include <dev/ofw/openfirm.h>
  56 #include <dev/ofw/ofw_bus.h>
  57 #include <dev/mii/miivar.h>
  58
  59 #include "thunder_bgx.h"
  60 #include "thunder_bgx_var.h"
  61
  62 #define CONN_TYPE_MAXLEN        16
  63 #define CONN_TYPE_OFFSET        2
  64
  65 #define BGX_NODE_NAME           "bgx"
  66 #define BGX_MAXID               9
  67 /* BGX func. 0, i.e.: reg = <0x8000 0 0 0 0>; DEVFN = 0x80 */
  68 #define BGX_DEVFN_0             0x80
  69
  70 #define FDT_NAME_MAXLEN         31
  71
  72 int bgx_fdt_init_phy(struct bgx *);
  73
  74 static void
  75 bgx_fdt_get_macaddr(phandle_t phy, uint8_t *hwaddr)
  76 {
  77         uint8_t addr[ETHER_ADDR_LEN];
  78
  79         if (OF_getprop(phy, "local-mac-address", addr, ETHER_ADDR_LEN) == -1) {
  80                 /* Missing MAC address should be marked by clearing it */
  81                 memset(hwaddr, 0, ETHER_ADDR_LEN);
  82         } else
  83                 memcpy(hwaddr, addr, ETHER_ADDR_LEN);
  84 }
  85
  86 static boolean_t
  87 bgx_fdt_phy_mode_match(struct bgx *bgx, char *qlm_mode, ssize_t size)
  88 {
  89         const char *type;
  90         ssize_t sz;
  91         ssize_t offset;
  92
  93         switch (bgx->qlm_mode) {
  94         case QLM_MODE_SGMII:
  95                 type = "sgmii";
  96                 sz = sizeof("sgmii") - 1;
  97                 offset = size - sz;
  98                 break;
  99         case QLM_MODE_XAUI_1X4:
 100                 type = "xaui";
 101                 sz = sizeof("xaui") - 1;
 102                 offset = size - sz;
 103                 if (offset < 0)
 104                         return (FALSE);
 105                 if (strncmp(&qlm_mode[offset], type, sz) == 0)
 106                         return (TRUE);
 107                 type = "dxaui";
 108                 sz = sizeof("dxaui") - 1;
 109                 offset = size - sz;
 110                 break;
 111         case QLM_MODE_RXAUI_2X2:
 112                 type = "raui";
 113                 sz = sizeof("raui") - 1;
 114                 offset = size - sz;
 115                 break;
 116         case QLM_MODE_XFI_4X1:
 117                 type = "xfi";
 118                 sz = sizeof("xfi") - 1;
 119                 offset = size - sz;
 120                 break;
 121         case QLM_MODE_XLAUI_1X4:
 122                 type = "xlaui";
 123                 sz = sizeof("xlaui") - 1;
 124                 offset = size - sz;
 125                 break;
 126         case QLM_MODE_10G_KR_4X1:
 127                 type = "xfi-10g-kr";
 128                 sz = sizeof("xfi-10g-kr") - 1;
 129                 offset = size - sz;
 130                 break;
 131         case QLM_MODE_40G_KR4_1X4:
 132                 type = "xlaui-40g-kr";
 133                 sz = sizeof("xlaui-40g-kr") - 1;
 134                 offset = size - sz;
 135                 break;
 136         default:
 137                 return (FALSE);
 138         }
 139
 140         if (offset < 0)
 141                 return (FALSE);
 142
 143         if (strncmp(&qlm_mode[offset], type, sz) == 0)
 144                 return (TRUE);
 145
 146         return (FALSE);
 147 }
 148
 149 static boolean_t
 150 bgx_fdt_phy_name_match(struct bgx *bgx, char *phy_name, ssize_t size)
 151 {
 152         const char *type;
 153         ssize_t sz;
 154
 155         switch (bgx->qlm_mode) {
 156         case QLM_MODE_SGMII:
 157                 type = "sgmii";
 158                 sz = sizeof("sgmii") - 1;
 159                 break;
 160         case QLM_MODE_XAUI_1X4:
 161                 type = "xaui";
 162                 sz = sizeof("xaui") - 1;
 163                 if (sz < size)
 164                         return (FALSE);
 165                 if (strncmp(phy_name, type, sz) == 0)
 166                         return (TRUE);
 167                 type = "dxaui";
 168                 sz = sizeof("dxaui") - 1;
 169                 break;
 170         case QLM_MODE_RXAUI_2X2:
 171                 type = "raui";
 172                 sz = sizeof("raui") - 1;
 173                 break;
 174         case QLM_MODE_XFI_4X1:
 175                 type = "xfi";
 176                 sz = sizeof("xfi") - 1;
 177                 break;
 178         case QLM_MODE_XLAUI_1X4:
 179                 type = "xlaui";
 180                 sz = sizeof("xlaui") - 1;
 181                 break;
 182         case QLM_MODE_10G_KR_4X1:
 183                 type = "xfi-10g-kr";
 184                 sz = sizeof("xfi-10g-kr") - 1;
 185                 break;
 186         case QLM_MODE_40G_KR4_1X4:
 187                 type = "xlaui-40g-kr";
 188                 sz = sizeof("xlaui-40g-kr") - 1;
 189                 break;
 190         default:
 191                 return (FALSE);
 192         }
 193
 194         if (sz > size)
 195                 return (FALSE);
 196         if (strncmp(phy_name, type, sz) == 0)
 197                 return (TRUE);
 198
 199         return (FALSE);
 200 }
 201
 202 static phandle_t
 203 bgx_fdt_traverse_nodes(uint8_t unit, phandle_t start, char *name,
 204     size_t len)
 205 {
 206         phandle_t node, ret;
 207         uint32_t *reg;
 208         size_t buf_size;
 209         ssize_t proplen;
 210         char *node_name;
 211         int err;
 212
 213         /*
 214          * Traverse all subordinate nodes of 'start' to find BGX instance.
 215          * This supports both old (by name) and new (by reg) methods.
 216          */
 217         buf_size = sizeof(*node_name) * FDT_NAME_MAXLEN;
 218         if (len > buf_size) {
 219                 /*
 220                  * This is an erroneous situation since the string
 221                  * to compare cannot be longer than FDT_NAME_MAXLEN.
 222                  */
 223                 return (0);
 224         }
 225
 226         node_name = malloc(buf_size, M_BGX, M_WAITOK);
 227         for (node = OF_child(start); node != 0; node = OF_peer(node)) {
 228                 /* Clean-up the buffer */
 229                 memset(node_name, 0, buf_size);
 230                 /* Recurse to children */
 231                 if (OF_child(node) != 0) {
 232                         ret = bgx_fdt_traverse_nodes(unit, node, name, len);
 233                         if (ret != 0) {
 234                                 free(node_name, M_BGX);
 235                                 return (ret);
 236                         }
 237                 }
 238                 /*
 239                  * Old way - by name
 240                  */
 241                 proplen = OF_getproplen(node, "name");
 242                 if ((proplen <= 0) || (proplen < len))
 243                         continue;
 244
 245                 err = OF_getprop(node, "name", node_name, proplen);
 246                 if (err <= 0)
 247                         continue;
 248
 249                 if (strncmp(node_name, name, len) == 0) {
 250                         free(node_name, M_BGX);
 251                         return (node);
 252                 }
 253                 /*
 254                  * New way - by reg
 255                  */
 256                 /* Check if even BGX */
 257                 if (strncmp(node_name,
 258                     BGX_NODE_NAME, sizeof(BGX_NODE_NAME) - 1) != 0)
 259                         continue;
 260                 /* Get reg */
 261                 err = OF_getencprop_alloc_multi(node, "reg", sizeof(*reg),
 262                     (void **)&reg);
 263                 if (err == -1) {
 264                         free(reg, M_OFWPROP);
 265                         continue;
 266                 }
 267
 268                 /* Match BGX device function */
 269                 if ((BGX_DEVFN_0 + unit) == (reg[0] >> 8)) {
 270                         free(reg, M_OFWPROP);
 271                         free(node_name, M_BGX);
 272                         return (node);
 273                 }
 274                 free(reg, M_OFWPROP);
 275         }
 276         free(node_name, M_BGX);
 277
 278         return (0);
 279 }
 280
 281 /*
 282  * Similar functionality to pci_find_pcie_root_port()
 283  * but this one works for ThunderX.
 284  */
 285 static device_t
 286 bgx_find_root_pcib(device_t dev)
 287 {
 288         devclass_t pci_class;
 289         device_t pcib, bus;
 290
 291         pci_class = devclass_find("pci");
 292         KASSERT(device_get_devclass(device_get_parent(dev)) == pci_class,
 293             ("%s: non-pci device %s", __func__, device_get_nameunit(dev)));
 294
 295         /* Walk the bridge hierarchy until we find a non-PCI device */
 296         for (;;) {
 297                 bus = device_get_parent(dev);
 298                 KASSERT(bus != NULL, ("%s: null parent of %s", __func__,
 299                     device_get_nameunit(dev)));
 300
 301                 if (device_get_devclass(bus) != pci_class)
 302                         return (NULL);
 303
 304                 pcib = device_get_parent(bus);
 305                 KASSERT(pcib != NULL, ("%s: null bridge of %s", __func__,
 306                     device_get_nameunit(bus)));
 307
 308                 /*
 309                  * If the parent of this PCIB is not PCI
 310                  * then we found our root PCIB.
 311                  */
 312                 if (device_get_devclass(device_get_parent(pcib)) != pci_class)
 313                         return (pcib);
 314
 315                 dev = pcib;
 316         }
 317 }
 318
 319 static __inline phandle_t
 320 bgx_fdt_find_node(struct bgx *bgx)
 321 {
 322         device_t root_pcib;
 323         phandle_t node;
 324         char *bgx_sel;
 325         size_t len;
 326
 327         KASSERT(bgx->bgx_id <= BGX_MAXID,
 328             ("Invalid BGX ID: %d, max: %d", bgx->bgx_id, BGX_MAXID));
 329
 330         len = sizeof(BGX_NODE_NAME) + 1; /* <bgx_name>+<digit>+<\0> */
 331         /* Allocate memory for BGX node name + "/" character */
 332         bgx_sel = malloc(sizeof(*bgx_sel) * (len + 1), M_BGX,
 333             M_ZERO | M_WAITOK);
 334
 335         /* Prepare node's name */
 336         snprintf(bgx_sel, len + 1, "/"BGX_NODE_NAME"%d", bgx->bgx_id);
 337         /* First try the root node */
 338         node =  OF_finddevice(bgx_sel);
 339         if (node != -1) {
 340                 /* Found relevant node */
 341                 goto out;
 342         }
 343         /*
 344          * Clean-up and try to find BGX in DT
 345          * starting from the parent PCI bridge node.
 346          */
 347         memset(bgx_sel, 0, sizeof(*bgx_sel) * (len + 1));
 348         snprintf(bgx_sel, len, BGX_NODE_NAME"%d", bgx->bgx_id);
 349
 350         /* Find PCI bridge that we are connected to */
 351
 352         root_pcib = bgx_find_root_pcib(bgx->dev);
 353         if (root_pcib == NULL) {
 354                 device_printf(bgx->dev, "Unable to find BGX root bridge\n");
 355                 node = 0;
 356                 goto out;
 357         }
 358
 359         node = ofw_bus_get_node(root_pcib);
 360         if ((int)node <= 0) {
 361                 device_printf(bgx->dev, "No parent FDT node for BGX\n");
 362                 goto out;
 363         }
 364
 365         node = bgx_fdt_traverse_nodes(bgx->bgx_id, node, bgx_sel, len);
 366 out:
 367         free(bgx_sel, M_BGX);
 368         return (node);
 369 }
 370
 371 int
 372 bgx_fdt_init_phy(struct bgx *bgx)
 373 {
 374         char *node_name;
 375         phandle_t node, child;
 376         phandle_t phy, mdio;
 377         ssize_t len;
 378         uint8_t lmac;
 379         char qlm_mode[CONN_TYPE_MAXLEN];
 380
 381         node = bgx_fdt_find_node(bgx);
 382         if (node == 0) {
 383                 device_printf(bgx->dev,
 384                     "Could not find bgx%d node in FDT\n", bgx->bgx_id);
 385                 return (ENXIO);
 386         }
 387
 388         lmac = 0;
 389         for (child = OF_child(node); child > 0; child = OF_peer(child)) {
 390                 len = OF_getprop(child, "qlm-mode", qlm_mode, sizeof(qlm_mode));
 391                 if (len > 0) {
 392                         if (!bgx_fdt_phy_mode_match(bgx, qlm_mode, len)) {
 393                                 /*
 394                                  * Connection type not match with BGX mode.
 395                                  */
 396                                 continue;
 397                         }
 398                 } else {
 399                         len = OF_getprop_alloc(child, "name",
 400                             (void **)&node_name);
 401                         if (len <= 0) {
 402                                 continue;
 403                         }
 404
 405                         if (!bgx_fdt_phy_name_match(bgx, node_name, len)) {
 406                                 free(node_name, M_OFWPROP);
 407                                 continue;
 408                         }
 409                         free(node_name, M_OFWPROP);
 410                 }
 411
 412                 /* Acquire PHY address */
 413                 if (OF_getencprop(child, "reg", &bgx->lmac[lmac].phyaddr,
 414                     sizeof(bgx->lmac[lmac].phyaddr)) <= 0) {
 415                         if (bootverbose) {
 416                                 device_printf(bgx->dev,
 417                                     "Could not retrieve PHY address\n");
 418                         }
 419                         bgx->lmac[lmac].phyaddr = MII_PHY_ANY;
 420                 }
 421
 422                 if (OF_getencprop(child, "phy-handle", &phy,
 423                     sizeof(phy)) <= 0) {
 424                         if (bootverbose) {
 425                                 device_printf(bgx->dev,
 426                                     "No phy-handle in PHY node. Skipping...\n");
 427                         }
 428                         continue;
 429                 }
 430                 phy = OF_instance_to_package(phy);
 431                 /*
 432                  * Get PHY interface (MDIO bus) device.
 433                  * Driver must be already attached.
 434                  */
 435                 mdio = OF_parent(phy);
 436                 bgx->lmac[lmac].phy_if_dev =
 437                     OF_device_from_xref(OF_xref_from_node(mdio));
 438                 if (bgx->lmac[lmac].phy_if_dev == NULL) {
 439                         if (bootverbose) {
 440                                 device_printf(bgx->dev,
 441                                     "Could not find interface to PHY\n");
 442                         }
 443                         continue;
 444                 }
 445
 446                 /* Get mac address from FDT */
 447                 bgx_fdt_get_macaddr(child, bgx->lmac[lmac].mac);
 448
 449                 bgx->lmac[lmac].lmacid = lmac;
 450                 lmac++;
 451                 if (lmac == MAX_LMAC_PER_BGX)
 452                         break;
 453         }
 454         if (lmac == 0) {
 455                 device_printf(bgx->dev, "Could not find matching PHY\n");
 456                 return (ENXIO);
 457         }
 458
 459         return (0);
 460 }