sys/dev/pci/pci_iov.c

   1 /*-
   2  * Copyright (c) 2013-2015 Sandvine Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_bus.h"
  31
  32 #include <sys/param.h>
  33 #include <sys/conf.h>
  34 #include <sys/kernel.h>
  35 #include <sys/systm.h>
  36 #include <sys/bus.h>
  37 #include <sys/fcntl.h>
  38 #include <sys/ioccom.h>
  39 #include <sys/iov.h>
  40 #include <sys/linker.h>
  41 #include <sys/malloc.h>
  42 #include <sys/module.h>
  43 #include <sys/pciio.h>
  44 #include <sys/queue.h>
  45 #include <sys/rman.h>
  46 #include <sys/sysctl.h>
  47
  48 #include <machine/bus.h>
  49 #include <machine/stdarg.h>
  50
  51 #include <sys/nv.h>
  52 #include <sys/iov_schema.h>
  53
  54 #include <dev/pci/pcireg.h>
  55 #include <dev/pci/pcivar.h>
  56 #include <dev/pci/pci_iov.h>
  57 #include <dev/pci/pci_private.h>
  58 #include <dev/pci/pci_iov_private.h>
  59 #include <dev/pci/schema_private.h>
  60
  61 #include "pcib_if.h"
  62
  63 static MALLOC_DEFINE(M_SRIOV, "sr_iov", "PCI SR-IOV allocations");
  64
  65 static d_ioctl_t pci_iov_ioctl;
  66
  67 static struct cdevsw iov_cdevsw = {
  68         .d_version = D_VERSION,
  69         .d_name = "iov",
  70         .d_ioctl = pci_iov_ioctl
  71 };
  72
  73 SYSCTL_DECL(_hw_pci);
  74
  75 /*
  76  * The maximum amount of memory we will allocate for user configuration of an
  77  * SR-IOV device.  1MB ought to be enough for anyone, but leave this
  78  * configurable just in case.
  79  */
  80 static u_long pci_iov_max_config = 1024 * 1024;
  81 SYSCTL_ULONG(_hw_pci, OID_AUTO, iov_max_config, CTLFLAG_RWTUN,
  82     &pci_iov_max_config, 0, "Maximum allowed size of SR-IOV configuration.");
  83
  84
  85 #define IOV_READ(d, r, w) \
  86         pci_read_config((d)->cfg.dev, (d)->cfg.iov->iov_pos + r, w)
  87
  88 #define IOV_WRITE(d, r, v, w) \
  89         pci_write_config((d)->cfg.dev, (d)->cfg.iov->iov_pos + r, v, w)
  90
  91 static nvlist_t *pci_iov_build_schema(nvlist_t **pf_schema,
  92                     nvlist_t **vf_schema);
  93 static void     pci_iov_build_pf_schema(nvlist_t *schema,
  94                     nvlist_t **driver_schema);
  95 static void     pci_iov_build_vf_schema(nvlist_t *schema,
  96                     nvlist_t **driver_schema);
  97 static nvlist_t *pci_iov_get_pf_subsystem_schema(void);
  98 static nvlist_t *pci_iov_get_vf_subsystem_schema(void);
  99
 100 int
 101 pci_iov_attach_name(device_t dev, struct nvlist *pf_schema,
 102     struct nvlist *vf_schema, const char *fmt, ...)
 103 {
 104         char buf[NAME_MAX + 1];
 105         va_list ap;
 106
 107         va_start(ap, fmt);
 108         vsnprintf(buf, sizeof(buf), fmt, ap);
 109         va_end(ap);
 110         return (PCI_IOV_ATTACH(device_get_parent(dev), dev, pf_schema,
 111             vf_schema, buf));
 112 }
 113
 114 int
 115 pci_iov_attach_method(device_t bus, device_t dev, nvlist_t *pf_schema,
 116     nvlist_t *vf_schema, const char *name)
 117 {
 118         device_t pcib;
 119         struct pci_devinfo *dinfo;
 120         struct pcicfg_iov *iov;
 121         nvlist_t *schema;
 122         uint32_t version;
 123         int error;
 124         int iov_pos;
 125
 126         dinfo = device_get_ivars(dev);
 127         pcib = device_get_parent(bus);
 128         schema = NULL;
 129
 130         error = pci_find_extcap(dev, PCIZ_SRIOV, &iov_pos);
 131
 132         if (error != 0)
 133                 return (error);
 134
 135         version = pci_read_config(dev, iov_pos, 4);
 136         if (PCI_EXTCAP_VER(version) != 1) {
 137                 if (bootverbose)
 138                         device_printf(dev,
 139                             "Unsupported version of SR-IOV (%d) detected\n",
 140                             PCI_EXTCAP_VER(version));
 141
 142                 return (ENXIO);
 143         }
 144
 145         iov = malloc(sizeof(*dinfo->cfg.iov), M_SRIOV, M_WAITOK | M_ZERO);
 146
 147         mtx_lock(&Giant);
 148         if (dinfo->cfg.iov != NULL) {
 149                 error = EBUSY;
 150                 goto cleanup;
 151         }
 152         iov->iov_pos = iov_pos;
 153
 154         schema = pci_iov_build_schema(&pf_schema, &vf_schema);
 155         if (schema == NULL) {
 156                 error = ENOMEM;
 157                 goto cleanup;
 158         }
 159
 160         error = pci_iov_validate_schema(schema);
 161         if (error != 0)
 162                 goto cleanup;
 163         iov->iov_schema = schema;
 164
 165         iov->iov_cdev = make_dev(&iov_cdevsw, device_get_unit(dev),
 166             UID_ROOT, GID_WHEEL, 0600, "iov/%s", name);
 167
 168         if (iov->iov_cdev == NULL) {
 169                 error = ENOMEM;
 170                 goto cleanup;
 171         }
 172
 173         dinfo->cfg.iov = iov;
 174         iov->iov_cdev->si_drv1 = dinfo;
 175         mtx_unlock(&Giant);
 176
 177         return (0);
 178
 179 cleanup:
 180         nvlist_destroy(schema);
 181         nvlist_destroy(pf_schema);
 182         nvlist_destroy(vf_schema);
 183         free(iov, M_SRIOV);
 184         mtx_unlock(&Giant);
 185         return (error);
 186 }
 187
 188 int
 189 pci_iov_detach_method(device_t bus, device_t dev)
 190 {
 191         struct pci_devinfo *dinfo;
 192         struct pcicfg_iov *iov;
 193
 194         mtx_lock(&Giant);
 195         dinfo = device_get_ivars(dev);
 196         iov = dinfo->cfg.iov;
 197
 198         if (iov == NULL) {
 199                 mtx_unlock(&Giant);
 200                 return (0);
 201         }
 202
 203         if (iov->iov_num_vfs != 0 || iov->iov_flags & IOV_BUSY) {
 204                 mtx_unlock(&Giant);
 205                 return (EBUSY);
 206         }
 207
 208         dinfo->cfg.iov = NULL;
 209
 210         if (iov->iov_cdev) {
 211                 destroy_dev(iov->iov_cdev);
 212                 iov->iov_cdev = NULL;
 213         }
 214         nvlist_destroy(iov->iov_schema);
 215
 216         free(iov, M_SRIOV);
 217         mtx_unlock(&Giant);
 218
 219         return (0);
 220 }
 221
 222 static nvlist_t *
 223 pci_iov_build_schema(nvlist_t **pf, nvlist_t **vf)
 224 {
 225         nvlist_t *schema, *pf_driver, *vf_driver;
 226
 227         /* We always take ownership of the schemas. */
 228         pf_driver = *pf;
 229         *pf = NULL;
 230         vf_driver = *vf;
 231         *vf = NULL;
 232
 233         schema = pci_iov_schema_alloc_node();
 234         if (schema == NULL)
 235                 goto cleanup;
 236
 237         pci_iov_build_pf_schema(schema, &pf_driver);
 238         pci_iov_build_vf_schema(schema, &vf_driver);
 239
 240         if (nvlist_error(schema) != 0)
 241                 goto cleanup;
 242
 243         return (schema);
 244
 245 cleanup:
 246         nvlist_destroy(schema);
 247         nvlist_destroy(pf_driver);
 248         nvlist_destroy(vf_driver);
 249         return (NULL);
 250 }
 251
 252 static void
 253 pci_iov_build_pf_schema(nvlist_t *schema, nvlist_t **driver_schema)
 254 {
 255         nvlist_t *pf_schema, *iov_schema;
 256
 257         pf_schema = pci_iov_schema_alloc_node();
 258         if (pf_schema == NULL) {
 259                 nvlist_set_error(schema, ENOMEM);
 260                 return;
 261         }
 262
 263         iov_schema = pci_iov_get_pf_subsystem_schema();
 264
 265         /*
 266          * Note that if either *driver_schema or iov_schema is NULL, then
 267          * nvlist_move_nvlist will put the schema in the error state and
 268          * SR-IOV will fail to initialize later, so we don't have to explicitly
 269          * handle that case.
 270          */
 271         nvlist_move_nvlist(pf_schema, DRIVER_CONFIG_NAME, *driver_schema);
 272         nvlist_move_nvlist(pf_schema, IOV_CONFIG_NAME, iov_schema);
 273         nvlist_move_nvlist(schema, PF_CONFIG_NAME, pf_schema);
 274         *driver_schema = NULL;
 275 }
 276
 277 static void
 278 pci_iov_build_vf_schema(nvlist_t *schema, nvlist_t **driver_schema)
 279 {
 280         nvlist_t *vf_schema, *iov_schema;
 281
 282         vf_schema = pci_iov_schema_alloc_node();
 283         if (vf_schema == NULL) {
 284                 nvlist_set_error(schema, ENOMEM);
 285                 return;
 286         }
 287
 288         iov_schema = pci_iov_get_vf_subsystem_schema();
 289
 290         /*
 291          * Note that if either *driver_schema or iov_schema is NULL, then
 292          * nvlist_move_nvlist will put the schema in the error state and
 293          * SR-IOV will fail to initialize later, so we don't have to explicitly
 294          * handle that case.
 295          */
 296         nvlist_move_nvlist(vf_schema, DRIVER_CONFIG_NAME, *driver_schema);
 297         nvlist_move_nvlist(vf_schema, IOV_CONFIG_NAME, iov_schema);
 298         nvlist_move_nvlist(schema, VF_SCHEMA_NAME, vf_schema);
 299         *driver_schema = NULL;
 300 }
 301
 302 static nvlist_t *
 303 pci_iov_get_pf_subsystem_schema(void)
 304 {
 305         nvlist_t *pf;
 306
 307         pf = pci_iov_schema_alloc_node();
 308         if (pf == NULL)
 309                 return (NULL);
 310
 311         pci_iov_schema_add_uint16(pf, "num_vfs", IOV_SCHEMA_REQUIRED, -1);
 312         pci_iov_schema_add_string(pf, "device", IOV_SCHEMA_REQUIRED, NULL);
 313
 314         return (pf);
 315 }
 316
 317 static nvlist_t *
 318 pci_iov_get_vf_subsystem_schema(void)
 319 {
 320         nvlist_t *vf;
 321
 322         vf = pci_iov_schema_alloc_node();
 323         if (vf == NULL)
 324                 return (NULL);
 325
 326         pci_iov_schema_add_bool(vf, "passthrough", IOV_SCHEMA_HASDEFAULT, 0);
 327
 328         return (vf);
 329 }
 330
 331 static int
 332 pci_iov_alloc_bar(struct pci_devinfo *dinfo, int bar, pci_addr_t bar_shift)
 333 {
 334         struct resource *res;
 335         struct pcicfg_iov *iov;
 336         device_t dev, bus;
 337         rman_res_t start, end;
 338         pci_addr_t bar_size;
 339         int rid;
 340
 341         iov = dinfo->cfg.iov;
 342         dev = dinfo->cfg.dev;
 343         bus = device_get_parent(dev);
 344         rid = iov->iov_pos + PCIR_SRIOV_BAR(bar);
 345         bar_size = 1 << bar_shift;
 346
 347         res = pci_alloc_multi_resource(bus, dev, SYS_RES_MEMORY, &rid, 0,
 348             ~0, 1, iov->iov_num_vfs, RF_ACTIVE);
 349
 350         if (res == NULL)
 351                 return (ENXIO);
 352
 353         iov->iov_bar[bar].res = res;
 354         iov->iov_bar[bar].bar_size = bar_size;
 355         iov->iov_bar[bar].bar_shift = bar_shift;
 356
 357         start = rman_get_start(res);
 358         end = rman_get_end(res);
 359         return (rman_manage_region(&iov->rman, start, end));
 360 }
 361
 362 static void
 363 pci_iov_add_bars(struct pcicfg_iov *iov, struct pci_devinfo *dinfo)
 364 {
 365         struct pci_iov_bar *bar;
 366         uint64_t bar_start;
 367         int i;
 368
 369         for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 370                 bar = &iov->iov_bar[i];
 371                 if (bar->res != NULL) {
 372                         bar_start = rman_get_start(bar->res) +
 373                             dinfo->cfg.vf.index * bar->bar_size;
 374
 375                         pci_add_bar(dinfo->cfg.dev, PCIR_BAR(i), bar_start,
 376                             bar->bar_shift);
 377                 }
 378         }
 379 }
 380
 381 static int
 382 pci_iov_parse_config(struct pcicfg_iov *iov, struct pci_iov_arg *arg,
 383     nvlist_t **ret)
 384 {
 385         void *packed_config;
 386         nvlist_t *config;
 387         int error;
 388
 389         config = NULL;
 390         packed_config = NULL;
 391
 392         if (arg->len > pci_iov_max_config) {
 393                 error = EMSGSIZE;
 394                 goto out;
 395         }
 396
 397         packed_config = malloc(arg->len, M_SRIOV, M_WAITOK);
 398
 399         error = copyin(arg->config, packed_config, arg->len);
 400         if (error != 0)
 401                 goto out;
 402
 403         config = nvlist_unpack(packed_config, arg->len, NV_FLAG_IGNORE_CASE);
 404         if (config == NULL) {
 405                 error = EINVAL;
 406                 goto out;
 407         }
 408
 409         error = pci_iov_schema_validate_config(iov->iov_schema, config);
 410         if (error != 0)
 411                 goto out;
 412
 413         error = nvlist_error(config);
 414         if (error != 0)
 415                 goto out;
 416
 417         *ret = config;
 418         config = NULL;
 419
 420 out:
 421         nvlist_destroy(config);
 422         free(packed_config, M_SRIOV);
 423         return (error);
 424 }
 425
 426 /*
 427  * Set the ARI_EN bit in the lowest-numbered PCI function with the SR-IOV
 428  * capability.  This bit is only writeable on the lowest-numbered PF but
 429  * affects all PFs on the device.
 430  */
 431 static int
 432 pci_iov_set_ari(device_t bus)
 433 {
 434         device_t lowest;
 435         device_t *devlist;
 436         int i, error, devcount, lowest_func, lowest_pos, iov_pos, dev_func;
 437         uint16_t iov_ctl;
 438
 439         /* If ARI is disabled on the downstream port there is nothing to do. */
 440         if (!PCIB_ARI_ENABLED(device_get_parent(bus)))
 441                 return (0);
 442
 443         error = device_get_children(bus, &devlist, &devcount);
 444
 445         if (error != 0)
 446                 return (error);
 447
 448         lowest = NULL;
 449         for (i = 0; i < devcount; i++) {
 450                 if (pci_find_extcap(devlist[i], PCIZ_SRIOV, &iov_pos) == 0) {
 451                         dev_func = pci_get_function(devlist[i]);
 452                         if (lowest == NULL || dev_func < lowest_func) {
 453                                 lowest = devlist[i];
 454                                 lowest_func = dev_func;
 455                                 lowest_pos = iov_pos;
 456                         }
 457                 }
 458         }
 459         free(devlist, M_TEMP);
 460
 461         /*
 462          * If we called this function some device must have the SR-IOV
 463          * capability.
 464          */
 465         KASSERT(lowest != NULL,
 466             ("Could not find child of %s with SR-IOV capability",
 467             device_get_nameunit(bus)));
 468
 469         iov_ctl = pci_read_config(lowest, lowest_pos + PCIR_SRIOV_CTL, 2);
 470         iov_ctl |= PCIM_SRIOV_ARI_EN;
 471         pci_write_config(lowest, lowest_pos + PCIR_SRIOV_CTL, iov_ctl, 2);
 472         if ((pci_read_config(lowest, lowest_pos + PCIR_SRIOV_CTL, 2) &
 473             PCIM_SRIOV_ARI_EN) == 0) {
 474                 device_printf(lowest, "failed to enable ARI\n");
 475                 return (ENXIO);
 476         }
 477         return (0);
 478 }
 479
 480 static int
 481 pci_iov_config_page_size(struct pci_devinfo *dinfo)
 482 {
 483         uint32_t page_cap, page_size;
 484
 485         page_cap = IOV_READ(dinfo, PCIR_SRIOV_PAGE_CAP, 4);
 486
 487         /*
 488          * If the system page size is less than the smallest SR-IOV page size
 489          * then round up to the smallest SR-IOV page size.
 490          */
 491         if (PAGE_SHIFT < PCI_SRIOV_BASE_PAGE_SHIFT)
 492                 page_size = (1 << 0);
 493         else
 494                 page_size = (1 << (PAGE_SHIFT - PCI_SRIOV_BASE_PAGE_SHIFT));
 495
 496         /* Check that the device supports the system page size. */
 497         if (!(page_size & page_cap))
 498                 return (ENXIO);
 499
 500         IOV_WRITE(dinfo, PCIR_SRIOV_PAGE_SIZE, page_size, 4);
 501         return (0);
 502 }
 503
 504 static int
 505 pci_iov_init(device_t dev, uint16_t num_vfs, const nvlist_t *config)
 506 {
 507         const nvlist_t *device, *driver_config;
 508
 509         device = nvlist_get_nvlist(config, PF_CONFIG_NAME);
 510         driver_config = nvlist_get_nvlist(device, DRIVER_CONFIG_NAME);
 511         return (PCI_IOV_INIT(dev, num_vfs, driver_config));
 512 }
 513
 514 static int
 515 pci_iov_init_rman(device_t pf, struct pcicfg_iov *iov)
 516 {
 517         int error;
 518
 519         iov->rman.rm_start = 0;
 520         iov->rman.rm_end = ~0;
 521         iov->rman.rm_type = RMAN_ARRAY;
 522         snprintf(iov->rman_name, sizeof(iov->rman_name), "%s VF I/O memory",
 523             device_get_nameunit(pf));
 524         iov->rman.rm_descr = iov->rman_name;
 525
 526         error = rman_init(&iov->rman);
 527         if (error != 0)
 528                 return (error);
 529
 530         iov->iov_flags |= IOV_RMAN_INITED;
 531         return (0);
 532 }
 533
 534 static int
 535 pci_iov_alloc_bar_ea(struct pci_devinfo *dinfo, int bar)
 536 {
 537         struct pcicfg_iov *iov;
 538         rman_res_t start, end;
 539         struct resource *res;
 540         struct resource_list *rl;
 541         struct resource_list_entry *rle;
 542
 543         rl = &dinfo->resources;
 544         iov = dinfo->cfg.iov;
 545
 546         rle = resource_list_find(rl, SYS_RES_MEMORY,
 547             iov->iov_pos + PCIR_SRIOV_BAR(bar));
 548         if (rle == NULL)
 549                 rle = resource_list_find(rl, SYS_RES_IOPORT,
 550                     iov->iov_pos + PCIR_SRIOV_BAR(bar));
 551         if (rle == NULL)
 552                 return (ENXIO);
 553         res = rle->res;
 554
 555         iov->iov_bar[bar].res = res;
 556         iov->iov_bar[bar].bar_size = rman_get_size(res) / iov->iov_num_vfs;
 557         iov->iov_bar[bar].bar_shift = pci_mapsize(iov->iov_bar[bar].bar_size);
 558
 559         start = rman_get_start(res);
 560         end = rman_get_end(res);
 561
 562         return (rman_manage_region(&iov->rman, start, end));
 563 }
 564
 565 static int
 566 pci_iov_setup_bars(struct pci_devinfo *dinfo)
 567 {
 568         device_t dev;
 569         struct pcicfg_iov *iov;
 570         pci_addr_t bar_value, testval;
 571         int i, last_64, error;
 572
 573         iov = dinfo->cfg.iov;
 574         dev = dinfo->cfg.dev;
 575         last_64 = 0;
 576
 577         pci_add_resources_ea(device_get_parent(dev), dev, 1);
 578
 579         for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 580                 /* First, try to use BARs allocated with EA */
 581                 error = pci_iov_alloc_bar_ea(dinfo, i);
 582                 if (error == 0)
 583                         continue;
 584
 585                 /* Allocate legacy-BAR only if EA is not enabled */
 586                 if (pci_ea_is_enabled(dev, iov->iov_pos + PCIR_SRIOV_BAR(i)))
 587                         continue;
 588
 589                 /*
 590                  * If a PCI BAR is a 64-bit wide BAR, then it spans two
 591                  * consecutive registers.  Therefore if the last BAR that
 592                  * we looked at was a 64-bit BAR, we need to skip this
 593                  * register as it's the second half of the last BAR.
 594                  */
 595                 if (!last_64) {
 596                         pci_read_bar(dev,
 597                             iov->iov_pos + PCIR_SRIOV_BAR(i),
 598                             &bar_value, &testval, &last_64);
 599
 600                         if (testval != 0) {
 601                                 error = pci_iov_alloc_bar(dinfo, i,
 602                                    pci_mapsize(testval));
 603                                 if (error != 0)
 604                                         return (error);
 605                         }
 606                 } else
 607                         last_64 = 0;
 608         }
 609
 610         return (0);
 611 }
 612
 613 static void
 614 pci_iov_enumerate_vfs(struct pci_devinfo *dinfo, const nvlist_t *config,
 615     uint16_t first_rid, uint16_t rid_stride)
 616 {
 617         char device_name[VF_MAX_NAME];
 618         const nvlist_t *device, *driver_config, *iov_config;
 619         device_t bus, dev, vf;
 620         struct pcicfg_iov *iov;
 621         struct pci_devinfo *vfinfo;
 622         int i, error;
 623         uint16_t vid, did, next_rid;
 624
 625         iov = dinfo->cfg.iov;
 626         dev = dinfo->cfg.dev;
 627         bus = device_get_parent(dev);
 628         next_rid = first_rid;
 629         vid = pci_get_vendor(dev);
 630         did = IOV_READ(dinfo, PCIR_SRIOV_VF_DID, 2);
 631
 632         for (i = 0; i < iov->iov_num_vfs; i++, next_rid += rid_stride) {
 633                 snprintf(device_name, sizeof(device_name), VF_PREFIX"%d", i);
 634                 device = nvlist_get_nvlist(config, device_name);
 635                 iov_config = nvlist_get_nvlist(device, IOV_CONFIG_NAME);
 636                 driver_config = nvlist_get_nvlist(device, DRIVER_CONFIG_NAME);
 637
 638                 vf = PCI_CREATE_IOV_CHILD(bus, dev, next_rid, vid, did);
 639                 if (vf == NULL)
 640                         break;
 641
 642                 /*
 643                  * If we are creating passthrough devices then force the ppt
 644                  * driver to attach to prevent a VF driver from claiming the
 645                  * VFs.
 646                  */
 647                 if (nvlist_get_bool(iov_config, "passthrough"))
 648                         device_set_devclass_fixed(vf, "ppt");
 649
 650                 vfinfo = device_get_ivars(vf);
 651
 652                 vfinfo->cfg.iov = iov;
 653                 vfinfo->cfg.vf.index = i;
 654
 655                 pci_iov_add_bars(iov, vfinfo);
 656
 657                 error = PCI_IOV_ADD_VF(dev, i, driver_config);
 658                 if (error != 0) {
 659                         device_printf(dev, "Failed to add VF %d\n", i);
 660                         device_delete_child(bus, vf);
 661                 }
 662         }
 663
 664         bus_generic_attach(bus);
 665 }
 666
 667 static int
 668 pci_iov_config(struct cdev *cdev, struct pci_iov_arg *arg)
 669 {
 670         device_t bus, dev;
 671         struct pci_devinfo *dinfo;
 672         struct pcicfg_iov *iov;
 673         nvlist_t *config;
 674         int i, error;
 675         uint16_t rid_off, rid_stride;
 676         uint16_t first_rid, last_rid;
 677         uint16_t iov_ctl;
 678         uint16_t num_vfs, total_vfs;
 679         int iov_inited;
 680
 681         mtx_lock(&Giant);
 682         dinfo = cdev->si_drv1;
 683         iov = dinfo->cfg.iov;
 684         dev = dinfo->cfg.dev;
 685         bus = device_get_parent(dev);
 686         iov_inited = 0;
 687         config = NULL;
 688
 689         if ((iov->iov_flags & IOV_BUSY) || iov->iov_num_vfs != 0) {
 690                 mtx_unlock(&Giant);
 691                 return (EBUSY);
 692         }
 693         iov->iov_flags |= IOV_BUSY;
 694
 695         error = pci_iov_parse_config(iov, arg, &config);
 696         if (error != 0)
 697                 goto out;
 698
 699         num_vfs = pci_iov_config_get_num_vfs(config);
 700         total_vfs = IOV_READ(dinfo, PCIR_SRIOV_TOTAL_VFS, 2);
 701         if (num_vfs > total_vfs) {
 702                 error = EINVAL;
 703                 goto out;
 704         }
 705
 706         error = pci_iov_config_page_size(dinfo);
 707         if (error != 0)
 708                 goto out;
 709
 710         error = pci_iov_set_ari(bus);
 711         if (error != 0)
 712                 goto out;
 713
 714         error = pci_iov_init(dev, num_vfs, config);
 715         if (error != 0)
 716                 goto out;
 717         iov_inited = 1;
 718
 719         IOV_WRITE(dinfo, PCIR_SRIOV_NUM_VFS, num_vfs, 2);
 720
 721         rid_off = IOV_READ(dinfo, PCIR_SRIOV_VF_OFF, 2);
 722         rid_stride = IOV_READ(dinfo, PCIR_SRIOV_VF_STRIDE, 2);
 723
 724         first_rid = pci_get_rid(dev) + rid_off;
 725         last_rid = first_rid + (num_vfs - 1) * rid_stride;
 726
 727         /* We don't yet support allocating extra bus numbers for VFs. */
 728         if (pci_get_bus(dev) != PCI_RID2BUS(last_rid)) {
 729                 error = ENOSPC;
 730                 goto out;
 731         }
 732
 733         iov_ctl = IOV_READ(dinfo, PCIR_SRIOV_CTL, 2);
 734         iov_ctl &= ~(PCIM_SRIOV_VF_EN | PCIM_SRIOV_VF_MSE);
 735         IOV_WRITE(dinfo, PCIR_SRIOV_CTL, iov_ctl, 2);
 736
 737         error = pci_iov_init_rman(dev, iov);
 738         if (error != 0)
 739                 goto out;
 740
 741         iov->iov_num_vfs = num_vfs;
 742
 743         error = pci_iov_setup_bars(dinfo);
 744         if (error != 0)
 745                 goto out;
 746
 747         iov_ctl = IOV_READ(dinfo, PCIR_SRIOV_CTL, 2);
 748         iov_ctl |= PCIM_SRIOV_VF_EN | PCIM_SRIOV_VF_MSE;
 749         IOV_WRITE(dinfo, PCIR_SRIOV_CTL, iov_ctl, 2);
 750
 751         /* Per specification, we must wait 100ms before accessing VFs. */
 752         pause("iov", roundup(hz, 10));
 753         pci_iov_enumerate_vfs(dinfo, config, first_rid, rid_stride);
 754
 755         nvlist_destroy(config);
 756         iov->iov_flags &= ~IOV_BUSY;
 757         mtx_unlock(&Giant);
 758
 759         return (0);
 760 out:
 761         if (iov_inited)
 762                 PCI_IOV_UNINIT(dev);
 763
 764         for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 765                 if (iov->iov_bar[i].res != NULL) {
 766                         pci_release_resource(bus, dev, SYS_RES_MEMORY,
 767                             iov->iov_pos + PCIR_SRIOV_BAR(i),
 768                             iov->iov_bar[i].res);
 769                         pci_delete_resource(bus, dev, SYS_RES_MEMORY,
 770                             iov->iov_pos + PCIR_SRIOV_BAR(i));
 771                         iov->iov_bar[i].res = NULL;
 772                 }
 773         }
 774
 775         if (iov->iov_flags & IOV_RMAN_INITED) {
 776                 rman_fini(&iov->rman);
 777                 iov->iov_flags &= ~IOV_RMAN_INITED;
 778         }
 779
 780         nvlist_destroy(config);
 781         iov->iov_num_vfs = 0;
 782         iov->iov_flags &= ~IOV_BUSY;
 783         mtx_unlock(&Giant);
 784         return (error);
 785 }
 786
 787 void
 788 pci_iov_cfg_restore(device_t dev, struct pci_devinfo *dinfo)
 789 {
 790         struct pcicfg_iov *iov;
 791
 792         iov = dinfo->cfg.iov;
 793
 794         IOV_WRITE(dinfo, PCIR_SRIOV_PAGE_SIZE, iov->iov_page_size, 4);
 795         IOV_WRITE(dinfo, PCIR_SRIOV_NUM_VFS, iov->iov_num_vfs, 2);
 796         IOV_WRITE(dinfo, PCIR_SRIOV_CTL, iov->iov_ctl, 2);
 797 }
 798
 799 void
 800 pci_iov_cfg_save(device_t dev, struct pci_devinfo *dinfo)
 801 {
 802         struct pcicfg_iov *iov;
 803
 804         iov = dinfo->cfg.iov;
 805
 806         iov->iov_page_size = IOV_READ(dinfo, PCIR_SRIOV_PAGE_SIZE, 4);
 807         iov->iov_ctl = IOV_READ(dinfo, PCIR_SRIOV_CTL, 2);
 808 }
 809
 810 /* Return true if child is a VF of the given PF. */
 811 static int
 812 pci_iov_is_child_vf(struct pcicfg_iov *pf, device_t child)
 813 {
 814         struct pci_devinfo *vfinfo;
 815
 816         vfinfo = device_get_ivars(child);
 817
 818         if (!(vfinfo->cfg.flags & PCICFG_VF))
 819                 return (0);
 820
 821         return (pf == vfinfo->cfg.iov);
 822 }
 823
 824 static int
 825 pci_iov_delete(struct cdev *cdev)
 826 {
 827         device_t bus, dev, vf, *devlist;
 828         struct pci_devinfo *dinfo;
 829         struct pcicfg_iov *iov;
 830         int i, error, devcount;
 831         uint32_t iov_ctl;
 832
 833         mtx_lock(&Giant);
 834         dinfo = cdev->si_drv1;
 835         iov = dinfo->cfg.iov;
 836         dev = dinfo->cfg.dev;
 837         bus = device_get_parent(dev);
 838         devlist = NULL;
 839
 840         if (iov->iov_flags & IOV_BUSY) {
 841                 mtx_unlock(&Giant);
 842                 return (EBUSY);
 843         }
 844
 845         if (iov->iov_num_vfs == 0) {
 846                 mtx_unlock(&Giant);
 847                 return (ECHILD);
 848         }
 849
 850         iov->iov_flags |= IOV_BUSY;
 851
 852         error = device_get_children(bus, &devlist, &devcount);
 853
 854         if (error != 0)
 855                 goto out;
 856
 857         for (i = 0; i < devcount; i++) {
 858                 vf = devlist[i];
 859
 860                 if (!pci_iov_is_child_vf(iov, vf))
 861                         continue;
 862
 863                 error = device_detach(vf);
 864                 if (error != 0) {
 865                         device_printf(dev,
 866                            "Could not disable SR-IOV: failed to detach VF %s\n",
 867                             device_get_nameunit(vf));
 868                         goto out;
 869                 }
 870         }
 871
 872         for (i = 0; i < devcount; i++) {
 873                 vf = devlist[i];
 874
 875                 if (pci_iov_is_child_vf(iov, vf))
 876                         device_delete_child(bus, vf);
 877         }
 878         PCI_IOV_UNINIT(dev);
 879
 880         iov_ctl = IOV_READ(dinfo, PCIR_SRIOV_CTL, 2);
 881         iov_ctl &= ~(PCIM_SRIOV_VF_EN | PCIM_SRIOV_VF_MSE);
 882         IOV_WRITE(dinfo, PCIR_SRIOV_CTL, iov_ctl, 2);
 883         IOV_WRITE(dinfo, PCIR_SRIOV_NUM_VFS, 0, 2);
 884
 885         iov->iov_num_vfs = 0;
 886
 887         for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 888                 if (iov->iov_bar[i].res != NULL) {
 889                         pci_release_resource(bus, dev, SYS_RES_MEMORY,
 890                             iov->iov_pos + PCIR_SRIOV_BAR(i),
 891                             iov->iov_bar[i].res);
 892                         pci_delete_resource(bus, dev, SYS_RES_MEMORY,
 893                             iov->iov_pos + PCIR_SRIOV_BAR(i));
 894                         iov->iov_bar[i].res = NULL;
 895                 }
 896         }
 897
 898         if (iov->iov_flags & IOV_RMAN_INITED) {
 899                 rman_fini(&iov->rman);
 900                 iov->iov_flags &= ~IOV_RMAN_INITED;
 901         }
 902
 903         error = 0;
 904 out:
 905         free(devlist, M_TEMP);
 906         iov->iov_flags &= ~IOV_BUSY;
 907         mtx_unlock(&Giant);
 908         return (error);
 909 }
 910
 911 static int
 912 pci_iov_get_schema_ioctl(struct cdev *cdev, struct pci_iov_schema *output)
 913 {
 914         struct pci_devinfo *dinfo;
 915         void *packed;
 916         size_t output_len, size;
 917         int error;
 918
 919         packed = NULL;
 920
 921         mtx_lock(&Giant);
 922         dinfo = cdev->si_drv1;
 923         packed = nvlist_pack(dinfo->cfg.iov->iov_schema, &size);
 924         mtx_unlock(&Giant);
 925
 926         if (packed == NULL) {
 927                 error = ENOMEM;
 928                 goto fail;
 929         }
 930
 931         output_len = output->len;
 932         output->len = size;
 933         if (size <= output_len) {
 934                 error = copyout(packed, output->schema, size);
 935
 936                 if (error != 0)
 937                         goto fail;
 938
 939                 output->error = 0;
 940         } else
 941                 /*
 942                  * If we return an error then the ioctl code won't copyout
 943                  * output back to userland, so we flag the error in the struct
 944                  * instead.
 945                  */
 946                 output->error = EMSGSIZE;
 947
 948         error = 0;
 949
 950 fail:
 951         free(packed, M_NVLIST);
 952
 953         return (error);
 954 }
 955
 956 static int
 957 pci_iov_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
 958     struct thread *td)
 959 {
 960
 961         switch (cmd) {
 962         case IOV_CONFIG:
 963                 return (pci_iov_config(dev, (struct pci_iov_arg *)data));
 964         case IOV_DELETE:
 965                 return (pci_iov_delete(dev));
 966         case IOV_GET_SCHEMA:
 967                 return (pci_iov_get_schema_ioctl(dev,
 968                     (struct pci_iov_schema *)data));
 969         default:
 970                 return (EINVAL);
 971         }
 972 }
 973
 974 struct resource *
 975 pci_vf_alloc_mem_resource(device_t dev, device_t child, int *rid,
 976     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 977 {
 978         struct pci_devinfo *dinfo;
 979         struct pcicfg_iov *iov;
 980         struct pci_map *map;
 981         struct resource *res;
 982         struct resource_list_entry *rle;
 983         rman_res_t bar_start, bar_end;
 984         pci_addr_t bar_length;
 985         int error;
 986
 987         dinfo = device_get_ivars(child);
 988         iov = dinfo->cfg.iov;
 989
 990         map = pci_find_bar(child, *rid);
 991         if (map == NULL)
 992                 return (NULL);
 993
 994         bar_length = 1 << map->pm_size;
 995         bar_start = map->pm_value;
 996         bar_end = bar_start + bar_length - 1;
 997
 998         /* Make sure that the resource fits the constraints. */
 999         if (bar_start >= end || bar_end <= bar_start || count != 1)
1000                 return (NULL);
1001
1002         /* Clamp the resource to the constraints if necessary. */
1003         if (bar_start < start)
1004                 bar_start = start;
1005         if (bar_end > end)
1006                 bar_end = end;
1007         bar_length = bar_end - bar_start + 1;
1008
1009         res = rman_reserve_resource(&iov->rman, bar_start, bar_end,
1010             bar_length, flags, child);
1011         if (res == NULL)
1012                 return (NULL);
1013
1014         rle = resource_list_add(&dinfo->resources, SYS_RES_MEMORY, *rid,
1015             bar_start, bar_end, 1);
1016         if (rle == NULL) {
1017                 rman_release_resource(res);
1018                 return (NULL);
1019         }
1020
1021         rman_set_rid(res, *rid);
1022
1023         if (flags & RF_ACTIVE) {
1024                 error = bus_activate_resource(child, SYS_RES_MEMORY, *rid, res);
1025                 if (error != 0) {
1026                         resource_list_delete(&dinfo->resources, SYS_RES_MEMORY,
1027                             *rid);
1028                         rman_release_resource(res);
1029                         return (NULL);
1030                 }
1031         }
1032         rle->res = res;
1033
1034         return (res);
1035 }
1036
1037 int
1038 pci_vf_release_mem_resource(device_t dev, device_t child, int rid,
1039     struct resource *r)
1040 {
1041         struct pci_devinfo *dinfo;
1042         struct resource_list_entry *rle;
1043         int error;
1044
1045         dinfo = device_get_ivars(child);
1046
1047         if (rman_get_flags(r) & RF_ACTIVE) {
1048                 error = bus_deactivate_resource(child, SYS_RES_MEMORY, rid, r);
1049                 if (error != 0)
1050                         return (error);
1051         }
1052
1053         rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY, rid);
1054         if (rle != NULL) {
1055                 rle->res = NULL;
1056                 resource_list_delete(&dinfo->resources, SYS_RES_MEMORY,
1057                     rid);
1058         }
1059
1060         return (rman_release_resource(r));
1061 }
1062