drivers/pci/iov.c

   1 /*
   2  * drivers/pci/iov.c
   3  *
   4  * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com>
   5  *
   6  * PCI Express I/O Virtualization (IOV) support.
   7  *   Single Root IOV 1.0
   8  *   Address Translation Service 1.0
   9  */
  10
  11 #include <linux/pci.h>
  12 #include <linux/mutex.h>
  13 #include <linux/string.h>
  14 #include <linux/delay.h>
  15 #include "pci.h"
  16
  17 #define VIRTFN_ID_LEN   16
  18
  19 static inline u8 virtfn_bus(struct pci_dev *dev, int id)
  20 {
  21         return dev->bus->number + ((dev->devfn + dev->sriov->offset +
  22                                     dev->sriov->stride * id) >> 8);
  23 }
  24
  25 static inline u8 virtfn_devfn(struct pci_dev *dev, int id)
  26 {
  27         return (dev->devfn + dev->sriov->offset +
  28                 dev->sriov->stride * id) & 0xff;
  29 }
  30
  31 static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr)
  32 {
  33         int rc;
  34         struct pci_bus *child;
  35
  36         if (bus->number == busnr)
  37                 return bus;
  38
  39         child = pci_find_bus(pci_domain_nr(bus), busnr);
  40         if (child)
  41                 return child;
  42
  43         child = pci_add_new_bus(bus, NULL, busnr);
  44         if (!child)
  45                 return NULL;
  46
  47         child->subordinate = busnr;
  48         child->dev.parent = bus->bridge;
  49         rc = pci_bus_add_child(child);
  50         if (rc) {
  51                 pci_remove_bus(child);
  52                 return NULL;
  53         }
  54
  55         return child;
  56 }
  57
  58 static void virtfn_remove_bus(struct pci_bus *bus, int busnr)
  59 {
  60         struct pci_bus *child;
  61
  62         if (bus->number == busnr)
  63                 return;
  64
  65         child = pci_find_bus(pci_domain_nr(bus), busnr);
  66         BUG_ON(!child);
  67
  68         if (list_empty(&child->devices))
  69                 pci_remove_bus(child);
  70 }
  71
  72 static int virtfn_add(struct pci_dev *dev, int id, int reset)
  73 {
  74         int i;
  75         int rc;
  76         u64 size;
  77         char buf[VIRTFN_ID_LEN];
  78         struct pci_dev *virtfn;
  79         struct resource *res;
  80         struct pci_sriov *iov = dev->sriov;
  81
  82         virtfn = alloc_pci_dev();
  83         if (!virtfn)
  84                 return -ENOMEM;
  85
  86         mutex_lock(&iov->dev->sriov->lock);
  87         virtfn->bus = virtfn_add_bus(dev->bus, virtfn_bus(dev, id));
  88         if (!virtfn->bus) {
  89                 kfree(virtfn);
  90                 mutex_unlock(&iov->dev->sriov->lock);
  91                 return -ENOMEM;
  92         }
  93         virtfn->devfn = virtfn_devfn(dev, id);
  94         virtfn->vendor = dev->vendor;
  95         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device);
  96         pci_setup_device(virtfn);
  97         virtfn->dev.parent = dev->dev.parent;
  98
  99         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 100                 res = dev->resource + PCI_IOV_RESOURCES + i;
 101                 if (!res->parent)
 102                         continue;
 103                 virtfn->resource[i].name = pci_name(virtfn);
 104                 virtfn->resource[i].flags = res->flags;
 105                 size = resource_size(res);
 106                 do_div(size, iov->total);
 107                 virtfn->resource[i].start = res->start + size * id;
 108                 virtfn->resource[i].end = virtfn->resource[i].start + size - 1;
 109                 rc = request_resource(res, &virtfn->resource[i]);
 110                 BUG_ON(rc);
 111         }
 112
 113         if (reset)
 114                 pci_execute_reset_function(virtfn);
 115
 116         pci_device_add(virtfn, virtfn->bus);
 117         mutex_unlock(&iov->dev->sriov->lock);
 118
 119         virtfn->physfn = pci_dev_get(dev);
 120         virtfn->is_virtfn = 1;
 121
 122         rc = pci_bus_add_device(virtfn);
 123         if (rc)
 124                 goto failed1;
 125         sprintf(buf, "virtfn%u", id);
 126         rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf);
 127         if (rc)
 128                 goto failed1;
 129         rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn");
 130         if (rc)
 131                 goto failed2;
 132
 133         kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE);
 134
 135         return 0;
 136
 137 failed2:
 138         sysfs_remove_link(&dev->dev.kobj, buf);
 139 failed1:
 140         pci_dev_put(dev);
 141         mutex_lock(&iov->dev->sriov->lock);
 142         pci_remove_bus_device(virtfn);
 143         virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
 144         mutex_unlock(&iov->dev->sriov->lock);
 145
 146         return rc;
 147 }
 148
 149 static void virtfn_remove(struct pci_dev *dev, int id, int reset)
 150 {
 151         char buf[VIRTFN_ID_LEN];
 152         struct pci_bus *bus;
 153         struct pci_dev *virtfn;
 154         struct pci_sriov *iov = dev->sriov;
 155
 156         bus = pci_find_bus(pci_domain_nr(dev->bus), virtfn_bus(dev, id));
 157         if (!bus)
 158                 return;
 159
 160         virtfn = pci_get_slot(bus, virtfn_devfn(dev, id));
 161         if (!virtfn)
 162                 return;
 163
 164         pci_dev_put(virtfn);
 165
 166         if (reset) {
 167                 device_release_driver(&virtfn->dev);
 168                 pci_execute_reset_function(virtfn);
 169         }
 170
 171         sprintf(buf, "virtfn%u", id);
 172         sysfs_remove_link(&dev->dev.kobj, buf);
 173         sysfs_remove_link(&virtfn->dev.kobj, "physfn");
 174
 175         mutex_lock(&iov->dev->sriov->lock);
 176         pci_remove_bus_device(virtfn);
 177         virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
 178         mutex_unlock(&iov->dev->sriov->lock);
 179
 180         pci_dev_put(dev);
 181 }
 182
 183 static int sriov_migration(struct pci_dev *dev)
 184 {
 185         u16 status;
 186         struct pci_sriov *iov = dev->sriov;
 187
 188         if (!iov->nr_virtfn)
 189                 return 0;
 190
 191         if (!(iov->cap & PCI_SRIOV_CAP_VFM))
 192                 return 0;
 193
 194         pci_read_config_word(dev, iov->pos + PCI_SRIOV_STATUS, &status);
 195         if (!(status & PCI_SRIOV_STATUS_VFM))
 196                 return 0;
 197
 198         schedule_work(&iov->mtask);
 199
 200         return 1;
 201 }
 202
 203 static void sriov_migration_task(struct work_struct *work)
 204 {
 205         int i;
 206         u8 state;
 207         u16 status;
 208         struct pci_sriov *iov = container_of(work, struct pci_sriov, mtask);
 209
 210         for (i = iov->initial; i < iov->nr_virtfn; i++) {
 211                 state = readb(iov->mstate + i);
 212                 if (state == PCI_SRIOV_VFM_MI) {
 213                         writeb(PCI_SRIOV_VFM_AV, iov->mstate + i);
 214                         state = readb(iov->mstate + i);
 215                         if (state == PCI_SRIOV_VFM_AV)
 216                                 virtfn_add(iov->self, i, 1);
 217                 } else if (state == PCI_SRIOV_VFM_MO) {
 218                         virtfn_remove(iov->self, i, 1);
 219                         writeb(PCI_SRIOV_VFM_UA, iov->mstate + i);
 220                         state = readb(iov->mstate + i);
 221                         if (state == PCI_SRIOV_VFM_AV)
 222                                 virtfn_add(iov->self, i, 0);
 223                 }
 224         }
 225
 226         pci_read_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, &status);
 227         status &= ~PCI_SRIOV_STATUS_VFM;
 228         pci_write_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, status);
 229 }
 230
 231 static int sriov_enable_migration(struct pci_dev *dev, int nr_virtfn)
 232 {
 233         int bir;
 234         u32 table;
 235         resource_size_t pa;
 236         struct pci_sriov *iov = dev->sriov;
 237
 238         if (nr_virtfn <= iov->initial)
 239                 return 0;
 240
 241         pci_read_config_dword(dev, iov->pos + PCI_SRIOV_VFM, &table);
 242         bir = PCI_SRIOV_VFM_BIR(table);
 243         if (bir > PCI_STD_RESOURCE_END)
 244                 return -EIO;
 245
 246         table = PCI_SRIOV_VFM_OFFSET(table);
 247         if (table + nr_virtfn > pci_resource_len(dev, bir))
 248                 return -EIO;
 249
 250         pa = pci_resource_start(dev, bir) + table;
 251         iov->mstate = ioremap(pa, nr_virtfn);
 252         if (!iov->mstate)
 253                 return -ENOMEM;
 254
 255         INIT_WORK(&iov->mtask, sriov_migration_task);
 256
 257         iov->ctrl |= PCI_SRIOV_CTRL_VFM | PCI_SRIOV_CTRL_INTR;
 258         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 259
 260         return 0;
 261 }
 262
 263 static void sriov_disable_migration(struct pci_dev *dev)
 264 {
 265         struct pci_sriov *iov = dev->sriov;
 266
 267         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFM | PCI_SRIOV_CTRL_INTR);
 268         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 269
 270         cancel_work_sync(&iov->mtask);
 271         iounmap(iov->mstate);
 272 }
 273
 274 static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
 275 {
 276         int rc;
 277         int i, j;
 278         int nres;
 279         u16 offset, stride, initial;
 280         struct resource *res;
 281         struct pci_dev *pdev;
 282         struct pci_sriov *iov = dev->sriov;
 283
 284         if (!nr_virtfn)
 285                 return 0;
 286
 287         if (iov->nr_virtfn)
 288                 return -EINVAL;
 289
 290         pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial);
 291         if (initial > iov->total ||
 292             (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total)))
 293                 return -EIO;
 294
 295         if (nr_virtfn < 0 || nr_virtfn > iov->total ||
 296             (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial)))
 297                 return -EINVAL;
 298
 299         pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
 300         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &offset);
 301         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &stride);
 302         if (!offset || (nr_virtfn > 1 && !stride))
 303                 return -EIO;
 304
 305         nres = 0;
 306         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 307                 res = dev->resource + PCI_IOV_RESOURCES + i;
 308                 if (res->parent)
 309                         nres++;
 310         }
 311         if (nres != iov->nres) {
 312                 dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n");
 313                 return -ENOMEM;
 314         }
 315
 316         iov->offset = offset;
 317         iov->stride = stride;
 318
 319         if (virtfn_bus(dev, nr_virtfn - 1) > dev->bus->subordinate) {
 320                 dev_err(&dev->dev, "SR-IOV: bus number out of range\n");
 321                 return -ENOMEM;
 322         }
 323
 324         if (iov->link != dev->devfn) {
 325                 pdev = pci_get_slot(dev->bus, iov->link);
 326                 if (!pdev)
 327                         return -ENODEV;
 328
 329                 pci_dev_put(pdev);
 330
 331                 if (!pdev->is_physfn)
 332                         return -ENODEV;
 333
 334                 rc = sysfs_create_link(&dev->dev.kobj,
 335                                         &pdev->dev.kobj, "dep_link");
 336                 if (rc)
 337                         return rc;
 338         }
 339
 340         iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
 341         pci_block_user_cfg_access(dev);
 342         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 343         msleep(100);
 344         pci_unblock_user_cfg_access(dev);
 345
 346         iov->initial = initial;
 347         if (nr_virtfn < initial)
 348                 initial = nr_virtfn;
 349
 350         for (i = 0; i < initial; i++) {
 351                 rc = virtfn_add(dev, i, 0);
 352                 if (rc)
 353                         goto failed;
 354         }
 355
 356         if (iov->cap & PCI_SRIOV_CAP_VFM) {
 357                 rc = sriov_enable_migration(dev, nr_virtfn);
 358                 if (rc)
 359                         goto failed;
 360         }
 361
 362         kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
 363         iov->nr_virtfn = nr_virtfn;
 364
 365         return 0;
 366
 367 failed:
 368         for (j = 0; j < i; j++)
 369                 virtfn_remove(dev, j, 0);
 370
 371         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
 372         pci_block_user_cfg_access(dev);
 373         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 374         ssleep(1);
 375         pci_unblock_user_cfg_access(dev);
 376
 377         if (iov->link != dev->devfn)
 378                 sysfs_remove_link(&dev->dev.kobj, "dep_link");
 379
 380         return rc;
 381 }
 382
 383 static void sriov_disable(struct pci_dev *dev)
 384 {
 385         int i;
 386         struct pci_sriov *iov = dev->sriov;
 387
 388         if (!iov->nr_virtfn)
 389                 return;
 390
 391         if (iov->cap & PCI_SRIOV_CAP_VFM)
 392                 sriov_disable_migration(dev);
 393
 394         for (i = 0; i < iov->nr_virtfn; i++)
 395                 virtfn_remove(dev, i, 0);
 396
 397         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
 398         pci_block_user_cfg_access(dev);
 399         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 400         ssleep(1);
 401         pci_unblock_user_cfg_access(dev);
 402
 403         if (iov->link != dev->devfn)
 404                 sysfs_remove_link(&dev->dev.kobj, "dep_link");
 405
 406         iov->nr_virtfn = 0;
 407 }
 408
 409 static int sriov_init(struct pci_dev *dev, int pos)
 410 {
 411         int i;
 412         int rc;
 413         int nres;
 414         u32 pgsz;
 415         u16 ctrl, total, offset, stride;
 416         struct pci_sriov *iov;
 417         struct resource *res;
 418         struct pci_dev *pdev;
 419
 420         if (dev->pcie_type != PCI_EXP_TYPE_RC_END &&
 421             dev->pcie_type != PCI_EXP_TYPE_ENDPOINT)
 422                 return -ENODEV;
 423
 424         pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl);
 425         if (ctrl & PCI_SRIOV_CTRL_VFE) {
 426                 pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0);
 427                 ssleep(1);
 428         }
 429
 430         pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total);
 431         if (!total)
 432                 return 0;
 433
 434         ctrl = 0;
 435         list_for_each_entry(pdev, &dev->bus->devices, bus_list)
 436                 if (pdev->is_physfn)
 437                         goto found;
 438
 439         pdev = NULL;
 440         if (pci_ari_enabled(dev->bus))
 441                 ctrl |= PCI_SRIOV_CTRL_ARI;
 442
 443 found:
 444         pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
 445         pci_write_config_word(dev, pos + PCI_SRIOV_NUM_VF, total);
 446         pci_read_config_word(dev, pos + PCI_SRIOV_VF_OFFSET, &offset);
 447         pci_read_config_word(dev, pos + PCI_SRIOV_VF_STRIDE, &stride);
 448         if (!offset || (total > 1 && !stride))
 449                 return -EIO;
 450
 451         pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz);
 452         i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0;
 453         pgsz &= ~((1 << i) - 1);
 454         if (!pgsz)
 455                 return -EIO;
 456
 457         pgsz &= ~(pgsz - 1);
 458         pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);
 459
 460         nres = 0;
 461         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 462                 res = dev->resource + PCI_IOV_RESOURCES + i;
 463                 i += __pci_read_base(dev, pci_bar_unknown, res,
 464                                      pos + PCI_SRIOV_BAR + i * 4);
 465                 if (!res->flags)
 466                         continue;
 467                 if (resource_size(res) & (PAGE_SIZE - 1)) {
 468                         rc = -EIO;
 469                         goto failed;
 470                 }
 471                 res->end = res->start + resource_size(res) * total - 1;
 472                 nres++;
 473         }
 474
 475         iov = kzalloc(sizeof(*iov), GFP_KERNEL);
 476         if (!iov) {
 477                 rc = -ENOMEM;
 478                 goto failed;
 479         }
 480
 481         iov->pos = pos;
 482         iov->nres = nres;
 483         iov->ctrl = ctrl;
 484         iov->total = total;
 485         iov->offset = offset;
 486         iov->stride = stride;
 487         iov->pgsz = pgsz;
 488         iov->self = dev;
 489         pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap);
 490         pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
 491
 492         if (pdev)
 493                 iov->dev = pci_dev_get(pdev);
 494         else
 495                 iov->dev = dev;
 496
 497         mutex_init(&iov->lock);
 498
 499         dev->sriov = iov;
 500         dev->is_physfn = 1;
 501
 502         return 0;
 503
 504 failed:
 505         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
 506                 res = dev->resource + PCI_IOV_RESOURCES + i;
 507                 res->flags = 0;
 508         }
 509
 510         return rc;
 511 }
 512
 513 static void sriov_release(struct pci_dev *dev)
 514 {
 515         BUG_ON(dev->sriov->nr_virtfn);
 516
 517         if (dev != dev->sriov->dev)
 518                 pci_dev_put(dev->sriov->dev);
 519
 520         mutex_destroy(&dev->sriov->lock);
 521
 522         kfree(dev->sriov);
 523         dev->sriov = NULL;
 524 }
 525
 526 static void sriov_restore_state(struct pci_dev *dev)
 527 {
 528         int i;
 529         u16 ctrl;
 530         struct pci_sriov *iov = dev->sriov;
 531
 532         pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl);
 533         if (ctrl & PCI_SRIOV_CTRL_VFE)
 534                 return;
 535
 536         for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++)
 537                 pci_update_resource(dev, i);
 538
 539         pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
 540         pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, iov->nr_virtfn);
 541         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
 542         if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
 543                 msleep(100);
 544 }
 545
 546 /**
 547  * pci_iov_init - initialize the IOV capability
 548  * @dev: the PCI device
 549  *
 550  * Returns 0 on success, or negative on failure.
 551  */
 552 int pci_iov_init(struct pci_dev *dev)
 553 {
 554         int pos;
 555
 556         if (!dev->is_pcie)
 557                 return -ENODEV;
 558
 559         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV);
 560         if (pos)
 561                 return sriov_init(dev, pos);
 562
 563         return -ENODEV;
 564 }
 565
 566 /**
 567  * pci_iov_release - release resources used by the IOV capability
 568  * @dev: the PCI device
 569  */
 570 void pci_iov_release(struct pci_dev *dev)
 571 {
 572         if (dev->is_physfn)
 573                 sriov_release(dev);
 574 }
 575
 576 /**
 577  * pci_iov_resource_bar - get position of the SR-IOV BAR
 578  * @dev: the PCI device
 579  * @resno: the resource number
 580  * @type: the BAR type to be filled in
 581  *
 582  * Returns position of the BAR encapsulated in the SR-IOV capability.
 583  */
 584 int pci_iov_resource_bar(struct pci_dev *dev, int resno,
 585                          enum pci_bar_type *type)
 586 {
 587         if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END)
 588                 return 0;
 589
 590         BUG_ON(!dev->is_physfn);
 591
 592         *type = pci_bar_unknown;
 593
 594         return dev->sriov->pos + PCI_SRIOV_BAR +
 595                 4 * (resno - PCI_IOV_RESOURCES);
 596 }
 597
 598 /**
 599  * pci_restore_iov_state - restore the state of the IOV capability
 600  * @dev: the PCI device
 601  */
 602 void pci_restore_iov_state(struct pci_dev *dev)
 603 {
 604         if (dev->is_physfn)
 605                 sriov_restore_state(dev);
 606 }
 607
 608 /**
 609  * pci_iov_bus_range - find bus range used by Virtual Function
 610  * @bus: the PCI bus
 611  *
 612  * Returns max number of buses (exclude current one) used by Virtual
 613  * Functions.
 614  */
 615 int pci_iov_bus_range(struct pci_bus *bus)
 616 {
 617         int max = 0;
 618         u8 busnr;
 619         struct pci_dev *dev;
 620
 621         list_for_each_entry(dev, &bus->devices, bus_list) {
 622                 if (!dev->is_physfn)
 623                         continue;
 624                 busnr = virtfn_bus(dev, dev->sriov->total - 1);
 625                 if (busnr > max)
 626                         max = busnr;
 627         }
 628
 629         return max ? max - bus->number : 0;
 630 }
 631
 632 /**
 633  * pci_enable_sriov - enable the SR-IOV capability
 634  * @dev: the PCI device
 635  * @nr_virtfn: number of virtual functions to enable
 636  *
 637  * Returns 0 on success, or negative on failure.
 638  */
 639 int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
 640 {
 641         might_sleep();
 642
 643         if (!dev->is_physfn)
 644                 return -ENODEV;
 645
 646         return sriov_enable(dev, nr_virtfn);
 647 }
 648 EXPORT_SYMBOL_GPL(pci_enable_sriov);
 649
 650 /**
 651  * pci_disable_sriov - disable the SR-IOV capability
 652  * @dev: the PCI device
 653  */
 654 void pci_disable_sriov(struct pci_dev *dev)
 655 {
 656         might_sleep();
 657
 658         if (!dev->is_physfn)
 659                 return;
 660
 661         sriov_disable(dev);
 662 }
 663 EXPORT_SYMBOL_GPL(pci_disable_sriov);
 664
 665 /**
 666  * pci_sriov_migration - notify SR-IOV core of Virtual Function Migration
 667  * @dev: the PCI device
 668  *
 669  * Returns IRQ_HANDLED if the IRQ is handled, or IRQ_NONE if not.
 670  *
 671  * Physical Function driver is responsible to register IRQ handler using
 672  * VF Migration Interrupt Message Number, and call this function when the
 673  * interrupt is generated by the hardware.
 674  */
 675 irqreturn_t pci_sriov_migration(struct pci_dev *dev)
 676 {
 677         if (!dev->is_physfn)
 678                 return IRQ_NONE;
 679
 680         return sriov_migration(dev) ? IRQ_HANDLED : IRQ_NONE;
 681 }
 682 EXPORT_SYMBOL_GPL(pci_sriov_migration);
 683
 684 static int ats_alloc_one(struct pci_dev *dev, int ps)
 685 {
 686         int pos;
 687         u16 cap;
 688         struct pci_ats *ats;
 689
 690         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ATS);
 691         if (!pos)
 692                 return -ENODEV;
 693
 694         ats = kzalloc(sizeof(*ats), GFP_KERNEL);
 695         if (!ats)
 696                 return -ENOMEM;
 697
 698         ats->pos = pos;
 699         ats->stu = ps;
 700         pci_read_config_word(dev, pos + PCI_ATS_CAP, &cap);
 701         ats->qdep = PCI_ATS_CAP_QDEP(cap) ? PCI_ATS_CAP_QDEP(cap) :
 702                                             PCI_ATS_MAX_QDEP;
 703         dev->ats = ats;
 704
 705         return 0;
 706 }
 707
 708 static void ats_free_one(struct pci_dev *dev)
 709 {
 710         kfree(dev->ats);
 711         dev->ats = NULL;
 712 }
 713
 714 /**
 715  * pci_enable_ats - enable the ATS capability
 716  * @dev: the PCI device
 717  * @ps: the IOMMU page shift
 718  *
 719  * Returns 0 on success, or negative on failure.
 720  */
 721 int pci_enable_ats(struct pci_dev *dev, int ps)
 722 {
 723         int rc;
 724         u16 ctrl;
 725
 726         BUG_ON(dev->ats && dev->ats->is_enabled);
 727
 728         if (ps < PCI_ATS_MIN_STU)
 729                 return -EINVAL;
 730
 731         if (dev->is_physfn || dev->is_virtfn) {
 732                 struct pci_dev *pdev = dev->is_physfn ? dev : dev->physfn;
 733
 734                 mutex_lock(&pdev->sriov->lock);
 735                 if (pdev->ats)
 736                         rc = pdev->ats->stu == ps ? 0 : -EINVAL;
 737                 else
 738                         rc = ats_alloc_one(pdev, ps);
 739
 740                 if (!rc)
 741                         pdev->ats->ref_cnt++;
 742                 mutex_unlock(&pdev->sriov->lock);
 743                 if (rc)
 744                         return rc;
 745         }
 746
 747         if (!dev->is_physfn) {
 748                 rc = ats_alloc_one(dev, ps);
 749                 if (rc)
 750                         return rc;
 751         }
 752
 753         ctrl = PCI_ATS_CTRL_ENABLE;
 754         if (!dev->is_virtfn)
 755                 ctrl |= PCI_ATS_CTRL_STU(ps - PCI_ATS_MIN_STU);
 756         pci_write_config_word(dev, dev->ats->pos + PCI_ATS_CTRL, ctrl);
 757
 758         dev->ats->is_enabled = 1;
 759
 760         return 0;
 761 }
 762
 763 /**
 764  * pci_disable_ats - disable the ATS capability
 765  * @dev: the PCI device
 766  */
 767 void pci_disable_ats(struct pci_dev *dev)
 768 {
 769         u16 ctrl;
 770
 771         BUG_ON(!dev->ats || !dev->ats->is_enabled);
 772
 773         pci_read_config_word(dev, dev->ats->pos + PCI_ATS_CTRL, &ctrl);
 774         ctrl &= ~PCI_ATS_CTRL_ENABLE;
 775         pci_write_config_word(dev, dev->ats->pos + PCI_ATS_CTRL, ctrl);
 776
 777         dev->ats->is_enabled = 0;
 778
 779         if (dev->is_physfn || dev->is_virtfn) {
 780                 struct pci_dev *pdev = dev->is_physfn ? dev : dev->physfn;
 781
 782                 mutex_lock(&pdev->sriov->lock);
 783                 pdev->ats->ref_cnt--;
 784                 if (!pdev->ats->ref_cnt)
 785                         ats_free_one(pdev);
 786                 mutex_unlock(&pdev->sriov->lock);
 787         }
 788
 789         if (!dev->is_physfn)
 790                 ats_free_one(dev);
 791 }
 792
 793 /**
 794  * pci_ats_queue_depth - query the ATS Invalidate Queue Depth
 795  * @dev: the PCI device
 796  *
 797  * Returns the queue depth on success, or negative on failure.
 798  *
 799  * The ATS spec uses 0 in the Invalidate Queue Depth field to
 800  * indicate that the function can accept 32 Invalidate Request.
 801  * But here we use the `real' values (i.e. 1~32) for the Queue
 802  * Depth; and 0 indicates the function shares the Queue with
 803  * other functions (doesn't exclusively own a Queue).
 804  */
 805 int pci_ats_queue_depth(struct pci_dev *dev)
 806 {
 807         int pos;
 808         u16 cap;
 809
 810         if (dev->is_virtfn)
 811                 return 0;
 812
 813         if (dev->ats)
 814                 return dev->ats->qdep;
 815
 816         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ATS);
 817         if (!pos)
 818                 return -ENODEV;
 819
 820         pci_read_config_word(dev, pos + PCI_ATS_CAP, &cap);
 821
 822         return PCI_ATS_CAP_QDEP(cap) ? PCI_ATS_CAP_QDEP(cap) :
 823                                        PCI_ATS_MAX_QDEP;
 824 }