sys/dev/cxgbe/t4_iov.c

   1 /*-
   2  * Copyright (c) 2015-2016 Chelsio Communications, Inc.
   3  * All rights reserved.
   4  * Written by: John Baldwin <jhb@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/bus.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/systm.h>
  36 #include <dev/pci/pcivar.h>
  37
  38 #ifdef PCI_IOV
  39 #include <sys/nv.h>
  40 #include <sys/iov_schema.h>
  41 #include <dev/pci/pci_iov.h>
  42 #endif
  43
  44 #include "common/common.h"
  45 #include "t4_if.h"
  46
  47 struct t4iov_softc {
  48         device_t sc_dev;
  49         device_t sc_main;
  50         bool sc_attached;
  51 };
  52
  53 struct {
  54         uint16_t device;
  55         char *desc;
  56 } t4iov_pciids[] = {
  57         {0x4000, "Chelsio T440-dbg"},
  58         {0x4001, "Chelsio T420-CR"},
  59         {0x4002, "Chelsio T422-CR"},
  60         {0x4003, "Chelsio T440-CR"},
  61         {0x4004, "Chelsio T420-BCH"},
  62         {0x4005, "Chelsio T440-BCH"},
  63         {0x4006, "Chelsio T440-CH"},
  64         {0x4007, "Chelsio T420-SO"},
  65         {0x4008, "Chelsio T420-CX"},
  66         {0x4009, "Chelsio T420-BT"},
  67         {0x400a, "Chelsio T404-BT"},
  68         {0x400e, "Chelsio T440-LP-CR"},
  69 }, t5iov_pciids[] = {
  70         {0x5000, "Chelsio T580-dbg"},
  71         {0x5001,  "Chelsio T520-CR"},           /* 2 x 10G */
  72         {0x5002,  "Chelsio T522-CR"},           /* 2 x 10G, 2 X 1G */
  73         {0x5003,  "Chelsio T540-CR"},           /* 4 x 10G */
  74         {0x5007,  "Chelsio T520-SO"},           /* 2 x 10G, nomem */
  75         {0x5009,  "Chelsio T520-BT"},           /* 2 x 10GBaseT */
  76         {0x500a,  "Chelsio T504-BT"},           /* 4 x 1G */
  77         {0x500d,  "Chelsio T580-CR"},           /* 2 x 40G */
  78         {0x500e,  "Chelsio T540-LP-CR"},        /* 4 x 10G */
  79         {0x5010,  "Chelsio T580-LP-CR"},        /* 2 x 40G */
  80         {0x5011,  "Chelsio T520-LL-CR"},        /* 2 x 10G */
  81         {0x5012,  "Chelsio T560-CR"},           /* 1 x 40G, 2 x 10G */
  82         {0x5014,  "Chelsio T580-LP-SO-CR"},     /* 2 x 40G, nomem */
  83         {0x5015,  "Chelsio T502-BT"},           /* 2 x 1G */
  84 #ifdef notyet
  85         {0x5004,  "Chelsio T520-BCH"},
  86         {0x5005,  "Chelsio T540-BCH"},
  87         {0x5006,  "Chelsio T540-CH"},
  88         {0x5008,  "Chelsio T520-CX"},
  89         {0x500b,  "Chelsio B520-SR"},
  90         {0x500c,  "Chelsio B504-BT"},
  91         {0x500f,  "Chelsio Amsterdam"},
  92         {0x5013,  "Chelsio T580-CHR"},
  93 #endif
  94 }, t6iov_pciids[] = {
  95         {0x6001, "Chelsio T6225-CR"},           /* 2 x 10/25G */
  96         {0x6002, "Chelsio T6225-SO-CR"},        /* 2 x 10/25G, nomem */
  97         {0x6007, "Chelsio T62100-LP-CR"},       /* 2 x 40/50/100G */
  98         {0x6008, "Chelsio T62100-SO-CR"},       /* 2 x 40/50/100G, nomem */
  99         {0x600d, "Chelsio T62100-CR"},          /* 2 x 40/50/100G */
 100 };
 101
 102 static int      t4iov_attach_child(device_t dev);
 103
 104 static int
 105 t4iov_probe(device_t dev)
 106 {
 107         uint16_t d;
 108         size_t i;
 109
 110         if (pci_get_vendor(dev) != PCI_VENDOR_ID_CHELSIO)
 111                 return (ENXIO);
 112
 113         d = pci_get_device(dev);
 114         for (i = 0; i < nitems(t4iov_pciids); i++) {
 115                 if (d == t4iov_pciids[i].device) {
 116                         device_set_desc(dev, t4iov_pciids[i].desc);
 117                         device_quiet(dev);
 118                         return (BUS_PROBE_DEFAULT);
 119                 }
 120         }
 121         return (ENXIO);
 122 }
 123
 124 static int
 125 t5iov_probe(device_t dev)
 126 {
 127         uint16_t d;
 128         size_t i;
 129
 130         if (pci_get_vendor(dev) != PCI_VENDOR_ID_CHELSIO)
 131                 return (ENXIO);
 132
 133         d = pci_get_device(dev);
 134         for (i = 0; i < nitems(t5iov_pciids); i++) {
 135                 if (d == t5iov_pciids[i].device) {
 136                         device_set_desc(dev, t5iov_pciids[i].desc);
 137                         device_quiet(dev);
 138                         return (BUS_PROBE_DEFAULT);
 139                 }
 140         }
 141         return (ENXIO);
 142 }
 143
 144 static int
 145 t6iov_probe(device_t dev)
 146 {
 147         uint16_t d;
 148         size_t i;
 149
 150         if (pci_get_vendor(dev) != PCI_VENDOR_ID_CHELSIO)
 151                 return (ENXIO);
 152
 153         d = pci_get_device(dev);
 154         for (i = 0; i < nitems(t6iov_pciids); i++) {
 155                 if (d == t6iov_pciids[i].device) {
 156                         device_set_desc(dev, t6iov_pciids[i].desc);
 157                         device_quiet(dev);
 158                         return (BUS_PROBE_DEFAULT);
 159                 }
 160         }
 161         return (ENXIO);
 162 }
 163
 164 static int
 165 t4iov_attach(device_t dev)
 166 {
 167         struct t4iov_softc *sc;
 168
 169         sc = device_get_softc(dev);
 170         sc->sc_dev = dev;
 171
 172         sc->sc_main = pci_find_dbsf(pci_get_domain(dev), pci_get_bus(dev),
 173             pci_get_slot(dev), 4);
 174         if (sc->sc_main == NULL)
 175                 return (ENXIO);
 176         if (T4_IS_MAIN_READY(sc->sc_main) == 0)
 177                 return (t4iov_attach_child(dev));
 178         return (0);
 179 }
 180
 181 static int
 182 t4iov_attach_child(device_t dev)
 183 {
 184         struct t4iov_softc *sc;
 185 #ifdef PCI_IOV
 186         nvlist_t *pf_schema, *vf_schema;
 187 #endif
 188         device_t pdev;
 189         int error;
 190
 191         sc = device_get_softc(dev);
 192         MPASS(!sc->sc_attached);
 193
 194         /*
 195          * PF0-3 are associated with a specific port on the NIC (PF0
 196          * with port 0, etc.).  Ask the PF4 driver for the device for
 197          * this function's associated port to determine if the port is
 198          * present.
 199          */
 200         error = T4_READ_PORT_DEVICE(sc->sc_main, pci_get_function(dev), &pdev);
 201         if (error)
 202                 return (0);
 203
 204 #ifdef PCI_IOV
 205         pf_schema = pci_iov_schema_alloc_node();
 206         vf_schema = pci_iov_schema_alloc_node();
 207         error = pci_iov_attach_name(dev, pf_schema, vf_schema, "%s",
 208             device_get_nameunit(pdev));
 209         if (error) {
 210                 device_printf(dev, "Failed to initialize SR-IOV: %d\n", error);
 211                 return (0);
 212         }
 213 #endif
 214
 215         sc->sc_attached = true;
 216         return (0);
 217 }
 218
 219 static int
 220 t4iov_detach_child(device_t dev)
 221 {
 222         struct t4iov_softc *sc;
 223 #ifdef PCI_IOV
 224         int error;
 225 #endif
 226
 227         sc = device_get_softc(dev);
 228         if (!sc->sc_attached)
 229                 return (0);
 230
 231 #ifdef PCI_IOV
 232         error = pci_iov_detach(dev);
 233         if (error != 0) {
 234                 device_printf(dev, "Failed to disable SR-IOV\n");
 235                 return (error);
 236         }
 237 #endif
 238
 239         sc->sc_attached = false;
 240         return (0);
 241 }
 242
 243 static int
 244 t4iov_detach(device_t dev)
 245 {
 246         struct t4iov_softc *sc;
 247         int error;
 248
 249         sc = device_get_softc(dev);
 250         if (sc->sc_attached) {
 251                 error = t4iov_detach_child(dev);
 252                 if (error)
 253                         return (error);
 254         }
 255         return (0);
 256 }
 257
 258 #ifdef PCI_IOV
 259 static int
 260 t4iov_iov_init(device_t dev, uint16_t num_vfs, const struct nvlist *config)
 261 {
 262
 263         /* XXX: The Linux driver sets up a vf_monitor task on T4 adapters. */
 264         return (0);
 265 }
 266
 267 static void
 268 t4iov_iov_uninit(device_t dev)
 269 {
 270 }
 271
 272 static int
 273 t4iov_add_vf(device_t dev, uint16_t vfnum, const struct nvlist *config)
 274 {
 275
 276         return (0);
 277 }
 278 #endif
 279
 280 static device_method_t t4iov_methods[] = {
 281         DEVMETHOD(device_probe,         t4iov_probe),
 282         DEVMETHOD(device_attach,        t4iov_attach),
 283         DEVMETHOD(device_detach,        t4iov_detach),
 284
 285 #ifdef PCI_IOV
 286         DEVMETHOD(pci_iov_init,         t4iov_iov_init),
 287         DEVMETHOD(pci_iov_uninit,       t4iov_iov_uninit),
 288         DEVMETHOD(pci_iov_add_vf,       t4iov_add_vf),
 289 #endif
 290
 291         DEVMETHOD(t4_attach_child,      t4iov_attach_child),
 292         DEVMETHOD(t4_detach_child,      t4iov_detach_child),
 293
 294         DEVMETHOD_END
 295 };
 296
 297 static driver_t t4iov_driver = {
 298         "t4iov",
 299         t4iov_methods,
 300         sizeof(struct t4iov_softc)
 301 };
 302
 303 static device_method_t t5iov_methods[] = {
 304         DEVMETHOD(device_probe,         t5iov_probe),
 305         DEVMETHOD(device_attach,        t4iov_attach),
 306         DEVMETHOD(device_detach,        t4iov_detach),
 307
 308 #ifdef PCI_IOV
 309         DEVMETHOD(pci_iov_init,         t4iov_iov_init),
 310         DEVMETHOD(pci_iov_uninit,       t4iov_iov_uninit),
 311         DEVMETHOD(pci_iov_add_vf,       t4iov_add_vf),
 312 #endif
 313
 314         DEVMETHOD(t4_attach_child,      t4iov_attach_child),
 315         DEVMETHOD(t4_detach_child,      t4iov_detach_child),
 316
 317         DEVMETHOD_END
 318 };
 319
 320 static driver_t t5iov_driver = {
 321         "t5iov",
 322         t5iov_methods,
 323         sizeof(struct t4iov_softc)
 324 };
 325
 326 static device_method_t t6iov_methods[] = {
 327         DEVMETHOD(device_probe,         t6iov_probe),
 328         DEVMETHOD(device_attach,        t4iov_attach),
 329         DEVMETHOD(device_detach,        t4iov_detach),
 330
 331 #ifdef PCI_IOV
 332         DEVMETHOD(pci_iov_init,         t4iov_iov_init),
 333         DEVMETHOD(pci_iov_uninit,       t4iov_iov_uninit),
 334         DEVMETHOD(pci_iov_add_vf,       t4iov_add_vf),
 335 #endif
 336
 337         DEVMETHOD(t4_attach_child,      t4iov_attach_child),
 338         DEVMETHOD(t4_detach_child,      t4iov_detach_child),
 339
 340         DEVMETHOD_END
 341 };
 342
 343 static driver_t t6iov_driver = {
 344         "t6iov",
 345         t6iov_methods,
 346         sizeof(struct t4iov_softc)
 347 };
 348
 349 static devclass_t t4iov_devclass, t5iov_devclass, t6iov_devclass;
 350
 351 DRIVER_MODULE(t4iov, pci, t4iov_driver, t4iov_devclass, 0, 0);
 352 MODULE_VERSION(t4iov, 1);
 353
 354 DRIVER_MODULE(t5iov, pci, t5iov_driver, t5iov_devclass, 0, 0);
 355 MODULE_VERSION(t5iov, 1);
 356
 357 DRIVER_MODULE(t6iov, pci, t6iov_driver, t6iov_devclass, 0, 0);
 358 MODULE_VERSION(t6iov, 1);