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 "t4_if.h"
  45
  46 struct t4iov_softc {
  47         device_t sc_dev;
  48         device_t sc_main;
  49         bool sc_attached;
  50 };
  51
  52 struct {
  53         uint16_t device;
  54         char *desc;
  55 } t4iov_pciids[] = {
  56         {0x4000, "Chelsio T440-dbg"},
  57         {0x4001, "Chelsio T420-CR"},
  58         {0x4002, "Chelsio T422-CR"},
  59         {0x4003, "Chelsio T440-CR"},
  60         {0x4004, "Chelsio T420-BCH"},
  61         {0x4005, "Chelsio T440-BCH"},
  62         {0x4006, "Chelsio T440-CH"},
  63         {0x4007, "Chelsio T420-SO"},
  64         {0x4008, "Chelsio T420-CX"},
  65         {0x4009, "Chelsio T420-BT"},
  66         {0x400a, "Chelsio T404-BT"},
  67         {0x400e, "Chelsio T440-LP-CR"},
  68 }, t5iov_pciids[] = {
  69         {0x5000, "Chelsio T580-dbg"},
  70         {0x5001,  "Chelsio T520-CR"},           /* 2 x 10G */
  71         {0x5002,  "Chelsio T522-CR"},           /* 2 x 10G, 2 X 1G */
  72         {0x5003,  "Chelsio T540-CR"},           /* 4 x 10G */
  73         {0x5007,  "Chelsio T520-SO"},           /* 2 x 10G, nomem */
  74         {0x5009,  "Chelsio T520-BT"},           /* 2 x 10GBaseT */
  75         {0x500a,  "Chelsio T504-BT"},           /* 4 x 1G */
  76         {0x500d,  "Chelsio T580-CR"},           /* 2 x 40G */
  77         {0x500e,  "Chelsio T540-LP-CR"},        /* 4 x 10G */
  78         {0x5010,  "Chelsio T580-LP-CR"},        /* 2 x 40G */
  79         {0x5011,  "Chelsio T520-LL-CR"},        /* 2 x 10G */
  80         {0x5012,  "Chelsio T560-CR"},           /* 1 x 40G, 2 x 10G */
  81         {0x5014,  "Chelsio T580-LP-SO-CR"},     /* 2 x 40G, nomem */
  82         {0x5015,  "Chelsio T502-BT"},           /* 2 x 1G */
  83 #ifdef notyet
  84         {0x5004,  "Chelsio T520-BCH"},
  85         {0x5005,  "Chelsio T540-BCH"},
  86         {0x5006,  "Chelsio T540-CH"},
  87         {0x5008,  "Chelsio T520-CX"},
  88         {0x500b,  "Chelsio B520-SR"},
  89         {0x500c,  "Chelsio B504-BT"},
  90         {0x500f,  "Chelsio Amsterdam"},
  91         {0x5013,  "Chelsio T580-CHR"},
  92 #endif
  93 };
  94
  95 static int      t4iov_attach_child(device_t dev);
  96
  97 static int
  98 t4iov_probe(device_t dev)
  99 {
 100         uint16_t d;
 101         size_t i;
 102
 103         d = pci_get_device(dev);
 104         for (i = 0; i < nitems(t4iov_pciids); i++) {
 105                 if (d == t4iov_pciids[i].device) {
 106                         device_set_desc(dev, t4iov_pciids[i].desc);
 107                         device_quiet(dev);
 108                         return (BUS_PROBE_DEFAULT);
 109                 }
 110         }
 111         return (ENXIO);
 112 }
 113
 114 static int
 115 t5iov_probe(device_t dev)
 116 {
 117         uint16_t d;
 118         size_t i;
 119
 120         d = pci_get_device(dev);
 121         for (i = 0; i < nitems(t5iov_pciids); i++) {
 122                 if (d == t5iov_pciids[i].device) {
 123                         device_set_desc(dev, t5iov_pciids[i].desc);
 124                         device_quiet(dev);
 125                         return (BUS_PROBE_DEFAULT);
 126                 }
 127         }
 128         return (ENXIO);
 129 }
 130
 131 static int
 132 t4iov_attach(device_t dev)
 133 {
 134         struct t4iov_softc *sc;
 135
 136         sc = device_get_softc(dev);
 137         sc->sc_dev = dev;
 138
 139         sc->sc_main = pci_find_dbsf(pci_get_domain(dev), pci_get_bus(dev),
 140             pci_get_slot(dev), 4);
 141         if (T4_IS_MAIN_READY(sc->sc_main) == 0)
 142                 return (t4iov_attach_child(dev));
 143         return (0);
 144 }
 145
 146 static int
 147 t4iov_attach_child(device_t dev)
 148 {
 149         struct t4iov_softc *sc;
 150 #ifdef PCI_IOV
 151         nvlist_t *pf_schema, *vf_schema;
 152 #endif
 153         device_t pdev;
 154         int error;
 155
 156         sc = device_get_softc(dev);
 157         MPASS(!sc->sc_attached);
 158
 159         /*
 160          * PF0-3 are associated with a specific port on the NIC (PF0
 161          * with port 0, etc.).  Ask the PF4 driver for the device for
 162          * this function's associated port to determine if the port is
 163          * present.
 164          */
 165         error = T4_READ_PORT_DEVICE(sc->sc_main, pci_get_function(dev), &pdev);
 166         if (error)
 167                 return (0);
 168
 169 #ifdef PCI_IOV
 170         pf_schema = pci_iov_schema_alloc_node();
 171         vf_schema = pci_iov_schema_alloc_node();
 172         error = pci_iov_attach_name(dev, pf_schema, vf_schema, "%s",
 173             device_get_nameunit(pdev));
 174         if (error) {
 175                 device_printf(dev, "Failed to initialize SR-IOV: %d\n", error);
 176                 return (0);
 177         }
 178 #endif
 179
 180         sc->sc_attached = true;
 181         return (0);
 182 }
 183
 184 static int
 185 t4iov_detach_child(device_t dev)
 186 {
 187         struct t4iov_softc *sc;
 188 #ifdef PCI_IOV
 189         int error;
 190 #endif
 191
 192         sc = device_get_softc(dev);
 193         if (!sc->sc_attached)
 194                 return (0);
 195
 196 #ifdef PCI_IOV
 197         error = pci_iov_detach(dev);
 198         if (error != 0) {
 199                 device_printf(dev, "Failed to disable SR-IOV\n");
 200                 return (error);
 201         }
 202 #endif
 203
 204         sc->sc_attached = false;
 205         return (0);
 206 }
 207
 208 static int
 209 t4iov_detach(device_t dev)
 210 {
 211         struct t4iov_softc *sc;
 212         int error;
 213
 214         sc = device_get_softc(dev);
 215         if (sc->sc_attached) {
 216                 error = t4iov_detach_child(dev);
 217                 if (error)
 218                         return (error);
 219         }
 220         return (0);
 221 }
 222
 223 #ifdef PCI_IOV
 224 static int
 225 t4iov_iov_init(device_t dev, uint16_t num_vfs, const struct nvlist *config)
 226 {
 227
 228         /* XXX: The Linux driver sets up a vf_monitor task on T4 adapters. */
 229         return (0);
 230 }
 231
 232 static void
 233 t4iov_iov_uninit(device_t dev)
 234 {
 235 }
 236
 237 static int
 238 t4iov_add_vf(device_t dev, uint16_t vfnum, const struct nvlist *config)
 239 {
 240
 241         return (0);
 242 }
 243 #endif
 244
 245 static device_method_t t4iov_methods[] = {
 246         DEVMETHOD(device_probe,         t4iov_probe),
 247         DEVMETHOD(device_attach,        t4iov_attach),
 248         DEVMETHOD(device_detach,        t4iov_detach),
 249
 250 #ifdef PCI_IOV
 251         DEVMETHOD(pci_iov_init,         t4iov_iov_init),
 252         DEVMETHOD(pci_iov_uninit,       t4iov_iov_uninit),
 253         DEVMETHOD(pci_iov_add_vf,       t4iov_add_vf),
 254 #endif
 255
 256         DEVMETHOD(t4_attach_child,      t4iov_attach_child),
 257         DEVMETHOD(t4_detach_child,      t4iov_detach_child),
 258
 259         DEVMETHOD_END
 260 };
 261
 262 static driver_t t4iov_driver = {
 263         "t4iov",
 264         t4iov_methods,
 265         sizeof(struct t4iov_softc)
 266 };
 267
 268 static device_method_t t5iov_methods[] = {
 269         DEVMETHOD(device_probe,         t5iov_probe),
 270         DEVMETHOD(device_attach,        t4iov_attach),
 271         DEVMETHOD(device_detach,        t4iov_detach),
 272
 273 #ifdef PCI_IOV
 274         DEVMETHOD(pci_iov_init,         t4iov_iov_init),
 275         DEVMETHOD(pci_iov_uninit,       t4iov_iov_uninit),
 276         DEVMETHOD(pci_iov_add_vf,       t4iov_add_vf),
 277 #endif
 278
 279         DEVMETHOD(t4_attach_child,      t4iov_attach_child),
 280         DEVMETHOD(t4_detach_child,      t4iov_detach_child),
 281
 282         DEVMETHOD_END
 283 };
 284
 285 static driver_t t5iov_driver = {
 286         "t5iov",
 287         t5iov_methods,
 288         sizeof(struct t4iov_softc)
 289 };
 290
 291 static devclass_t t4iov_devclass, t5iov_devclass;
 292
 293 DRIVER_MODULE(t4iov, pci, t4iov_driver, t4iov_devclass, 0, 0);
 294 MODULE_VERSION(t4iov, 1);
 295
 296 DRIVER_MODULE(t5iov, pci, t5iov_driver, t5iov_devclass, 0, 0);
 297 MODULE_VERSION(t5iov, 1);