Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * driver for the TEWS TPCI-200 device
0004  *
0005  * Copyright (C) 2009-2012 CERN (www.cern.ch)
0006  * Author: Nicolas Serafini, EIC2 SA
0007  * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
0008  */
0009 
0010 #include <linux/module.h>
0011 #include <linux/slab.h>
0012 #include "tpci200.h"
0013 
0014 static const u16 tpci200_status_timeout[] = {
0015     TPCI200_A_TIMEOUT,
0016     TPCI200_B_TIMEOUT,
0017     TPCI200_C_TIMEOUT,
0018     TPCI200_D_TIMEOUT,
0019 };
0020 
0021 static const u16 tpci200_status_error[] = {
0022     TPCI200_A_ERROR,
0023     TPCI200_B_ERROR,
0024     TPCI200_C_ERROR,
0025     TPCI200_D_ERROR,
0026 };
0027 
0028 static const size_t tpci200_space_size[IPACK_SPACE_COUNT] = {
0029     [IPACK_IO_SPACE]    = TPCI200_IO_SPACE_SIZE,
0030     [IPACK_ID_SPACE]    = TPCI200_ID_SPACE_SIZE,
0031     [IPACK_INT_SPACE]   = TPCI200_INT_SPACE_SIZE,
0032     [IPACK_MEM8_SPACE]  = TPCI200_MEM8_SPACE_SIZE,
0033     [IPACK_MEM16_SPACE] = TPCI200_MEM16_SPACE_SIZE,
0034 };
0035 
0036 static const size_t tpci200_space_interval[IPACK_SPACE_COUNT] = {
0037     [IPACK_IO_SPACE]    = TPCI200_IO_SPACE_INTERVAL,
0038     [IPACK_ID_SPACE]    = TPCI200_ID_SPACE_INTERVAL,
0039     [IPACK_INT_SPACE]   = TPCI200_INT_SPACE_INTERVAL,
0040     [IPACK_MEM8_SPACE]  = TPCI200_MEM8_SPACE_INTERVAL,
0041     [IPACK_MEM16_SPACE] = TPCI200_MEM16_SPACE_INTERVAL,
0042 };
0043 
0044 static struct tpci200_board *check_slot(struct ipack_device *dev)
0045 {
0046     struct tpci200_board *tpci200;
0047 
0048     if (dev == NULL)
0049         return NULL;
0050 
0051 
0052     tpci200 = dev_get_drvdata(dev->bus->parent);
0053 
0054     if (tpci200 == NULL) {
0055         dev_info(&dev->dev, "carrier board not found\n");
0056         return NULL;
0057     }
0058 
0059     if (dev->slot >= TPCI200_NB_SLOT) {
0060         dev_info(&dev->dev,
0061              "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
0062              dev->bus->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
0063         return NULL;
0064     }
0065 
0066     return tpci200;
0067 }
0068 
0069 static void tpci200_clear_mask(struct tpci200_board *tpci200,
0070                    __le16 __iomem *addr, u16 mask)
0071 {
0072     unsigned long flags;
0073     spin_lock_irqsave(&tpci200->regs_lock, flags);
0074     iowrite16(ioread16(addr) & (~mask), addr);
0075     spin_unlock_irqrestore(&tpci200->regs_lock, flags);
0076 }
0077 
0078 static void tpci200_set_mask(struct tpci200_board *tpci200,
0079                  __le16 __iomem *addr, u16 mask)
0080 {
0081     unsigned long flags;
0082     spin_lock_irqsave(&tpci200->regs_lock, flags);
0083     iowrite16(ioread16(addr) | mask, addr);
0084     spin_unlock_irqrestore(&tpci200->regs_lock, flags);
0085 }
0086 
0087 static void tpci200_unregister(struct tpci200_board *tpci200)
0088 {
0089     free_irq(tpci200->info->pdev->irq, (void *) tpci200);
0090 
0091     pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
0092 
0093     pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
0094     pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
0095     pci_release_region(tpci200->info->pdev, TPCI200_MEM16_SPACE_BAR);
0096     pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
0097 
0098     pci_disable_device(tpci200->info->pdev);
0099 }
0100 
0101 static void tpci200_enable_irq(struct tpci200_board *tpci200,
0102                    int islot)
0103 {
0104     tpci200_set_mask(tpci200,
0105             &tpci200->info->interface_regs->control[islot],
0106             TPCI200_INT0_EN | TPCI200_INT1_EN);
0107 }
0108 
0109 static void tpci200_disable_irq(struct tpci200_board *tpci200,
0110                 int islot)
0111 {
0112     tpci200_clear_mask(tpci200,
0113             &tpci200->info->interface_regs->control[islot],
0114             TPCI200_INT0_EN | TPCI200_INT1_EN);
0115 }
0116 
0117 static irqreturn_t tpci200_slot_irq(struct slot_irq *slot_irq)
0118 {
0119     irqreturn_t ret;
0120 
0121     if (!slot_irq)
0122         return -ENODEV;
0123     ret = slot_irq->handler(slot_irq->arg);
0124 
0125     return ret;
0126 }
0127 
0128 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
0129 {
0130     struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
0131     struct slot_irq *slot_irq;
0132     irqreturn_t ret;
0133     u16 status_reg;
0134     int i;
0135 
0136     /* Read status register */
0137     status_reg = ioread16(&tpci200->info->interface_regs->status);
0138 
0139     /* Did we cause the interrupt? */
0140     if (!(status_reg & TPCI200_SLOT_INT_MASK))
0141         return IRQ_NONE;
0142 
0143     /* callback to the IRQ handler for the corresponding slot */
0144     rcu_read_lock();
0145     for (i = 0; i < TPCI200_NB_SLOT; i++) {
0146         if (!(status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2 * i))))
0147             continue;
0148         slot_irq = rcu_dereference(tpci200->slots[i].irq);
0149         ret = tpci200_slot_irq(slot_irq);
0150         if (ret == -ENODEV) {
0151             dev_info(&tpci200->info->pdev->dev,
0152                  "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
0153                  tpci200->number, i);
0154             tpci200_disable_irq(tpci200, i);
0155         }
0156     }
0157     rcu_read_unlock();
0158 
0159     return IRQ_HANDLED;
0160 }
0161 
0162 static int tpci200_free_irq(struct ipack_device *dev)
0163 {
0164     struct slot_irq *slot_irq;
0165     struct tpci200_board *tpci200;
0166 
0167     tpci200 = check_slot(dev);
0168     if (tpci200 == NULL)
0169         return -EINVAL;
0170 
0171     if (mutex_lock_interruptible(&tpci200->mutex))
0172         return -ERESTARTSYS;
0173 
0174     if (tpci200->slots[dev->slot].irq == NULL) {
0175         mutex_unlock(&tpci200->mutex);
0176         return -EINVAL;
0177     }
0178 
0179     tpci200_disable_irq(tpci200, dev->slot);
0180     slot_irq = tpci200->slots[dev->slot].irq;
0181     /* uninstall handler */
0182     RCU_INIT_POINTER(tpci200->slots[dev->slot].irq, NULL);
0183     synchronize_rcu();
0184     kfree(slot_irq);
0185     mutex_unlock(&tpci200->mutex);
0186     return 0;
0187 }
0188 
0189 static int tpci200_request_irq(struct ipack_device *dev,
0190                    irqreturn_t (*handler)(void *), void *arg)
0191 {
0192     int res = 0;
0193     struct slot_irq *slot_irq;
0194     struct tpci200_board *tpci200;
0195 
0196     tpci200 = check_slot(dev);
0197     if (tpci200 == NULL)
0198         return -EINVAL;
0199 
0200     if (mutex_lock_interruptible(&tpci200->mutex))
0201         return -ERESTARTSYS;
0202 
0203     if (tpci200->slots[dev->slot].irq != NULL) {
0204         dev_err(&dev->dev,
0205             "Slot [%d:%d] IRQ already registered !\n",
0206             dev->bus->bus_nr,
0207             dev->slot);
0208         res = -EINVAL;
0209         goto out_unlock;
0210     }
0211 
0212     slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
0213     if (slot_irq == NULL) {
0214         dev_err(&dev->dev,
0215             "Slot [%d:%d] unable to allocate memory for IRQ !\n",
0216             dev->bus->bus_nr, dev->slot);
0217         res = -ENOMEM;
0218         goto out_unlock;
0219     }
0220 
0221     /*
0222      * WARNING: Setup Interrupt Vector in the IndustryPack device
0223      * before an IRQ request.
0224      * Read the User Manual of your IndustryPack device to know
0225      * where to write the vector in memory.
0226      */
0227     slot_irq->handler = handler;
0228     slot_irq->arg = arg;
0229     slot_irq->holder = dev;
0230 
0231     rcu_assign_pointer(tpci200->slots[dev->slot].irq, slot_irq);
0232     tpci200_enable_irq(tpci200, dev->slot);
0233 
0234 out_unlock:
0235     mutex_unlock(&tpci200->mutex);
0236     return res;
0237 }
0238 
0239 static int tpci200_register(struct tpci200_board *tpci200)
0240 {
0241     int i;
0242     int res;
0243     phys_addr_t ioidint_base;
0244     unsigned short slot_ctrl;
0245 
0246     if (pci_enable_device(tpci200->info->pdev) < 0)
0247         return -ENODEV;
0248 
0249     /* Request IP interface register (Bar 2) */
0250     res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
0251                  "Carrier IP interface registers");
0252     if (res) {
0253         dev_err(&tpci200->info->pdev->dev,
0254             "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
0255             tpci200->info->pdev->bus->number,
0256             tpci200->info->pdev->devfn);
0257         goto err_disable_device;
0258     }
0259 
0260     /* Request IO ID INT space (Bar 3) */
0261     res = pci_request_region(tpci200->info->pdev,
0262                  TPCI200_IO_ID_INT_SPACES_BAR,
0263                  "Carrier IO ID INT space");
0264     if (res) {
0265         dev_err(&tpci200->info->pdev->dev,
0266             "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
0267             tpci200->info->pdev->bus->number,
0268             tpci200->info->pdev->devfn);
0269         goto err_ip_interface_bar;
0270     }
0271 
0272     /* Request MEM8 space (Bar 5) */
0273     res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
0274                  "Carrier MEM8 space");
0275     if (res) {
0276         dev_err(&tpci200->info->pdev->dev,
0277             "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 5!",
0278             tpci200->info->pdev->bus->number,
0279             tpci200->info->pdev->devfn);
0280         goto err_io_id_int_spaces_bar;
0281     }
0282 
0283     /* Request MEM16 space (Bar 4) */
0284     res = pci_request_region(tpci200->info->pdev, TPCI200_MEM16_SPACE_BAR,
0285                  "Carrier MEM16 space");
0286     if (res) {
0287         dev_err(&tpci200->info->pdev->dev,
0288             "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
0289             tpci200->info->pdev->bus->number,
0290             tpci200->info->pdev->devfn);
0291         goto err_mem8_space_bar;
0292     }
0293 
0294     /* Map internal tpci200 driver user space */
0295     tpci200->info->interface_regs =
0296         ioremap(pci_resource_start(tpci200->info->pdev,
0297                        TPCI200_IP_INTERFACE_BAR),
0298             TPCI200_IFACE_SIZE);
0299     if (!tpci200->info->interface_regs) {
0300         dev_err(&tpci200->info->pdev->dev,
0301             "(bn 0x%X, sn 0x%X) failed to map driver user space!",
0302             tpci200->info->pdev->bus->number,
0303             tpci200->info->pdev->devfn);
0304         res = -ENOMEM;
0305         goto err_mem16_space_bar;
0306     }
0307 
0308     /* Initialize lock that protects interface_regs */
0309     spin_lock_init(&tpci200->regs_lock);
0310 
0311     ioidint_base = pci_resource_start(tpci200->info->pdev,
0312                       TPCI200_IO_ID_INT_SPACES_BAR);
0313     tpci200->mod_mem[IPACK_IO_SPACE] = ioidint_base + TPCI200_IO_SPACE_OFF;
0314     tpci200->mod_mem[IPACK_ID_SPACE] = ioidint_base + TPCI200_ID_SPACE_OFF;
0315     tpci200->mod_mem[IPACK_INT_SPACE] =
0316         ioidint_base + TPCI200_INT_SPACE_OFF;
0317     tpci200->mod_mem[IPACK_MEM8_SPACE] =
0318         pci_resource_start(tpci200->info->pdev,
0319                    TPCI200_MEM8_SPACE_BAR);
0320     tpci200->mod_mem[IPACK_MEM16_SPACE] =
0321         pci_resource_start(tpci200->info->pdev,
0322                    TPCI200_MEM16_SPACE_BAR);
0323 
0324     /* Set the default parameters of the slot
0325      * INT0 disabled, level sensitive
0326      * INT1 disabled, level sensitive
0327      * error interrupt disabled
0328      * timeout interrupt disabled
0329      * recover time disabled
0330      * clock rate 8 MHz
0331      */
0332     slot_ctrl = 0;
0333     for (i = 0; i < TPCI200_NB_SLOT; i++)
0334         writew(slot_ctrl, &tpci200->info->interface_regs->control[i]);
0335 
0336     res = request_irq(tpci200->info->pdev->irq,
0337               tpci200_interrupt, IRQF_SHARED,
0338               KBUILD_MODNAME, (void *) tpci200);
0339     if (res) {
0340         dev_err(&tpci200->info->pdev->dev,
0341             "(bn 0x%X, sn 0x%X) unable to register IRQ !",
0342             tpci200->info->pdev->bus->number,
0343             tpci200->info->pdev->devfn);
0344         goto err_interface_regs;
0345     }
0346 
0347     return 0;
0348 
0349 err_interface_regs:
0350     pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
0351 err_mem16_space_bar:
0352     pci_release_region(tpci200->info->pdev, TPCI200_MEM16_SPACE_BAR);
0353 err_mem8_space_bar:
0354     pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
0355 err_io_id_int_spaces_bar:
0356     pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
0357 err_ip_interface_bar:
0358     pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
0359 err_disable_device:
0360     pci_disable_device(tpci200->info->pdev);
0361     return res;
0362 }
0363 
0364 static int tpci200_get_clockrate(struct ipack_device *dev)
0365 {
0366     struct tpci200_board *tpci200 = check_slot(dev);
0367     __le16 __iomem *addr;
0368 
0369     if (!tpci200)
0370         return -ENODEV;
0371 
0372     addr = &tpci200->info->interface_regs->control[dev->slot];
0373     return (ioread16(addr) & TPCI200_CLK32) ? 32 : 8;
0374 }
0375 
0376 static int tpci200_set_clockrate(struct ipack_device *dev, int mherz)
0377 {
0378     struct tpci200_board *tpci200 = check_slot(dev);
0379     __le16 __iomem *addr;
0380 
0381     if (!tpci200)
0382         return -ENODEV;
0383 
0384     addr = &tpci200->info->interface_regs->control[dev->slot];
0385 
0386     switch (mherz) {
0387     case 8:
0388         tpci200_clear_mask(tpci200, addr, TPCI200_CLK32);
0389         break;
0390     case 32:
0391         tpci200_set_mask(tpci200, addr, TPCI200_CLK32);
0392         break;
0393     default:
0394         return -EINVAL;
0395     }
0396     return 0;
0397 }
0398 
0399 static int tpci200_get_error(struct ipack_device *dev)
0400 {
0401     struct tpci200_board *tpci200 = check_slot(dev);
0402     __le16 __iomem *addr;
0403     u16 mask;
0404 
0405     if (!tpci200)
0406         return -ENODEV;
0407 
0408     addr = &tpci200->info->interface_regs->status;
0409     mask = tpci200_status_error[dev->slot];
0410     return (ioread16(addr) & mask) ? 1 : 0;
0411 }
0412 
0413 static int tpci200_get_timeout(struct ipack_device *dev)
0414 {
0415     struct tpci200_board *tpci200 = check_slot(dev);
0416     __le16 __iomem *addr;
0417     u16 mask;
0418 
0419     if (!tpci200)
0420         return -ENODEV;
0421 
0422     addr = &tpci200->info->interface_regs->status;
0423     mask = tpci200_status_timeout[dev->slot];
0424 
0425     return (ioread16(addr) & mask) ? 1 : 0;
0426 }
0427 
0428 static int tpci200_reset_timeout(struct ipack_device *dev)
0429 {
0430     struct tpci200_board *tpci200 = check_slot(dev);
0431     __le16 __iomem *addr;
0432     u16 mask;
0433 
0434     if (!tpci200)
0435         return -ENODEV;
0436 
0437     addr = &tpci200->info->interface_regs->status;
0438     mask = tpci200_status_timeout[dev->slot];
0439 
0440     iowrite16(mask, addr);
0441     return 0;
0442 }
0443 
0444 static void tpci200_uninstall(struct tpci200_board *tpci200)
0445 {
0446     tpci200_unregister(tpci200);
0447     kfree(tpci200->slots);
0448 }
0449 
0450 static const struct ipack_bus_ops tpci200_bus_ops = {
0451     .request_irq = tpci200_request_irq,
0452     .free_irq = tpci200_free_irq,
0453     .get_clockrate = tpci200_get_clockrate,
0454     .set_clockrate = tpci200_set_clockrate,
0455     .get_error     = tpci200_get_error,
0456     .get_timeout   = tpci200_get_timeout,
0457     .reset_timeout = tpci200_reset_timeout,
0458 };
0459 
0460 static int tpci200_install(struct tpci200_board *tpci200)
0461 {
0462     int res;
0463 
0464     tpci200->slots = kcalloc(TPCI200_NB_SLOT, sizeof(struct tpci200_slot),
0465                  GFP_KERNEL);
0466     if (tpci200->slots == NULL)
0467         return -ENOMEM;
0468 
0469     res = tpci200_register(tpci200);
0470     if (res) {
0471         kfree(tpci200->slots);
0472         tpci200->slots = NULL;
0473         return res;
0474     }
0475 
0476     mutex_init(&tpci200->mutex);
0477     return 0;
0478 }
0479 
0480 static void tpci200_release_device(struct ipack_device *dev)
0481 {
0482     kfree(dev);
0483 }
0484 
0485 static int tpci200_create_device(struct tpci200_board *tpci200, int i)
0486 {
0487     int ret;
0488     enum ipack_space space;
0489     struct ipack_device *dev =
0490         kzalloc(sizeof(struct ipack_device), GFP_KERNEL);
0491     if (!dev)
0492         return -ENOMEM;
0493     dev->slot = i;
0494     dev->bus = tpci200->info->ipack_bus;
0495     dev->release = tpci200_release_device;
0496 
0497     for (space = 0; space < IPACK_SPACE_COUNT; space++) {
0498         dev->region[space].start =
0499             tpci200->mod_mem[space]
0500             + tpci200_space_interval[space] * i;
0501         dev->region[space].size = tpci200_space_size[space];
0502     }
0503 
0504     ret = ipack_device_init(dev);
0505     if (ret < 0) {
0506         ipack_put_device(dev);
0507         return ret;
0508     }
0509 
0510     ret = ipack_device_add(dev);
0511     if (ret < 0)
0512         ipack_put_device(dev);
0513 
0514     return ret;
0515 }
0516 
0517 static int tpci200_pci_probe(struct pci_dev *pdev,
0518                  const struct pci_device_id *id)
0519 {
0520     int ret, i;
0521     struct tpci200_board *tpci200;
0522     u32 reg32;
0523 
0524     tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
0525     if (!tpci200)
0526         return -ENOMEM;
0527 
0528     tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
0529     if (!tpci200->info) {
0530         ret = -ENOMEM;
0531         goto err_tpci200;
0532     }
0533 
0534     pci_dev_get(pdev);
0535 
0536     /* Obtain a mapping of the carrier's PCI configuration registers */
0537     ret = pci_request_region(pdev, TPCI200_CFG_MEM_BAR,
0538                  KBUILD_MODNAME " Configuration Memory");
0539     if (ret) {
0540         dev_err(&pdev->dev, "Failed to allocate PCI Configuration Memory");
0541         ret = -EBUSY;
0542         goto err_tpci200_info;
0543     }
0544     tpci200->info->cfg_regs = ioremap(
0545             pci_resource_start(pdev, TPCI200_CFG_MEM_BAR),
0546             pci_resource_len(pdev, TPCI200_CFG_MEM_BAR));
0547     if (!tpci200->info->cfg_regs) {
0548         dev_err(&pdev->dev, "Failed to map PCI Configuration Memory");
0549         ret = -EFAULT;
0550         goto err_request_region;
0551     }
0552 
0553     /* Disable byte swapping for 16 bit IP module access. This will ensure
0554      * that the Industrypack big endian byte order is preserved by the
0555      * carrier. */
0556     reg32 = ioread32(tpci200->info->cfg_regs + LAS1_DESC);
0557     reg32 |= 1 << LAS_BIT_BIGENDIAN;
0558     iowrite32(reg32, tpci200->info->cfg_regs + LAS1_DESC);
0559 
0560     reg32 = ioread32(tpci200->info->cfg_regs + LAS2_DESC);
0561     reg32 |= 1 << LAS_BIT_BIGENDIAN;
0562     iowrite32(reg32, tpci200->info->cfg_regs + LAS2_DESC);
0563 
0564     /* Save struct pci_dev pointer */
0565     tpci200->info->pdev = pdev;
0566     tpci200->info->id_table = (struct pci_device_id *)id;
0567 
0568     /* register the device and initialize it */
0569     ret = tpci200_install(tpci200);
0570     if (ret) {
0571         dev_err(&pdev->dev, "error during tpci200 install\n");
0572         ret = -ENODEV;
0573         goto err_cfg_regs;
0574     }
0575 
0576     /* Register the carrier in the industry pack bus driver */
0577     tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
0578                               TPCI200_NB_SLOT,
0579                               &tpci200_bus_ops,
0580                               THIS_MODULE);
0581     if (!tpci200->info->ipack_bus) {
0582         dev_err(&pdev->dev,
0583             "error registering the carrier on ipack driver\n");
0584         ret = -EFAULT;
0585         goto err_tpci200_install;
0586     }
0587 
0588     /* save the bus number given by ipack to logging purpose */
0589     tpci200->number = tpci200->info->ipack_bus->bus_nr;
0590     dev_set_drvdata(&pdev->dev, tpci200);
0591 
0592     for (i = 0; i < TPCI200_NB_SLOT; i++)
0593         tpci200_create_device(tpci200, i);
0594     return 0;
0595 
0596 err_tpci200_install:
0597     tpci200_uninstall(tpci200);
0598 err_cfg_regs:
0599     pci_iounmap(tpci200->info->pdev, tpci200->info->cfg_regs);
0600 err_request_region:
0601     pci_release_region(pdev, TPCI200_CFG_MEM_BAR);
0602 err_tpci200_info:
0603     kfree(tpci200->info);
0604     pci_dev_put(pdev);
0605 err_tpci200:
0606     kfree(tpci200);
0607     return ret;
0608 }
0609 
0610 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
0611 {
0612     ipack_bus_unregister(tpci200->info->ipack_bus);
0613     tpci200_uninstall(tpci200);
0614 
0615     pci_iounmap(tpci200->info->pdev, tpci200->info->cfg_regs);
0616 
0617     pci_release_region(tpci200->info->pdev, TPCI200_CFG_MEM_BAR);
0618 
0619     pci_dev_put(tpci200->info->pdev);
0620 
0621     kfree(tpci200->info);
0622     kfree(tpci200);
0623 }
0624 
0625 static void tpci200_pci_remove(struct pci_dev *dev)
0626 {
0627     struct tpci200_board *tpci200 = pci_get_drvdata(dev);
0628 
0629     __tpci200_pci_remove(tpci200);
0630 }
0631 
0632 static const struct pci_device_id tpci200_idtable[] = {
0633     { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
0634       TPCI200_SUBDEVICE_ID },
0635     { 0, },
0636 };
0637 
0638 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
0639 
0640 static struct pci_driver tpci200_pci_drv = {
0641     .name = "tpci200",
0642     .id_table = tpci200_idtable,
0643     .probe = tpci200_pci_probe,
0644     .remove = tpci200_pci_remove,
0645 };
0646 
0647 module_pci_driver(tpci200_pci_drv);
0648 
0649 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
0650 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!