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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  26
  27 #include <linux/device.h>
  28 #include <linux/module.h>
  29 #include <linux/pci.h>
  30 #include <linux/uio_driver.h>
  31 #include <linux/io.h>
  32 #include <linux/irq.h>
  33 #include <linux/msi.h>
  34 #include <linux/version.h>
  35 #include <linux/slab.h>
  36
  37 #include <rte_pci_dev_features.h>
  38
  39 #include "compat.h"
  40
  41 /**
  42  * A structure describing the private information for a uio device.
  43  */
  44 struct rte_uio_pci_dev {
  45         struct uio_info info;
  46         struct pci_dev *pdev;
  47         enum rte_intr_mode mode;
  48         atomic_t refcnt;
  49 };
  50
  51 static char *intr_mode;
  52 static enum rte_intr_mode igbuio_intr_mode_preferred = RTE_INTR_MODE_MSIX;
  53 /* sriov sysfs */
  54 static ssize_t
  55 show_max_vfs(struct device *dev, struct device_attribute *attr,
  56              char *buf)
  57 {
  58         return snprintf(buf, 10, "%u\n", dev_num_vf(dev));
  59 }
  60
  61 static ssize_t
  62 store_max_vfs(struct device *dev, struct device_attribute *attr,
  63               const char *buf, size_t count)
  64 {
  65         int err = 0;
  66         unsigned long max_vfs;
  67         struct pci_dev *pdev = to_pci_dev(dev);
  68
  69         if (0 != kstrtoul(buf, 0, &max_vfs))
  70                 return -EINVAL;
  71
  72         if (0 == max_vfs)
  73                 pci_disable_sriov(pdev);
  74         else if (0 == pci_num_vf(pdev))
  75                 err = pci_enable_sriov(pdev, max_vfs);
  76         else /* do nothing if change max_vfs number */
  77                 err = -EINVAL;
  78
  79         return err ? err : count;
  80 }
  81
  82 static DEVICE_ATTR(max_vfs, S_IRUGO | S_IWUSR, show_max_vfs, store_max_vfs);
  83
  84 static struct attribute *dev_attrs[] = {
  85         &dev_attr_max_vfs.attr,
  86         NULL,
  87 };
  88
  89 static const struct attribute_group dev_attr_grp = {
  90         .attrs = dev_attrs,
  91 };
  92
  93 #ifndef HAVE_PCI_MSI_MASK_IRQ
  94 /*
  95  * It masks the msix on/off of generating MSI-X messages.
  96  */
  97 static void
  98 igbuio_msix_mask_irq(struct msi_desc *desc, s32 state)
  99 {
 100         u32 mask_bits = desc->masked;
 101         unsigned int offset = desc->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
 102                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
 103
 104         if (state != 0)
 105                 mask_bits &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
 106         else
 107                 mask_bits |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
 108
 109         if (mask_bits != desc->masked) {
 110                 writel(mask_bits, desc->mask_base + offset);
 111                 readl(desc->mask_base);
 112                 desc->masked = mask_bits;
 113         }
 114 }
 115
 116 /*
 117  * It masks the msi on/off of generating MSI messages.
 118  */
 119 static void
 120 igbuio_msi_mask_irq(struct pci_dev *pdev, struct msi_desc *desc, int32_t state)
 121 {
 122         u32 mask_bits = desc->masked;
 123         u32 offset = desc->irq - pdev->irq;
 124         u32 mask = 1 << offset;
 125
 126         if (!desc->msi_attrib.maskbit)
 127                 return;
 128
 129         if (state != 0)
 130                 mask_bits &= ~mask;
 131         else
 132                 mask_bits |= mask;
 133
 134         if (mask_bits != desc->masked) {
 135                 pci_write_config_dword(pdev, desc->mask_pos, mask_bits);
 136                 desc->masked = mask_bits;
 137         }
 138 }
 139
 140 static void
 141 igbuio_mask_irq(struct pci_dev *pdev, enum rte_intr_mode mode, s32 irq_state)
 142 {
 143         struct msi_desc *desc;
 144         struct list_head *msi_list;
 145
 146 #ifdef HAVE_MSI_LIST_IN_GENERIC_DEVICE
 147         msi_list = &pdev->dev.msi_list;
 148 #else
 149         msi_list = &pdev->msi_list;
 150 #endif
 151
 152         if (mode == RTE_INTR_MODE_MSIX) {
 153                 list_for_each_entry(desc, msi_list, list)
 154                         igbuio_msix_mask_irq(desc, irq_state);
 155         } else if (mode == RTE_INTR_MODE_MSI) {
 156                 list_for_each_entry(desc, msi_list, list)
 157                         igbuio_msi_mask_irq(pdev, desc, irq_state);
 158         }
 159 }
 160 #endif
 161
 162 /**
 163  * This is the irqcontrol callback to be registered to uio_info.
 164  * It can be used to disable/enable interrupt from user space processes.
 165  *
 166  * @param info
 167  *  pointer to uio_info.
 168  * @param irq_state
 169  *  state value. 1 to enable interrupt, 0 to disable interrupt.
 170  *
 171  * @return
 172  *  - On success, 0.
 173  *  - On failure, a negative value.
 174  */
 175 static int
 176 igbuio_pci_irqcontrol(struct uio_info *info, s32 irq_state)
 177 {
 178         struct rte_uio_pci_dev *udev = info->priv;
 179         struct pci_dev *pdev = udev->pdev;
 180
 181 #ifdef HAVE_PCI_MSI_MASK_IRQ
 182         struct irq_data *irq = irq_get_irq_data(udev->info.irq);
 183 #endif
 184
 185         pci_cfg_access_lock(pdev);
 186
 187         if (udev->mode == RTE_INTR_MODE_MSIX || udev->mode == RTE_INTR_MODE_MSI) {
 188 #ifdef HAVE_PCI_MSI_MASK_IRQ
 189                 if (irq_state == 1)
 190                         pci_msi_unmask_irq(irq);
 191                 else
 192                         pci_msi_mask_irq(irq);
 193 #else
 194                 igbuio_mask_irq(pdev, udev->mode, irq_state);
 195 #endif
 196         }
 197
 198         if (udev->mode == RTE_INTR_MODE_LEGACY)
 199                 pci_intx(pdev, !!irq_state);
 200
 201         pci_cfg_access_unlock(pdev);
 202
 203         return 0;
 204 }
 205
 206 /**
 207  * This is interrupt handler which will check if the interrupt is for the right device.
 208  * If yes, disable it here and will be enable later.
 209  */
 210 static irqreturn_t
 211 igbuio_pci_irqhandler(int irq, void *dev_id)
 212 {
 213         struct rte_uio_pci_dev *udev = (struct rte_uio_pci_dev *)dev_id;
 214         struct uio_info *info = &udev->info;
 215
 216         /* Legacy mode need to mask in hardware */
 217         if (udev->mode == RTE_INTR_MODE_LEGACY &&
 218             !pci_check_and_mask_intx(udev->pdev))
 219                 return IRQ_NONE;
 220
 221         uio_event_notify(info);
 222
 223         /* Message signal mode, no share IRQ and automasked */
 224         return IRQ_HANDLED;
 225 }
 226
 227 static int
 228 igbuio_pci_enable_interrupts(struct rte_uio_pci_dev *udev)
 229 {
 230         int err = 0;
 231 #ifndef HAVE_ALLOC_IRQ_VECTORS
 232         struct msix_entry msix_entry;
 233 #endif
 234
 235         switch (igbuio_intr_mode_preferred) {
 236         case RTE_INTR_MODE_MSIX:
 237                 /* Only 1 msi-x vector needed */
 238 #ifndef HAVE_ALLOC_IRQ_VECTORS
 239                 msix_entry.entry = 0;
 240                 if (pci_enable_msix(udev->pdev, &msix_entry, 1) == 0) {
 241                         dev_dbg(&udev->pdev->dev, "using MSI-X");
 242                         udev->info.irq_flags = IRQF_NO_THREAD;
 243                         udev->info.irq = msix_entry.vector;
 244                         udev->mode = RTE_INTR_MODE_MSIX;
 245                         break;
 246                 }
 247 #else
 248                 if (pci_alloc_irq_vectors(udev->pdev, 1, 1, PCI_IRQ_MSIX) == 1) {
 249                         dev_dbg(&udev->pdev->dev, "using MSI-X");
 250                         udev->info.irq_flags = IRQF_NO_THREAD;
 251                         udev->info.irq = pci_irq_vector(udev->pdev, 0);
 252                         udev->mode = RTE_INTR_MODE_MSIX;
 253                         break;
 254                 }
 255 #endif
 256
 257         /* fall back to MSI */
 258         case RTE_INTR_MODE_MSI:
 259 #ifndef HAVE_ALLOC_IRQ_VECTORS
 260                 if (pci_enable_msi(udev->pdev) == 0) {
 261                         dev_dbg(&udev->pdev->dev, "using MSI");
 262                         udev->info.irq_flags = IRQF_NO_THREAD;
 263                         udev->info.irq = udev->pdev->irq;
 264                         udev->mode = RTE_INTR_MODE_MSI;
 265                         break;
 266                 }
 267 #else
 268                 if (pci_alloc_irq_vectors(udev->pdev, 1, 1, PCI_IRQ_MSI) == 1) {
 269                         dev_dbg(&udev->pdev->dev, "using MSI");
 270                         udev->info.irq_flags = IRQF_NO_THREAD;
 271                         udev->info.irq = pci_irq_vector(udev->pdev, 0);
 272                         udev->mode = RTE_INTR_MODE_MSI;
 273                         break;
 274                 }
 275 #endif
 276         /* fall back to INTX */
 277         case RTE_INTR_MODE_LEGACY:
 278                 if (pci_intx_mask_supported(udev->pdev)) {
 279                         dev_dbg(&udev->pdev->dev, "using INTX");
 280                         udev->info.irq_flags = IRQF_SHARED | IRQF_NO_THREAD;
 281                         udev->info.irq = udev->pdev->irq;
 282                         udev->mode = RTE_INTR_MODE_LEGACY;
 283                         break;
 284                 }
 285                 dev_notice(&udev->pdev->dev, "PCI INTX mask not supported\n");
 286         /* fall back to no IRQ */
 287         case RTE_INTR_MODE_NONE:
 288                 udev->mode = RTE_INTR_MODE_NONE;
 289                 udev->info.irq = UIO_IRQ_NONE;
 290                 break;
 291
 292         default:
 293                 dev_err(&udev->pdev->dev, "invalid IRQ mode %u",
 294                         igbuio_intr_mode_preferred);
 295                 udev->info.irq = UIO_IRQ_NONE;
 296                 err = -EINVAL;
 297         }
 298
 299         if (udev->info.irq != UIO_IRQ_NONE)
 300                 err = request_irq(udev->info.irq, igbuio_pci_irqhandler,
 301                                   udev->info.irq_flags, udev->info.name,
 302                                   udev);
 303         dev_info(&udev->pdev->dev, "uio device registered with irq %lx\n",
 304                  udev->info.irq);
 305
 306         return err;
 307 }
 308
 309 static void
 310 igbuio_pci_disable_interrupts(struct rte_uio_pci_dev *udev)
 311 {
 312         if (udev->info.irq) {
 313                 free_irq(udev->info.irq, udev);
 314                 udev->info.irq = 0;
 315         }
 316
 317 #ifndef HAVE_ALLOC_IRQ_VECTORS
 318         if (udev->mode == RTE_INTR_MODE_MSIX)
 319                 pci_disable_msix(udev->pdev);
 320         if (udev->mode == RTE_INTR_MODE_MSI)
 321                 pci_disable_msi(udev->pdev);
 322 #else
 323         if (udev->mode == RTE_INTR_MODE_MSIX ||
 324             udev->mode == RTE_INTR_MODE_MSI)
 325                 pci_free_irq_vectors(udev->pdev);
 326 #endif
 327 }
 328
 329
 330 /**
 331  * This gets called while opening uio device file.
 332  */
 333 static int
 334 igbuio_pci_open(struct uio_info *info, struct inode *inode)
 335 {
 336         struct rte_uio_pci_dev *udev = info->priv;
 337         struct pci_dev *dev = udev->pdev;
 338         int err;
 339
 340         if (atomic_inc_return(&udev->refcnt) != 1)
 341                 return 0;
 342
 343         /* set bus master, which was cleared by the reset function */
 344         pci_set_master(dev);
 345
 346         /* enable interrupts */
 347         err = igbuio_pci_enable_interrupts(udev);
 348         if (err) {
 349                 atomic_dec(&udev->refcnt);
 350                 dev_err(&dev->dev, "Enable interrupt fails\n");
 351         }
 352         return err;
 353 }
 354
 355 static int
 356 igbuio_pci_release(struct uio_info *info, struct inode *inode)
 357 {
 358         struct rte_uio_pci_dev *udev = info->priv;
 359         struct pci_dev *dev = udev->pdev;
 360
 361         if (atomic_dec_and_test(&udev->refcnt)) {
 362                 /* disable interrupts */
 363                 igbuio_pci_disable_interrupts(udev);
 364
 365                 /* stop the device from further DMA */
 366                 pci_clear_master(dev);
 367         }
 368
 369         return 0;
 370 }
 371
 372 /* Remap pci resources described by bar #pci_bar in uio resource n. */
 373 static int
 374 igbuio_pci_setup_iomem(struct pci_dev *dev, struct uio_info *info,
 375                        int n, int pci_bar, const char *name)
 376 {
 377         unsigned long addr, len;
 378         void *internal_addr;
 379
 380         if (n >= ARRAY_SIZE(info->mem))
 381                 return -EINVAL;
 382
 383         addr = pci_resource_start(dev, pci_bar);
 384         len = pci_resource_len(dev, pci_bar);
 385         if (addr == 0 || len == 0)
 386                 return -1;
 387         internal_addr = ioremap(addr, len);
 388         if (internal_addr == NULL)
 389                 return -1;
 390         info->mem[n].name = name;
 391         info->mem[n].addr = addr;
 392         info->mem[n].internal_addr = internal_addr;
 393         info->mem[n].size = len;
 394         info->mem[n].memtype = UIO_MEM_PHYS;
 395         return 0;
 396 }
 397
 398 /* Get pci port io resources described by bar #pci_bar in uio resource n. */
 399 static int
 400 igbuio_pci_setup_ioport(struct pci_dev *dev, struct uio_info *info,
 401                 int n, int pci_bar, const char *name)
 402 {
 403         unsigned long addr, len;
 404
 405         if (n >= ARRAY_SIZE(info->port))
 406                 return -EINVAL;
 407
 408         addr = pci_resource_start(dev, pci_bar);
 409         len = pci_resource_len(dev, pci_bar);
 410         if (addr == 0 || len == 0)
 411                 return -EINVAL;
 412
 413         info->port[n].name = name;
 414         info->port[n].start = addr;
 415         info->port[n].size = len;
 416         info->port[n].porttype = UIO_PORT_X86;
 417
 418         return 0;
 419 }
 420
 421 /* Unmap previously ioremap'd resources */
 422 static void
 423 igbuio_pci_release_iomem(struct uio_info *info)
 424 {
 425         int i;
 426
 427         for (i = 0; i < MAX_UIO_MAPS; i++) {
 428                 if (info->mem[i].internal_addr)
 429                         iounmap(info->mem[i].internal_addr);
 430         }
 431 }
 432
 433 static int
 434 igbuio_setup_bars(struct pci_dev *dev, struct uio_info *info)
 435 {
 436         int i, iom, iop, ret;
 437         unsigned long flags;
 438         static const char *bar_names[PCI_STD_RESOURCE_END + 1]  = {
 439                 "BAR0",
 440                 "BAR1",
 441                 "BAR2",
 442                 "BAR3",
 443                 "BAR4",
 444                 "BAR5",
 445         };
 446
 447         iom = 0;
 448         iop = 0;
 449
 450         for (i = 0; i < ARRAY_SIZE(bar_names); i++) {
 451                 if (pci_resource_len(dev, i) != 0 &&
 452                                 pci_resource_start(dev, i) != 0) {
 453                         flags = pci_resource_flags(dev, i);
 454                         if (flags & IORESOURCE_MEM) {
 455                                 ret = igbuio_pci_setup_iomem(dev, info, iom,
 456                                                              i, bar_names[i]);
 457                                 if (ret != 0)
 458                                         return ret;
 459                                 iom++;
 460                         } else if (flags & IORESOURCE_IO) {
 461                                 ret = igbuio_pci_setup_ioport(dev, info, iop,
 462                                                               i, bar_names[i]);
 463                                 if (ret != 0)
 464                                         return ret;
 465                                 iop++;
 466                         }
 467                 }
 468         }
 469
 470         return (iom != 0 || iop != 0) ? ret : -ENOENT;
 471 }
 472
 473 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 8, 0)
 474 static int __devinit
 475 #else
 476 static int
 477 #endif
 478 igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 479 {
 480         struct rte_uio_pci_dev *udev;
 481         dma_addr_t map_dma_addr;
 482         void *map_addr;
 483         int err;
 484
 485         udev = kzalloc(sizeof(struct rte_uio_pci_dev), GFP_KERNEL);
 486         if (!udev)
 487                 return -ENOMEM;
 488
 489         /*
 490          * enable device: ask low-level code to enable I/O and
 491          * memory
 492          */
 493         err = pci_enable_device(dev);
 494         if (err != 0) {
 495                 dev_err(&dev->dev, "Cannot enable PCI device\n");
 496                 goto fail_free;
 497         }
 498
 499         /* enable bus mastering on the device */
 500         pci_set_master(dev);
 501
 502         /* remap IO memory */
 503         err = igbuio_setup_bars(dev, &udev->info);
 504         if (err != 0)
 505                 goto fail_release_iomem;
 506
 507         /* set 64-bit DMA mask */
 508         err = pci_set_dma_mask(dev,  DMA_BIT_MASK(64));
 509         if (err != 0) {
 510                 dev_err(&dev->dev, "Cannot set DMA mask\n");
 511                 goto fail_release_iomem;
 512         }
 513
 514         err = pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64));
 515         if (err != 0) {
 516                 dev_err(&dev->dev, "Cannot set consistent DMA mask\n");
 517                 goto fail_release_iomem;
 518         }
 519
 520         /* fill uio infos */
 521         udev->info.name = "igb_uio";
 522         udev->info.version = "0.1";
 523         udev->info.irqcontrol = igbuio_pci_irqcontrol;
 524         udev->info.open = igbuio_pci_open;
 525         udev->info.release = igbuio_pci_release;
 526         udev->info.priv = udev;
 527         udev->pdev = dev;
 528         atomic_set(&udev->refcnt, 0);
 529
 530         err = sysfs_create_group(&dev->dev.kobj, &dev_attr_grp);
 531         if (err != 0)
 532                 goto fail_release_iomem;
 533
 534         /* register uio driver */
 535         err = uio_register_device(&dev->dev, &udev->info);
 536         if (err != 0)
 537                 goto fail_remove_group;
 538
 539         pci_set_drvdata(dev, udev);
 540
 541         /*
 542          * Doing a harmless dma mapping for attaching the device to
 543          * the iommu identity mapping if kernel boots with iommu=pt.
 544          * Note this is not a problem if no IOMMU at all.
 545          */
 546         map_addr = dma_alloc_coherent(&dev->dev, 1024, &map_dma_addr,
 547                         GFP_KERNEL);
 548         if (map_addr)
 549                 memset(map_addr, 0, 1024);
 550
 551         if (!map_addr)
 552                 dev_info(&dev->dev, "dma mapping failed\n");
 553         else {
 554                 dev_info(&dev->dev, "mapping 1K dma=%#llx host=%p\n",
 555                          (unsigned long long)map_dma_addr, map_addr);
 556
 557                 dma_free_coherent(&dev->dev, 1024, map_addr, map_dma_addr);
 558                 dev_info(&dev->dev, "unmapping 1K dma=%#llx host=%p\n",
 559                          (unsigned long long)map_dma_addr, map_addr);
 560         }
 561
 562         return 0;
 563
 564 fail_remove_group:
 565         sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 566 fail_release_iomem:
 567         igbuio_pci_release_iomem(&udev->info);
 568         pci_disable_device(dev);
 569 fail_free:
 570         kfree(udev);
 571
 572         return err;
 573 }
 574
 575 static void
 576 igbuio_pci_remove(struct pci_dev *dev)
 577 {
 578         struct rte_uio_pci_dev *udev = pci_get_drvdata(dev);
 579
 580         sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 581         uio_unregister_device(&udev->info);
 582         igbuio_pci_release_iomem(&udev->info);
 583         pci_disable_device(dev);
 584         pci_set_drvdata(dev, NULL);
 585         kfree(udev);
 586 }
 587
 588 static int
 589 igbuio_config_intr_mode(char *intr_str)
 590 {
 591         if (!intr_str) {
 592                 pr_info("Use MSIX interrupt by default\n");
 593                 return 0;
 594         }
 595
 596         if (!strcmp(intr_str, RTE_INTR_MODE_MSIX_NAME)) {
 597                 igbuio_intr_mode_preferred = RTE_INTR_MODE_MSIX;
 598                 pr_info("Use MSIX interrupt\n");
 599         } else if (!strcmp(intr_str, RTE_INTR_MODE_MSI_NAME)) {
 600                 igbuio_intr_mode_preferred = RTE_INTR_MODE_MSI;
 601                 pr_info("Use MSI interrupt\n");
 602         } else if (!strcmp(intr_str, RTE_INTR_MODE_LEGACY_NAME)) {
 603                 igbuio_intr_mode_preferred = RTE_INTR_MODE_LEGACY;
 604                 pr_info("Use legacy interrupt\n");
 605         } else {
 606                 pr_info("Error: bad parameter - %s\n", intr_str);
 607                 return -EINVAL;
 608         }
 609
 610         return 0;
 611 }
 612
 613 static struct pci_driver igbuio_pci_driver = {
 614         .name = "igb_uio",
 615         .id_table = NULL,
 616         .probe = igbuio_pci_probe,
 617         .remove = igbuio_pci_remove,
 618 };
 619
 620 static int __init
 621 igbuio_pci_init_module(void)
 622 {
 623         int ret;
 624
 625         ret = igbuio_config_intr_mode(intr_mode);
 626         if (ret < 0)
 627                 return ret;
 628
 629         return pci_register_driver(&igbuio_pci_driver);
 630 }
 631
 632 static void __exit
 633 igbuio_pci_exit_module(void)
 634 {
 635         pci_unregister_driver(&igbuio_pci_driver);
 636 }
 637
 638 module_init(igbuio_pci_init_module);
 639 module_exit(igbuio_pci_exit_module);
 640
 641 module_param(intr_mode, charp, S_IRUGO);
 642 MODULE_PARM_DESC(intr_mode,
 643 "igb_uio interrupt mode (default=msix):\n"
 644 "    " RTE_INTR_MODE_MSIX_NAME "       Use MSIX interrupt\n"
 645 "    " RTE_INTR_MODE_MSI_NAME "        Use MSI interrupt\n"
 646 "    " RTE_INTR_MODE_LEGACY_NAME "     Use Legacy interrupt\n"
 647 "\n");
 648
 649 MODULE_DESCRIPTION("UIO driver for Intel IGB PCI cards");
 650 MODULE_LICENSE("GPL");
 651 MODULE_AUTHOR("Intel Corporation");