drivers/uio/uio_netx.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * UIO driver for Hilscher NetX based fieldbus cards (cifX, comX).
0004  * See http://www.hilscher.com for details.
0005  *
0006  * (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
0007  * (C) 2008 Manuel Traut <manut@linutronix.de>
0008  *
0009  */
0010
0011 #include <linux/device.h>
0012 #include <linux/io.h>
0013 #include <linux/module.h>
0014 #include <linux/pci.h>
0015 #include <linux/slab.h>
0016 #include <linux/uio_driver.h>
0017
0018 #define PCI_VENDOR_ID_HILSCHER      0x15CF
0019 #define PCI_DEVICE_ID_HILSCHER_NETX 0x0000
0020 #define PCI_DEVICE_ID_HILSCHER_NETPLC   0x0010
0021 #define PCI_SUBDEVICE_ID_NETPLC_RAM 0x0000
0022 #define PCI_SUBDEVICE_ID_NETPLC_FLASH   0x0001
0023 #define PCI_SUBDEVICE_ID_NXSB_PCA   0x3235
0024 #define PCI_SUBDEVICE_ID_NXPCA      0x3335
0025
0026 #define DPM_HOST_INT_EN0    0xfff0
0027 #define DPM_HOST_INT_STAT0  0xffe0
0028
0029 #define DPM_HOST_INT_MASK   0xe600ffff
0030 #define DPM_HOST_INT_GLOBAL_EN  0x80000000
0031
0032 static irqreturn_t netx_handler(int irq, struct uio_info *dev_info)
0033 {
0034     void __iomem *int_enable_reg = dev_info->mem[0].internal_addr
0035                     + DPM_HOST_INT_EN0;
0036     void __iomem *int_status_reg = dev_info->mem[0].internal_addr
0037                     + DPM_HOST_INT_STAT0;
0038
0039     /* Is one of our interrupts enabled and active ? */
0040     if (!(ioread32(int_enable_reg) & ioread32(int_status_reg)
0041         & DPM_HOST_INT_MASK))
0042         return IRQ_NONE;
0043
0044     /* Disable interrupt */
0045     iowrite32(ioread32(int_enable_reg) & ~DPM_HOST_INT_GLOBAL_EN,
0046         int_enable_reg);
0047     return IRQ_HANDLED;
0048 }
0049
0050 static int netx_pci_probe(struct pci_dev *dev,
0051                     const struct pci_device_id *id)
0052 {
0053     struct uio_info *info;
0054     int bar;
0055
0056     info = devm_kzalloc(&dev->dev, sizeof(struct uio_info), GFP_KERNEL);
0057     if (!info)
0058         return -ENOMEM;
0059
0060     if (pci_enable_device(dev))
0061         return -ENODEV;
0062
0063     if (pci_request_regions(dev, "netx"))
0064         goto out_disable;
0065
0066     switch (id->device) {
0067     case PCI_DEVICE_ID_HILSCHER_NETX:
0068         bar = 0;
0069         info->name = "netx";
0070         break;
0071     case PCI_DEVICE_ID_HILSCHER_NETPLC:
0072         bar = 0;
0073         info->name = "netplc";
0074         break;
0075     default:
0076         bar = 2;
0077         info->name = "netx_plx";
0078     }
0079
0080     /* BAR0 or 2 points to the card's dual port memory */
0081     info->mem[0].addr = pci_resource_start(dev, bar);
0082     if (!info->mem[0].addr)
0083         goto out_release;
0084     info->mem[0].internal_addr = ioremap(pci_resource_start(dev, bar),
0085                         pci_resource_len(dev, bar));
0086
0087     if (!info->mem[0].internal_addr)
0088             goto out_release;
0089
0090     info->mem[0].size = pci_resource_len(dev, bar);
0091     info->mem[0].memtype = UIO_MEM_PHYS;
0092     info->irq = dev->irq;
0093     info->irq_flags = IRQF_SHARED;
0094     info->handler = netx_handler;
0095     info->version = "0.0.1";
0096
0097     /* Make sure all interrupts are disabled */
0098     iowrite32(0, info->mem[0].internal_addr + DPM_HOST_INT_EN0);
0099
0100     if (uio_register_device(&dev->dev, info))
0101         goto out_unmap;
0102
0103     pci_set_drvdata(dev, info);
0104     dev_info(&dev->dev, "Found %s card, registered UIO device.\n",
0105                 info->name);
0106
0107     return 0;
0108
0109 out_unmap:
0110     iounmap(info->mem[0].internal_addr);
0111 out_release:
0112     pci_release_regions(dev);
0113 out_disable:
0114     pci_disable_device(dev);
0115     return -ENODEV;
0116 }
0117
0118 static void netx_pci_remove(struct pci_dev *dev)
0119 {
0120     struct uio_info *info = pci_get_drvdata(dev);
0121
0122     /* Disable all interrupts */
0123     iowrite32(0, info->mem[0].internal_addr + DPM_HOST_INT_EN0);
0124     uio_unregister_device(info);
0125     pci_release_regions(dev);
0126     pci_disable_device(dev);
0127     iounmap(info->mem[0].internal_addr);
0128 }
0129
0130 static struct pci_device_id netx_pci_ids[] = {
0131     {
0132         .vendor =   PCI_VENDOR_ID_HILSCHER,
0133         .device =   PCI_DEVICE_ID_HILSCHER_NETX,
0134         .subvendor =    0,
0135         .subdevice =    0,
0136     },
0137     {
0138         .vendor =       PCI_VENDOR_ID_HILSCHER,
0139         .device =       PCI_DEVICE_ID_HILSCHER_NETPLC,
0140         .subvendor =    PCI_VENDOR_ID_HILSCHER,
0141         .subdevice =    PCI_SUBDEVICE_ID_NETPLC_RAM,
0142     },
0143     {
0144         .vendor =       PCI_VENDOR_ID_HILSCHER,
0145         .device =       PCI_DEVICE_ID_HILSCHER_NETPLC,
0146         .subvendor =    PCI_VENDOR_ID_HILSCHER,
0147         .subdevice =    PCI_SUBDEVICE_ID_NETPLC_FLASH,
0148     },
0149     {
0150         .vendor =   PCI_VENDOR_ID_PLX,
0151         .device =   PCI_DEVICE_ID_PLX_9030,
0152         .subvendor =    PCI_VENDOR_ID_PLX,
0153         .subdevice =    PCI_SUBDEVICE_ID_NXSB_PCA,
0154     },
0155     {
0156         .vendor =   PCI_VENDOR_ID_PLX,
0157         .device =   PCI_DEVICE_ID_PLX_9030,
0158         .subvendor =    PCI_VENDOR_ID_PLX,
0159         .subdevice =    PCI_SUBDEVICE_ID_NXPCA,
0160     },
0161     { 0, }
0162 };
0163
0164 static struct pci_driver netx_pci_driver = {
0165     .name = "netx",
0166     .id_table = netx_pci_ids,
0167     .probe = netx_pci_probe,
0168     .remove = netx_pci_remove,
0169 };
0170
0171 module_pci_driver(netx_pci_driver);
0172 MODULE_DEVICE_TABLE(pci, netx_pci_ids);
0173 MODULE_LICENSE("GPL v2");
0174 MODULE_AUTHOR("Hans J. Koch, Manuel Traut");