lib/librte_eal/linuxapp/igb_uio/igb_uio.c

   1 /*-
   2  * GPL LICENSE SUMMARY
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of version 2 of the GNU General Public License as
   8  *   published by the Free Software Foundation.
   9  *
  10  *   This program is distributed in the hope that it will be useful, but
  11  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *   General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18  *   The full GNU General Public License is included in this distribution
  19  *   in the file called LICENSE.GPL.
  20  *
  21  *   Contact Information:
  22  *   Intel Corporation
  23  */
  24
  25 #include <linux/device.h>
  26 #include <linux/module.h>
  27 #include <linux/pci.h>
  28 #include <linux/uio_driver.h>
  29 #include <linux/io.h>
  30 #include <linux/msi.h>
  31 #include <linux/version.h>
  32
  33 #ifdef CONFIG_XEN_DOM0
  34 #include <xen/xen.h>
  35 #endif
  36 #include <rte_pci_dev_features.h>
  37
  38 /**
  39  * MSI-X related macros, copy from linux/pci_regs.h in kernel 2.6.39,
  40  * but none of them in kernel 2.6.35.
  41  */
  42 #ifndef PCI_MSIX_ENTRY_SIZE
  43 #define PCI_MSIX_ENTRY_SIZE             16
  44 #define PCI_MSIX_ENTRY_LOWER_ADDR       0
  45 #define PCI_MSIX_ENTRY_UPPER_ADDR       4
  46 #define PCI_MSIX_ENTRY_DATA             8
  47 #define PCI_MSIX_ENTRY_VECTOR_CTRL      12
  48 #define PCI_MSIX_ENTRY_CTRL_MASKBIT     1
  49 #endif
  50
  51 #ifdef RTE_PCI_CONFIG
  52 #define PCI_SYS_FILE_BUF_SIZE      10
  53 #define PCI_DEV_CAP_REG            0xA4
  54 #define PCI_DEV_CTRL_REG           0xA8
  55 #define PCI_DEV_CAP_EXT_TAG_MASK   0x20
  56 #define PCI_DEV_CTRL_EXT_TAG_SHIFT 8
  57 #define PCI_DEV_CTRL_EXT_TAG_MASK  (1 << PCI_DEV_CTRL_EXT_TAG_SHIFT)
  58 #endif
  59
  60 #define IGBUIO_NUM_MSI_VECTORS 1
  61
  62 /**
  63  * A structure describing the private information for a uio device.
  64  */
  65 struct rte_uio_pci_dev {
  66         struct uio_info info;
  67         struct pci_dev *pdev;
  68         spinlock_t lock; /* spinlock for accessing PCI config space or msix data in multi tasks/isr */
  69         enum rte_intr_mode mode;
  70         struct msix_entry \
  71                 msix_entries[IGBUIO_NUM_MSI_VECTORS]; /* pointer to the msix vectors to be allocated later */
  72 };
  73
  74 static char *intr_mode = NULL;
  75 static enum rte_intr_mode igbuio_intr_mode_preferred = RTE_INTR_MODE_MSIX;
  76
  77 static inline struct rte_uio_pci_dev *
  78 igbuio_get_uio_pci_dev(struct uio_info *info)
  79 {
  80         return container_of(info, struct rte_uio_pci_dev, info);
  81 }
  82
  83 /* sriov sysfs */
  84 int local_pci_num_vf(struct pci_dev *dev)
  85 {
  86 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)
  87         struct iov {
  88                 int pos;
  89                 int nres;
  90                 u32 cap;
  91                 u16 ctrl;
  92                 u16 total;
  93                 u16 initial;
  94                 u16 nr_virtfn;
  95         } *iov = (struct iov*)dev->sriov;
  96
  97         if (!dev->is_physfn)
  98                 return 0;
  99
 100         return iov->nr_virtfn;
 101 #else
 102         return pci_num_vf(dev);
 103 #endif
 104 }
 105
 106 static ssize_t
 107 show_max_vfs(struct device *dev, struct device_attribute *attr,
 108              char *buf)
 109 {
 110         return snprintf(buf, 10, "%u\n", local_pci_num_vf(
 111                                 container_of(dev, struct pci_dev, dev)));
 112 }
 113
 114 static ssize_t
 115 store_max_vfs(struct device *dev, struct device_attribute *attr,
 116               const char *buf, size_t count)
 117 {
 118         int err = 0;
 119         unsigned long max_vfs;
 120         struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
 121
 122         if (0 != strict_strtoul(buf, 0, &max_vfs))
 123                 return -EINVAL;
 124
 125         if (0 == max_vfs)
 126                 pci_disable_sriov(pdev);
 127         else if (0 == local_pci_num_vf(pdev))
 128                 err = pci_enable_sriov(pdev, max_vfs);
 129         else /* do nothing if change max_vfs number */
 130                 err = -EINVAL;
 131
 132         return err ? err : count;
 133 }
 134
 135 #ifdef RTE_PCI_CONFIG
 136 static ssize_t
 137 show_extended_tag(struct device *dev, struct device_attribute *attr, char *buf)
 138 {
 139         struct pci_dev *pci_dev = container_of(dev, struct pci_dev, dev);
 140         uint32_t val = 0;
 141
 142         pci_read_config_dword(pci_dev, PCI_DEV_CAP_REG, &val);
 143         if (!(val & PCI_DEV_CAP_EXT_TAG_MASK)) /* Not supported */
 144                 return snprintf(buf, PCI_SYS_FILE_BUF_SIZE, "%s\n", "invalid");
 145
 146         val = 0;
 147         pci_bus_read_config_dword(pci_dev->bus, pci_dev->devfn,
 148                                         PCI_DEV_CTRL_REG, &val);
 149
 150         return snprintf(buf, PCI_SYS_FILE_BUF_SIZE, "%s\n",
 151                 (val & PCI_DEV_CTRL_EXT_TAG_MASK) ? "on" : "off");
 152 }
 153
 154 static ssize_t
 155 store_extended_tag(struct device *dev,
 156                    struct device_attribute *attr,
 157                    const char *buf,
 158                    size_t count)
 159 {
 160         struct pci_dev *pci_dev = container_of(dev, struct pci_dev, dev);
 161         uint32_t val = 0, enable;
 162
 163         if (strncmp(buf, "on", 2) == 0)
 164                 enable = 1;
 165         else if (strncmp(buf, "off", 3) == 0)
 166                 enable = 0;
 167         else
 168                 return -EINVAL;
 169
 170         pci_bus_read_config_dword(pci_dev->bus, pci_dev->devfn,
 171                                         PCI_DEV_CAP_REG, &val);
 172         if (!(val & PCI_DEV_CAP_EXT_TAG_MASK)) /* Not supported */
 173                 return -EPERM;
 174
 175         val = 0;
 176         pci_bus_read_config_dword(pci_dev->bus, pci_dev->devfn,
 177                                         PCI_DEV_CTRL_REG, &val);
 178         if (enable)
 179                 val |= PCI_DEV_CTRL_EXT_TAG_MASK;
 180         else
 181                 val &= ~PCI_DEV_CTRL_EXT_TAG_MASK;
 182         pci_bus_write_config_dword(pci_dev->bus, pci_dev->devfn,
 183                                         PCI_DEV_CTRL_REG, val);
 184
 185         return count;
 186 }
 187
 188 static ssize_t
 189 show_max_read_request_size(struct device *dev,
 190                            struct device_attribute *attr,
 191                            char *buf)
 192 {
 193         struct pci_dev *pci_dev = container_of(dev, struct pci_dev, dev);
 194         int val = pcie_get_readrq(pci_dev);
 195
 196         return snprintf(buf, PCI_SYS_FILE_BUF_SIZE, "%d\n", val);
 197 }
 198
 199 static ssize_t
 200 store_max_read_request_size(struct device *dev,
 201                             struct device_attribute *attr,
 202                             const char *buf,
 203                             size_t count)
 204 {
 205         struct pci_dev *pci_dev = container_of(dev, struct pci_dev, dev);
 206         unsigned long size = 0;
 207         int ret;
 208
 209         if (strict_strtoul(buf, 0, &size) != 0)
 210                 return -EINVAL;
 211
 212         ret = pcie_set_readrq(pci_dev, (int)size);
 213         if (ret < 0)
 214                 return ret;
 215
 216         return count;
 217 }
 218 #endif
 219
 220 static DEVICE_ATTR(max_vfs, S_IRUGO | S_IWUSR, show_max_vfs, store_max_vfs);
 221 #ifdef RTE_PCI_CONFIG
 222 static DEVICE_ATTR(extended_tag, S_IRUGO | S_IWUSR, show_extended_tag, \
 223         store_extended_tag);
 224 static DEVICE_ATTR(max_read_request_size, S_IRUGO | S_IWUSR, \
 225         show_max_read_request_size, store_max_read_request_size);
 226 #endif
 227
 228 static struct attribute *dev_attrs[] = {
 229         &dev_attr_max_vfs.attr,
 230 #ifdef RTE_PCI_CONFIG
 231         &dev_attr_extended_tag.attr,
 232         &dev_attr_max_read_request_size.attr,
 233 #endif
 234         NULL,
 235 };
 236
 237 static const struct attribute_group dev_attr_grp = {
 238         .attrs = dev_attrs,
 239 };
 240
 241 static inline int
 242 pci_lock(struct pci_dev * pdev)
 243 {
 244         /* Some function names changes between 3.2.0 and 3.3.0... */
 245 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)
 246         pci_block_user_cfg_access(pdev);
 247         return 1;
 248 #else
 249         return pci_cfg_access_trylock(pdev);
 250 #endif
 251 }
 252
 253 static inline void
 254 pci_unlock(struct pci_dev * pdev)
 255 {
 256         /* Some function names changes between 3.2.0 and 3.3.0... */
 257 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)
 258         pci_unblock_user_cfg_access(pdev);
 259 #else
 260         pci_cfg_access_unlock(pdev);
 261 #endif
 262 }
 263
 264 /**
 265  * It masks the msix on/off of generating MSI-X messages.
 266  */
 267 static int
 268 igbuio_msix_mask_irq(struct msi_desc *desc, int32_t state)
 269 {
 270         uint32_t mask_bits = desc->masked;
 271         unsigned offset = desc->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
 272                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
 273
 274         if (state != 0)
 275                 mask_bits &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
 276         else
 277                 mask_bits |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
 278
 279         if (mask_bits != desc->masked) {
 280                 writel(mask_bits, desc->mask_base + offset);
 281                 readl(desc->mask_base);
 282                 desc->masked = mask_bits;
 283         }
 284
 285         return 0;
 286 }
 287
 288 /**
 289  * This function sets/clears the masks for generating LSC interrupts.
 290  *
 291  * @param info
 292  *   The pointer to struct uio_info.
 293  * @param on
 294  *   The on/off flag of masking LSC.
 295  * @return
 296  *   -On success, zero value.
 297  *   -On failure, a negative value.
 298  */
 299 static int
 300 igbuio_set_interrupt_mask(struct rte_uio_pci_dev *udev, int32_t state)
 301 {
 302         struct pci_dev *pdev = udev->pdev;
 303
 304         if (udev->mode == RTE_INTR_MODE_MSIX) {
 305                 struct msi_desc *desc;
 306
 307                 list_for_each_entry(desc, &pdev->msi_list, list) {
 308                         igbuio_msix_mask_irq(desc, state);
 309                 }
 310         } else if (udev->mode == RTE_INTR_MODE_LEGACY) {
 311                 uint32_t status;
 312                 uint16_t old, new;
 313
 314                 pci_read_config_dword(pdev, PCI_COMMAND, &status);
 315                 old = status;
 316                 if (state != 0)
 317                         new = old & (~PCI_COMMAND_INTX_DISABLE);
 318                 else
 319                         new = old | PCI_COMMAND_INTX_DISABLE;
 320
 321                 if (old != new)
 322                         pci_write_config_word(pdev, PCI_COMMAND, new);
 323         }
 324
 325         return 0;
 326 }
 327
 328 /**
 329  * This is the irqcontrol callback to be registered to uio_info.
 330  * It can be used to disable/enable interrupt from user space processes.
 331  *
 332  * @param info
 333  *  pointer to uio_info.
 334  * @param irq_state
 335  *  state value. 1 to enable interrupt, 0 to disable interrupt.
 336  *
 337  * @return
 338  *  - On success, 0.
 339  *  - On failure, a negative value.
 340  */
 341 static int
 342 igbuio_pci_irqcontrol(struct uio_info *info, s32 irq_state)
 343 {
 344         unsigned long flags;
 345         struct rte_uio_pci_dev *udev = igbuio_get_uio_pci_dev(info);
 346         struct pci_dev *pdev = udev->pdev;
 347
 348         spin_lock_irqsave(&udev->lock, flags);
 349         if (!pci_lock(pdev)) {
 350                 spin_unlock_irqrestore(&udev->lock, flags);
 351                 return -1;
 352         }
 353
 354         igbuio_set_interrupt_mask(udev, irq_state);
 355
 356         pci_unlock(pdev);
 357         spin_unlock_irqrestore(&udev->lock, flags);
 358
 359         return 0;
 360 }
 361
 362 /**
 363  * This is interrupt handler which will check if the interrupt is for the right device.
 364  * If yes, disable it here and will be enable later.
 365  */
 366 static irqreturn_t
 367 igbuio_pci_irqhandler(int irq, struct uio_info *info)
 368 {
 369         irqreturn_t ret = IRQ_NONE;
 370         unsigned long flags;
 371         struct rte_uio_pci_dev *udev = igbuio_get_uio_pci_dev(info);
 372         struct pci_dev *pdev = udev->pdev;
 373         uint32_t cmd_status_dword;
 374         uint16_t status;
 375
 376         spin_lock_irqsave(&udev->lock, flags);
 377         /* block userspace PCI config reads/writes */
 378         if (!pci_lock(pdev))
 379                 goto spin_unlock;
 380
 381         /* for legacy mode, interrupt maybe shared */
 382         if (udev->mode == RTE_INTR_MODE_LEGACY) {
 383                 pci_read_config_dword(pdev, PCI_COMMAND, &cmd_status_dword);
 384                 status = cmd_status_dword >> 16;
 385                 /* interrupt is not ours, goes to out */
 386                 if (!(status & PCI_STATUS_INTERRUPT))
 387                         goto done;
 388         }
 389
 390         igbuio_set_interrupt_mask(udev, 0);
 391         ret = IRQ_HANDLED;
 392 done:
 393         /* unblock userspace PCI config reads/writes */
 394         pci_unlock(pdev);
 395 spin_unlock:
 396         spin_unlock_irqrestore(&udev->lock, flags);
 397         printk(KERN_INFO "irq 0x%x %s\n", irq, (ret == IRQ_HANDLED) ? "handled" : "not handled");
 398
 399         return ret;
 400 }
 401
 402 #ifdef CONFIG_XEN_DOM0
 403 static int
 404 igbuio_dom0_mmap_phys(struct uio_info *info, struct vm_area_struct *vma)
 405 {
 406         int idx;
 407         idx = (int)vma->vm_pgoff;
 408         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 409         vma->vm_page_prot.pgprot |= _PAGE_IOMAP;
 410
 411         return remap_pfn_range(vma,
 412                         vma->vm_start,
 413                         info->mem[idx].addr >> PAGE_SHIFT,
 414                         vma->vm_end - vma->vm_start,
 415                         vma->vm_page_prot);
 416 }
 417
 418 /**
 419  * This is uio device mmap method which will use igbuio mmap for Xen
 420  * Dom0 environment.
 421  */
 422 static int
 423 igbuio_dom0_pci_mmap(struct uio_info *info, struct vm_area_struct *vma)
 424 {
 425         int idx;
 426
 427         if (vma->vm_pgoff >= MAX_UIO_MAPS)
 428                 return -EINVAL;
 429         if(info->mem[vma->vm_pgoff].size == 0)
 430                 return  -EINVAL;
 431
 432         idx = (int)vma->vm_pgoff;
 433         switch (info->mem[idx].memtype) {
 434         case UIO_MEM_PHYS:
 435                 return igbuio_dom0_mmap_phys(info, vma);
 436         case UIO_MEM_LOGICAL:
 437         case UIO_MEM_VIRTUAL:
 438         default:
 439                 return -EINVAL;
 440         }
 441 }
 442 #endif
 443
 444 /* Remap pci resources described by bar #pci_bar in uio resource n. */
 445 static int
 446 igbuio_pci_setup_iomem(struct pci_dev *dev, struct uio_info *info,
 447                        int n, int pci_bar, const char *name)
 448 {
 449         unsigned long addr, len;
 450         void *internal_addr;
 451
 452         if (sizeof(info->mem) / sizeof (info->mem[0]) <= n)
 453                 return (EINVAL);
 454
 455         addr = pci_resource_start(dev, pci_bar);
 456         len = pci_resource_len(dev, pci_bar);
 457         if (addr == 0 || len == 0)
 458                 return -1;
 459         internal_addr = ioremap(addr, len);
 460         if (internal_addr == NULL)
 461                 return -1;
 462         info->mem[n].name = name;
 463         info->mem[n].addr = addr;
 464         info->mem[n].internal_addr = internal_addr;
 465         info->mem[n].size = len;
 466         info->mem[n].memtype = UIO_MEM_PHYS;
 467         return 0;
 468 }
 469
 470 /* Get pci port io resources described by bar #pci_bar in uio resource n. */
 471 static int
 472 igbuio_pci_setup_ioport(struct pci_dev *dev, struct uio_info *info,
 473                 int n, int pci_bar, const char *name)
 474 {
 475         unsigned long addr, len;
 476
 477         if (sizeof(info->port) / sizeof (info->port[0]) <= n)
 478                 return (EINVAL);
 479
 480         addr = pci_resource_start(dev, pci_bar);
 481         len = pci_resource_len(dev, pci_bar);
 482         if (addr == 0 || len == 0)
 483                 return (-1);
 484
 485         info->port[n].name = name;
 486         info->port[n].start = addr;
 487         info->port[n].size = len;
 488         info->port[n].porttype = UIO_PORT_X86;
 489
 490         return (0);
 491 }
 492
 493 /* Unmap previously ioremap'd resources */
 494 static void
 495 igbuio_pci_release_iomem(struct uio_info *info)
 496 {
 497         int i;
 498         for (i = 0; i < MAX_UIO_MAPS; i++) {
 499                 if (info->mem[i].internal_addr)
 500                         iounmap(info->mem[i].internal_addr);
 501         }
 502 }
 503
 504 static int
 505 igbuio_setup_bars(struct pci_dev *dev, struct uio_info *info)
 506 {
 507         int i, iom, iop, ret;
 508         unsigned long flags;
 509         static const char *bar_names[PCI_STD_RESOURCE_END + 1]  = {
 510                 "BAR0",
 511                 "BAR1",
 512                 "BAR2",
 513                 "BAR3",
 514                 "BAR4",
 515                 "BAR5",
 516         };
 517
 518         iom = 0;
 519         iop = 0;
 520
 521         for (i = 0; i != sizeof(bar_names) / sizeof(bar_names[0]); i++) {
 522                 if (pci_resource_len(dev, i) != 0 &&
 523                                 pci_resource_start(dev, i) != 0) {
 524                         flags = pci_resource_flags(dev, i);
 525                         if (flags & IORESOURCE_MEM) {
 526                                 if ((ret = igbuio_pci_setup_iomem(dev, info,
 527                                                 iom, i, bar_names[i])) != 0)
 528                                         return (ret);
 529                                 iom++;
 530                         } else if (flags & IORESOURCE_IO) {
 531                                 if ((ret = igbuio_pci_setup_ioport(dev, info,
 532                                                 iop, i, bar_names[i])) != 0)
 533                                         return (ret);
 534                                 iop++;
 535                         }
 536                 }
 537         }
 538
 539         return ((iom != 0) ? ret : ENOENT);
 540 }
 541
 542 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)
 543 static int __devinit
 544 #else
 545 static int
 546 #endif
 547 igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 548 {
 549         struct rte_uio_pci_dev *udev;
 550
 551         udev = kzalloc(sizeof(struct rte_uio_pci_dev), GFP_KERNEL);
 552         if (!udev)
 553                 return -ENOMEM;
 554
 555         /*
 556          * enable device: ask low-level code to enable I/O and
 557          * memory
 558          */
 559         if (pci_enable_device(dev)) {
 560                 printk(KERN_ERR "Cannot enable PCI device\n");
 561                 goto fail_free;
 562         }
 563
 564         /*
 565          * reserve device's PCI memory regions for use by this
 566          * module
 567          */
 568         if (pci_request_regions(dev, "igb_uio")) {
 569                 printk(KERN_ERR "Cannot request regions\n");
 570                 goto fail_disable;
 571         }
 572
 573         /* enable bus mastering on the device */
 574         pci_set_master(dev);
 575
 576         /* remap IO memory */
 577         if (igbuio_setup_bars(dev, &udev->info))
 578                 goto fail_release_iomem;
 579
 580         /* set 64-bit DMA mask */
 581         if (pci_set_dma_mask(dev,  DMA_BIT_MASK(64))) {
 582                 printk(KERN_ERR "Cannot set DMA mask\n");
 583                 goto fail_release_iomem;
 584         } else if (pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64))) {
 585                 printk(KERN_ERR "Cannot set consistent DMA mask\n");
 586                 goto fail_release_iomem;
 587         }
 588
 589         /* fill uio infos */
 590         udev->info.name = "Intel IGB UIO";
 591         udev->info.version = "0.1";
 592         udev->info.handler = igbuio_pci_irqhandler;
 593         udev->info.irqcontrol = igbuio_pci_irqcontrol;
 594 #ifdef CONFIG_XEN_DOM0
 595         /* check if the driver run on Xen Dom0 */
 596         if (xen_initial_domain())
 597                 udev->info.mmap = igbuio_dom0_pci_mmap;
 598 #endif
 599         udev->info.priv = udev;
 600         udev->pdev = dev;
 601         udev->mode = RTE_INTR_MODE_LEGACY;
 602         spin_lock_init(&udev->lock);
 603
 604         /* check if it need to try msix first */
 605         if (igbuio_intr_mode_preferred == RTE_INTR_MODE_MSIX) {
 606                 int vector;
 607
 608                 for (vector = 0; vector < IGBUIO_NUM_MSI_VECTORS; vector ++)
 609                         udev->msix_entries[vector].entry = vector;
 610
 611                 if (pci_enable_msix(udev->pdev, udev->msix_entries, IGBUIO_NUM_MSI_VECTORS) == 0) {
 612                         udev->mode = RTE_INTR_MODE_MSIX;
 613                 }
 614                 else {
 615                         pci_disable_msix(udev->pdev);
 616                         printk(KERN_INFO "fail to enable pci msix, or not enough msix entries\n");
 617                 }
 618         }
 619         switch (udev->mode) {
 620         case RTE_INTR_MODE_MSIX:
 621                 udev->info.irq_flags = 0;
 622                 udev->info.irq = udev->msix_entries[0].vector;
 623                 break;
 624         case RTE_INTR_MODE_MSI:
 625                 break;
 626         case RTE_INTR_MODE_LEGACY:
 627                 udev->info.irq_flags = IRQF_SHARED;
 628                 udev->info.irq = dev->irq;
 629                 break;
 630         default:
 631                 break;
 632         }
 633
 634         pci_set_drvdata(dev, udev);
 635         igbuio_pci_irqcontrol(&udev->info, 0);
 636
 637         if (sysfs_create_group(&dev->dev.kobj, &dev_attr_grp))
 638                 goto fail_release_iomem;
 639
 640         /* register uio driver */
 641         if (uio_register_device(&dev->dev, &udev->info))
 642                 goto fail_release_iomem;
 643
 644         printk(KERN_INFO "uio device registered with irq %lx\n", udev->info.irq);
 645
 646         return 0;
 647
 648 fail_release_iomem:
 649         sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 650         igbuio_pci_release_iomem(&udev->info);
 651         if (udev->mode == RTE_INTR_MODE_MSIX)
 652                 pci_disable_msix(udev->pdev);
 653         pci_release_regions(dev);
 654 fail_disable:
 655         pci_disable_device(dev);
 656 fail_free:
 657         kfree(udev);
 658
 659         return -ENODEV;
 660 }
 661
 662 static void
 663 igbuio_pci_remove(struct pci_dev *dev)
 664 {
 665         struct uio_info *info = pci_get_drvdata(dev);
 666
 667         if (info->priv == NULL) {
 668                 printk(KERN_DEBUG "Not igbuio device\n");
 669                 return;
 670         }
 671
 672         sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 673         uio_unregister_device(info);
 674         igbuio_pci_release_iomem(info);
 675         if (((struct rte_uio_pci_dev *)info->priv)->mode ==
 676                         RTE_INTR_MODE_MSIX)
 677                 pci_disable_msix(dev);
 678         pci_release_regions(dev);
 679         pci_disable_device(dev);
 680         pci_set_drvdata(dev, NULL);
 681         kfree(info);
 682 }
 683
 684 static int
 685 igbuio_config_intr_mode(char *intr_str)
 686 {
 687         if (!intr_str) {
 688                 printk(KERN_INFO "Use MSIX interrupt by default\n");
 689                 return 0;
 690         }
 691
 692         if (!strcmp(intr_str, RTE_INTR_MODE_MSIX_NAME)) {
 693                 igbuio_intr_mode_preferred = RTE_INTR_MODE_MSIX;
 694                 printk(KERN_INFO "Use MSIX interrupt\n");
 695         } else if (!strcmp(intr_str, RTE_INTR_MODE_LEGACY_NAME)) {
 696                 igbuio_intr_mode_preferred = RTE_INTR_MODE_LEGACY;
 697                 printk(KERN_INFO "Use legacy interrupt\n");
 698         } else {
 699                 printk(KERN_INFO "Error: bad parameter - %s\n", intr_str);
 700                 return -EINVAL;
 701         }
 702
 703         return 0;
 704 }
 705
 706 static struct pci_driver igbuio_pci_driver = {
 707         .name = "igb_uio",
 708         .id_table = NULL,
 709         .probe = igbuio_pci_probe,
 710         .remove = igbuio_pci_remove,
 711 };
 712
 713 static int __init
 714 igbuio_pci_init_module(void)
 715 {
 716         int ret;
 717
 718         ret = igbuio_config_intr_mode(intr_mode);
 719         if (ret < 0)
 720                 return ret;
 721
 722         return pci_register_driver(&igbuio_pci_driver);
 723 }
 724
 725 static void __exit
 726 igbuio_pci_exit_module(void)
 727 {
 728         pci_unregister_driver(&igbuio_pci_driver);
 729 }
 730
 731 module_init(igbuio_pci_init_module);
 732 module_exit(igbuio_pci_exit_module);
 733
 734 module_param(intr_mode, charp, S_IRUGO | S_IWUSR);
 735 MODULE_PARM_DESC(intr_mode,
 736 "igb_uio interrupt mode (default=msix):\n"
 737 "    " RTE_INTR_MODE_MSIX_NAME "       Use MSIX interrupt\n"
 738 "    " RTE_INTR_MODE_LEGACY_NAME "     Use Legacy interrupt\n"
 739 "\n");
 740
 741 MODULE_DESCRIPTION("UIO driver for Intel IGB PCI cards");
 742 MODULE_LICENSE("GPL");
 743 MODULE_AUTHOR("Intel Corporation");