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 };
  49
  50 static char *intr_mode;
  51 static enum rte_intr_mode igbuio_intr_mode_preferred = RTE_INTR_MODE_MSIX;
  52
  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, struct uio_info *info)
 212 {
 213         struct rte_uio_pci_dev *udev = info->priv;
 214
 215         /* Legacy mode need to mask in hardware */
 216         if (udev->mode == RTE_INTR_MODE_LEGACY &&
 217             !pci_check_and_mask_intx(udev->pdev))
 218                 return IRQ_NONE;
 219
 220         /* Message signal mode, no share IRQ and automasked */
 221         return IRQ_HANDLED;
 222 }
 223
 224 /**
 225  * This gets called while opening uio device file.
 226  */
 227 static int
 228 igbuio_pci_open(struct uio_info *info, struct inode *inode)
 229 {
 230         struct rte_uio_pci_dev *udev = info->priv;
 231         struct pci_dev *dev = udev->pdev;
 232
 233         pci_reset_function(dev);
 234
 235         /* set bus master, which was cleared by the reset function */
 236         pci_set_master(dev);
 237
 238         return 0;
 239 }
 240
 241 static int
 242 igbuio_pci_release(struct uio_info *info, struct inode *inode)
 243 {
 244         struct rte_uio_pci_dev *udev = info->priv;
 245         struct pci_dev *dev = udev->pdev;
 246
 247         /* stop the device from further DMA */
 248         pci_clear_master(dev);
 249
 250         pci_reset_function(dev);
 251
 252         return 0;
 253 }
 254
 255 /* Remap pci resources described by bar #pci_bar in uio resource n. */
 256 static int
 257 igbuio_pci_setup_iomem(struct pci_dev *dev, struct uio_info *info,
 258                        int n, int pci_bar, const char *name)
 259 {
 260         unsigned long addr, len;
 261         void *internal_addr;
 262
 263         if (n >= ARRAY_SIZE(info->mem))
 264                 return -EINVAL;
 265
 266         addr = pci_resource_start(dev, pci_bar);
 267         len = pci_resource_len(dev, pci_bar);
 268         if (addr == 0 || len == 0)
 269                 return -1;
 270         internal_addr = ioremap(addr, len);
 271         if (internal_addr == NULL)
 272                 return -1;
 273         info->mem[n].name = name;
 274         info->mem[n].addr = addr;
 275         info->mem[n].internal_addr = internal_addr;
 276         info->mem[n].size = len;
 277         info->mem[n].memtype = UIO_MEM_PHYS;
 278         return 0;
 279 }
 280
 281 /* Get pci port io resources described by bar #pci_bar in uio resource n. */
 282 static int
 283 igbuio_pci_setup_ioport(struct pci_dev *dev, struct uio_info *info,
 284                 int n, int pci_bar, const char *name)
 285 {
 286         unsigned long addr, len;
 287
 288         if (n >= ARRAY_SIZE(info->port))
 289                 return -EINVAL;
 290
 291         addr = pci_resource_start(dev, pci_bar);
 292         len = pci_resource_len(dev, pci_bar);
 293         if (addr == 0 || len == 0)
 294                 return -EINVAL;
 295
 296         info->port[n].name = name;
 297         info->port[n].start = addr;
 298         info->port[n].size = len;
 299         info->port[n].porttype = UIO_PORT_X86;
 300
 301         return 0;
 302 }
 303
 304 /* Unmap previously ioremap'd resources */
 305 static void
 306 igbuio_pci_release_iomem(struct uio_info *info)
 307 {
 308         int i;
 309
 310         for (i = 0; i < MAX_UIO_MAPS; i++) {
 311                 if (info->mem[i].internal_addr)
 312                         iounmap(info->mem[i].internal_addr);
 313         }
 314 }
 315
 316 static int
 317 igbuio_pci_enable_interrupts(struct rte_uio_pci_dev *udev)
 318 {
 319         int err = 0;
 320 #ifndef HAVE_ALLOC_IRQ_VECTORS
 321         struct msix_entry msix_entry;
 322 #endif
 323
 324         switch (igbuio_intr_mode_preferred) {
 325         case RTE_INTR_MODE_MSIX:
 326                 /* Only 1 msi-x vector needed */
 327 #ifndef HAVE_ALLOC_IRQ_VECTORS
 328                 msix_entry.entry = 0;
 329                 if (pci_enable_msix(udev->pdev, &msix_entry, 1) == 0) {
 330                         dev_dbg(&udev->pdev->dev, "using MSI-X");
 331                         udev->info.irq_flags = IRQF_NO_THREAD;
 332                         udev->info.irq = msix_entry.vector;
 333                         udev->mode = RTE_INTR_MODE_MSIX;
 334                         break;
 335                 }
 336 #else
 337                 if (pci_alloc_irq_vectors(udev->pdev, 1, 1, PCI_IRQ_MSIX) == 1) {
 338                         dev_dbg(&udev->pdev->dev, "using MSI-X");
 339                         udev->info.irq_flags = IRQF_NO_THREAD;
 340                         udev->info.irq = pci_irq_vector(udev->pdev, 0);
 341                         udev->mode = RTE_INTR_MODE_MSIX;
 342                         break;
 343                 }
 344 #endif
 345         /* fall back to MSI */
 346         case RTE_INTR_MODE_MSI:
 347 #ifndef HAVE_ALLOC_IRQ_VECTORS
 348                 if (pci_enable_msi(udev->pdev) == 0) {
 349                         dev_dbg(&udev->pdev->dev, "using MSI");
 350                         udev->info.irq_flags = IRQF_NO_THREAD;
 351                         udev->info.irq = udev->pdev->irq;
 352                         udev->mode = RTE_INTR_MODE_MSI;
 353                         break;
 354                 }
 355 #else
 356                 if (pci_alloc_irq_vectors(udev->pdev, 1, 1, PCI_IRQ_MSI) == 1) {
 357                         dev_dbg(&udev->pdev->dev, "using MSI");
 358                         udev->info.irq_flags = IRQF_NO_THREAD;
 359                         udev->info.irq = pci_irq_vector(udev->pdev, 0);
 360                         udev->mode = RTE_INTR_MODE_MSI;
 361                         break;
 362                 }
 363 #endif
 364         /* fall back to INTX */
 365         case RTE_INTR_MODE_LEGACY:
 366                 if (pci_intx_mask_supported(udev->pdev)) {
 367                         dev_dbg(&udev->pdev->dev, "using INTX");
 368                         udev->info.irq_flags = IRQF_SHARED | IRQF_NO_THREAD;
 369                         udev->info.irq = udev->pdev->irq;
 370                         udev->mode = RTE_INTR_MODE_LEGACY;
 371                         break;
 372                 }
 373                 dev_notice(&udev->pdev->dev, "PCI INTX mask not supported\n");
 374         /* fall back to no IRQ */
 375         case RTE_INTR_MODE_NONE:
 376                 udev->mode = RTE_INTR_MODE_NONE;
 377                 udev->info.irq = UIO_IRQ_NONE;
 378                 break;
 379
 380         default:
 381                 dev_err(&udev->pdev->dev, "invalid IRQ mode %u",
 382                         igbuio_intr_mode_preferred);
 383                 err = -EINVAL;
 384         }
 385
 386         return err;
 387 }
 388
 389 static void
 390 igbuio_pci_disable_interrupts(struct rte_uio_pci_dev *udev)
 391 {
 392 #ifndef HAVE_ALLOC_IRQ_VECTORS
 393         if (udev->mode == RTE_INTR_MODE_MSIX)
 394                 pci_disable_msix(udev->pdev);
 395         if (udev->mode == RTE_INTR_MODE_MSI)
 396                 pci_disable_msi(udev->pdev);
 397 #else
 398         if (udev->mode == RTE_INTR_MODE_MSIX ||
 399             udev->mode == RTE_INTR_MODE_MSI)
 400                 pci_free_irq_vectors(udev->pdev);
 401 #endif
 402 }
 403
 404 static int
 405 igbuio_setup_bars(struct pci_dev *dev, struct uio_info *info)
 406 {
 407         int i, iom, iop, ret;
 408         unsigned long flags;
 409         static const char *bar_names[PCI_STD_RESOURCE_END + 1]  = {
 410                 "BAR0",
 411                 "BAR1",
 412                 "BAR2",
 413                 "BAR3",
 414                 "BAR4",
 415                 "BAR5",
 416         };
 417
 418         iom = 0;
 419         iop = 0;
 420
 421         for (i = 0; i < ARRAY_SIZE(bar_names); i++) {
 422                 if (pci_resource_len(dev, i) != 0 &&
 423                                 pci_resource_start(dev, i) != 0) {
 424                         flags = pci_resource_flags(dev, i);
 425                         if (flags & IORESOURCE_MEM) {
 426                                 ret = igbuio_pci_setup_iomem(dev, info, iom,
 427                                                              i, bar_names[i]);
 428                                 if (ret != 0)
 429                                         return ret;
 430                                 iom++;
 431                         } else if (flags & IORESOURCE_IO) {
 432                                 ret = igbuio_pci_setup_ioport(dev, info, iop,
 433                                                               i, bar_names[i]);
 434                                 if (ret != 0)
 435                                         return ret;
 436                                 iop++;
 437                         }
 438                 }
 439         }
 440
 441         return (iom != 0 || iop != 0) ? ret : -ENOENT;
 442 }
 443
 444 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 8, 0)
 445 static int __devinit
 446 #else
 447 static int
 448 #endif
 449 igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 450 {
 451         struct rte_uio_pci_dev *udev;
 452         dma_addr_t map_dma_addr;
 453         void *map_addr;
 454         int err;
 455
 456         udev = kzalloc(sizeof(struct rte_uio_pci_dev), GFP_KERNEL);
 457         if (!udev)
 458                 return -ENOMEM;
 459
 460         /*
 461          * enable device: ask low-level code to enable I/O and
 462          * memory
 463          */
 464         err = pci_enable_device(dev);
 465         if (err != 0) {
 466                 dev_err(&dev->dev, "Cannot enable PCI device\n");
 467                 goto fail_free;
 468         }
 469
 470         /* enable bus mastering on the device */
 471         pci_set_master(dev);
 472
 473         /* remap IO memory */
 474         err = igbuio_setup_bars(dev, &udev->info);
 475         if (err != 0)
 476                 goto fail_release_iomem;
 477
 478         /* set 64-bit DMA mask */
 479         err = pci_set_dma_mask(dev,  DMA_BIT_MASK(64));
 480         if (err != 0) {
 481                 dev_err(&dev->dev, "Cannot set DMA mask\n");
 482                 goto fail_release_iomem;
 483         }
 484
 485         err = pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64));
 486         if (err != 0) {
 487                 dev_err(&dev->dev, "Cannot set consistent DMA mask\n");
 488                 goto fail_release_iomem;
 489         }
 490
 491         /* fill uio infos */
 492         udev->info.name = "igb_uio";
 493         udev->info.version = "0.1";
 494         udev->info.handler = igbuio_pci_irqhandler;
 495         udev->info.irqcontrol = igbuio_pci_irqcontrol;
 496         udev->info.open = igbuio_pci_open;
 497         udev->info.release = igbuio_pci_release;
 498         udev->info.priv = udev;
 499         udev->pdev = dev;
 500
 501         err = igbuio_pci_enable_interrupts(udev);
 502         if (err != 0)
 503                 goto fail_release_iomem;
 504
 505         err = sysfs_create_group(&dev->dev.kobj, &dev_attr_grp);
 506         if (err != 0)
 507                 goto fail_disable_interrupts;
 508
 509         /* register uio driver */
 510         err = uio_register_device(&dev->dev, &udev->info);
 511         if (err != 0)
 512                 goto fail_remove_group;
 513
 514         pci_set_drvdata(dev, udev);
 515
 516         dev_info(&dev->dev, "uio device registered with irq %lx\n",
 517                  udev->info.irq);
 518
 519         /*
 520          * Doing a harmless dma mapping for attaching the device to
 521          * the iommu identity mapping if kernel boots with iommu=pt.
 522          * Note this is not a problem if no IOMMU at all.
 523          */
 524         map_addr = dma_alloc_coherent(&dev->dev, 1024, &map_dma_addr,
 525                         GFP_KERNEL);
 526         if (map_addr)
 527                 memset(map_addr, 0, 1024);
 528
 529         if (!map_addr)
 530                 dev_info(&dev->dev, "dma mapping failed\n");
 531         else {
 532                 dev_info(&dev->dev, "mapping 1K dma=%#llx host=%p\n",
 533                          (unsigned long long)map_dma_addr, map_addr);
 534
 535                 dma_free_coherent(&dev->dev, 1024, map_addr, map_dma_addr);
 536                 dev_info(&dev->dev, "unmapping 1K dma=%#llx host=%p\n",
 537                          (unsigned long long)map_dma_addr, map_addr);
 538         }
 539
 540         return 0;
 541
 542 fail_remove_group:
 543         sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 544 fail_disable_interrupts:
 545         igbuio_pci_disable_interrupts(udev);
 546 fail_release_iomem:
 547         igbuio_pci_release_iomem(&udev->info);
 548         pci_disable_device(dev);
 549 fail_free:
 550         kfree(udev);
 551
 552         return err;
 553 }
 554
 555 static void
 556 igbuio_pci_remove(struct pci_dev *dev)
 557 {
 558         struct rte_uio_pci_dev *udev = pci_get_drvdata(dev);
 559
 560         sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 561         uio_unregister_device(&udev->info);
 562         igbuio_pci_disable_interrupts(udev);
 563         igbuio_pci_release_iomem(&udev->info);
 564         pci_disable_device(dev);
 565         pci_set_drvdata(dev, NULL);
 566         kfree(udev);
 567 }
 568
 569 static int
 570 igbuio_config_intr_mode(char *intr_str)
 571 {
 572         if (!intr_str) {
 573                 pr_info("Use MSIX interrupt by default\n");
 574                 return 0;
 575         }
 576
 577         if (!strcmp(intr_str, RTE_INTR_MODE_MSIX_NAME)) {
 578                 igbuio_intr_mode_preferred = RTE_INTR_MODE_MSIX;
 579                 pr_info("Use MSIX interrupt\n");
 580         } else if (!strcmp(intr_str, RTE_INTR_MODE_MSI_NAME)) {
 581                 igbuio_intr_mode_preferred = RTE_INTR_MODE_MSI;
 582                 pr_info("Use MSI interrupt\n");
 583         } else if (!strcmp(intr_str, RTE_INTR_MODE_LEGACY_NAME)) {
 584                 igbuio_intr_mode_preferred = RTE_INTR_MODE_LEGACY;
 585                 pr_info("Use legacy interrupt\n");
 586         } else {
 587                 pr_info("Error: bad parameter - %s\n", intr_str);
 588                 return -EINVAL;
 589         }
 590
 591         return 0;
 592 }
 593
 594 static struct pci_driver igbuio_pci_driver = {
 595         .name = "igb_uio",
 596         .id_table = NULL,
 597         .probe = igbuio_pci_probe,
 598         .remove = igbuio_pci_remove,
 599 };
 600
 601 static int __init
 602 igbuio_pci_init_module(void)
 603 {
 604         int ret;
 605
 606         ret = igbuio_config_intr_mode(intr_mode);
 607         if (ret < 0)
 608                 return ret;
 609
 610         return pci_register_driver(&igbuio_pci_driver);
 611 }
 612
 613 static void __exit
 614 igbuio_pci_exit_module(void)
 615 {
 616         pci_unregister_driver(&igbuio_pci_driver);
 617 }
 618
 619 module_init(igbuio_pci_init_module);
 620 module_exit(igbuio_pci_exit_module);
 621
 622 module_param(intr_mode, charp, S_IRUGO);
 623 MODULE_PARM_DESC(intr_mode,
 624 "igb_uio interrupt mode (default=msix):\n"
 625 "    " RTE_INTR_MODE_MSIX_NAME "       Use MSIX interrupt\n"
 626 "    " RTE_INTR_MODE_MSI_NAME "        Use MSI interrupt\n"
 627 "    " RTE_INTR_MODE_LEGACY_NAME "     Use Legacy interrupt\n"
 628 "\n");
 629
 630 MODULE_DESCRIPTION("UIO driver for Intel IGB PCI cards");
 631 MODULE_LICENSE("GPL");
 632 MODULE_AUTHOR("Intel Corporation");