4 * driver for the TEWS TPCI-200 device
5 * Copyright (c) 2009 Nicolas Serafini, EIC2 SA
6 * Copyright (c) 2010,2011 Samuel Iglesias Gonsalvez <siglesia@cern.ch>, CERN
7 * Copyright (c) 2012 Samuel Iglesias Gonsalvez <siglesias@igalia.com>, Igalia
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; version 2 of the License.
14 #include <linux/module.h>
15 #include <linux/slab.h>
18 static u16 tpci200_status_timeout[] = {
25 static u16 tpci200_status_error[] = {
32 static struct tpci200_board *check_slot(struct ipack_device *dev)
34 struct tpci200_board *tpci200;
40 tpci200 = dev_get_drvdata(dev->bus->parent);
42 if (tpci200 == NULL) {
43 dev_info(&dev->dev, "carrier board not found\n");
47 if (dev->slot >= TPCI200_NB_SLOT) {
49 "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
50 dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
57 static void tpci200_clear_mask(struct tpci200_board *tpci200,
58 __le16 __iomem *addr, u16 mask)
61 spin_lock_irqsave(&tpci200->regs_lock, flags);
62 iowrite16(ioread16(addr) & (~mask), addr);
63 spin_unlock_irqrestore(&tpci200->regs_lock, flags);
66 static void tpci200_set_mask(struct tpci200_board *tpci200,
67 __le16 __iomem *addr, u16 mask)
70 spin_lock_irqsave(&tpci200->regs_lock, flags);
71 iowrite16(ioread16(addr) | mask, addr);
72 spin_unlock_irqrestore(&tpci200->regs_lock, flags);
75 static void tpci200_unregister(struct tpci200_board *tpci200)
79 free_irq(tpci200->info->pdev->irq, (void *) tpci200);
81 pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
82 pci_iounmap(tpci200->info->pdev, tpci200->info->ioidint_space);
83 pci_iounmap(tpci200->info->pdev, tpci200->info->mem8_space);
84 pci_iounmap(tpci200->info->pdev, tpci200->info->cfg_regs);
86 pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
87 pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
88 pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
89 pci_release_region(tpci200->info->pdev, TPCI200_CFG_MEM_BAR);
91 pci_disable_device(tpci200->info->pdev);
92 pci_dev_put(tpci200->info->pdev);
94 for (i = 0; i < TPCI200_NB_SLOT; i++) {
95 tpci200->slots[i].io_phys.address = NULL;
96 tpci200->slots[i].io_phys.size = 0;
97 tpci200->slots[i].id_phys.address = NULL;
98 tpci200->slots[i].id_phys.size = 0;
99 tpci200->slots[i].int_phys.address = NULL;
100 tpci200->slots[i].int_phys.size = 0;
101 tpci200->slots[i].mem_phys.address = NULL;
102 tpci200->slots[i].mem_phys.size = 0;
106 static void tpci200_enable_irq(struct tpci200_board *tpci200,
109 tpci200_set_mask(tpci200,
110 &tpci200->info->interface_regs->control[islot],
111 TPCI200_INT0_EN | TPCI200_INT1_EN);
114 static void tpci200_disable_irq(struct tpci200_board *tpci200,
117 tpci200_clear_mask(tpci200,
118 &tpci200->info->interface_regs->control[islot],
119 TPCI200_INT0_EN | TPCI200_INT1_EN);
122 static irqreturn_t tpci200_slot_irq(struct slot_irq *slot_irq)
128 ret = slot_irq->handler(slot_irq->arg);
133 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
135 struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
136 struct slot_irq *slot_irq;
141 /* Read status register */
142 status_reg = ioread16(&tpci200->info->interface_regs->status);
144 /* Did we cause the interrupt? */
145 if (!(status_reg & TPCI200_SLOT_INT_MASK))
148 /* callback to the IRQ handler for the corresponding slot */
150 for (i = 0; i < TPCI200_NB_SLOT; i++) {
151 if (!(status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2 * i))))
153 slot_irq = rcu_dereference(tpci200->slots[i].irq);
154 ret = tpci200_slot_irq(slot_irq);
155 if (ret == -ENODEV) {
156 dev_info(&tpci200->info->pdev->dev,
157 "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
159 tpci200_disable_irq(tpci200, i);
167 static int tpci200_free_irq(struct ipack_device *dev)
169 struct slot_irq *slot_irq;
170 struct tpci200_board *tpci200;
172 tpci200 = check_slot(dev);
176 if (mutex_lock_interruptible(&tpci200->mutex))
179 if (tpci200->slots[dev->slot].irq == NULL) {
180 mutex_unlock(&tpci200->mutex);
184 tpci200_disable_irq(tpci200, dev->slot);
185 slot_irq = tpci200->slots[dev->slot].irq;
186 /* uninstall handler */
187 RCU_INIT_POINTER(tpci200->slots[dev->slot].irq, NULL);
190 mutex_unlock(&tpci200->mutex);
194 static int tpci200_request_irq(struct ipack_device *dev,
195 irqreturn_t (*handler)(void *), void *arg)
198 struct slot_irq *slot_irq;
199 struct tpci200_board *tpci200;
201 tpci200 = check_slot(dev);
205 if (mutex_lock_interruptible(&tpci200->mutex))
208 if (tpci200->slots[dev->slot].irq != NULL) {
210 "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
216 slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
217 if (slot_irq == NULL) {
219 "Slot [%d:%d] unable to allocate memory for IRQ !\n",
220 dev->bus_nr, dev->slot);
226 * WARNING: Setup Interrupt Vector in the IndustryPack device
227 * before an IRQ request.
228 * Read the User Manual of your IndustryPack device to know
229 * where to write the vector in memory.
231 slot_irq->handler = handler;
233 slot_irq->holder = dev;
235 rcu_assign_pointer(tpci200->slots[dev->slot].irq, slot_irq);
236 tpci200_enable_irq(tpci200, dev->slot);
239 mutex_unlock(&tpci200->mutex);
243 static int tpci200_register(struct tpci200_board *tpci200)
247 unsigned long ioidint_base;
248 unsigned long mem_base;
249 unsigned short slot_ctrl;
251 if (pci_enable_device(tpci200->info->pdev) < 0)
254 /* Request IP interface register (Bar 2) */
255 res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
256 "Carrier IP interface registers");
258 dev_err(&tpci200->info->pdev->dev,
259 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
260 tpci200->info->pdev->bus->number,
261 tpci200->info->pdev->devfn);
262 goto out_disable_pci;
265 /* Request IO ID INT space (Bar 3) */
266 res = pci_request_region(tpci200->info->pdev,
267 TPCI200_IO_ID_INT_SPACES_BAR,
268 "Carrier IO ID INT space");
270 dev_err(&tpci200->info->pdev->dev,
271 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
272 tpci200->info->pdev->bus->number,
273 tpci200->info->pdev->devfn);
274 goto out_release_ip_space;
277 /* Request MEM space (Bar 4) */
278 res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
279 "Carrier MEM space");
281 dev_err(&tpci200->info->pdev->dev,
282 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
283 tpci200->info->pdev->bus->number,
284 tpci200->info->pdev->devfn);
285 goto out_release_ioid_int_space;
288 /* Map internal tpci200 driver user space */
289 tpci200->info->interface_regs =
290 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
291 TPCI200_IP_INTERFACE_BAR),
293 tpci200->info->ioidint_space =
294 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
295 TPCI200_IO_ID_INT_SPACES_BAR),
296 TPCI200_IOIDINT_SIZE);
297 tpci200->info->mem8_space =
298 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
299 TPCI200_MEM8_SPACE_BAR),
302 /* Initialize lock that protects interface_regs */
303 spin_lock_init(&tpci200->regs_lock);
305 ioidint_base = pci_resource_start(tpci200->info->pdev,
306 TPCI200_IO_ID_INT_SPACES_BAR);
307 mem_base = pci_resource_start(tpci200->info->pdev,
308 TPCI200_MEM8_SPACE_BAR);
310 /* Set the default parameters of the slot
311 * INT0 disabled, level sensitive
312 * INT1 disabled, level sensitive
313 * error interrupt disabled
314 * timeout interrupt disabled
315 * recover time disabled
320 /* Set all slot physical address space */
321 for (i = 0; i < TPCI200_NB_SLOT; i++) {
322 tpci200->slots[i].io_phys.address =
323 (void __iomem *)ioidint_base +
324 TPCI200_IO_SPACE_OFF + TPCI200_IO_SPACE_GAP*i;
325 tpci200->slots[i].io_phys.size = TPCI200_IO_SPACE_SIZE;
327 tpci200->slots[i].id_phys.address =
328 (void __iomem *)ioidint_base +
329 TPCI200_ID_SPACE_OFF + TPCI200_ID_SPACE_GAP*i;
330 tpci200->slots[i].id_phys.size = TPCI200_ID_SPACE_SIZE;
332 tpci200->slots[i].int_phys.address =
333 (void __iomem *)ioidint_base +
334 TPCI200_INT_SPACE_OFF + TPCI200_INT_SPACE_GAP * i;
335 tpci200->slots[i].int_phys.size = TPCI200_INT_SPACE_SIZE;
337 tpci200->slots[i].mem_phys.address =
338 (void __iomem *)mem_base + TPCI200_MEM8_GAP*i;
339 tpci200->slots[i].mem_phys.size = TPCI200_MEM8_SIZE;
341 writew(slot_ctrl, &tpci200->info->interface_regs->control[i]);
344 res = request_irq(tpci200->info->pdev->irq,
345 tpci200_interrupt, IRQF_SHARED,
346 KBUILD_MODNAME, (void *) tpci200);
348 dev_err(&tpci200->info->pdev->dev,
349 "(bn 0x%X, sn 0x%X) unable to register IRQ !",
350 tpci200->info->pdev->bus->number,
351 tpci200->info->pdev->devfn);
352 goto out_release_ioid_int_space;
357 out_release_ioid_int_space:
358 pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
359 out_release_ip_space:
360 pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
362 pci_disable_device(tpci200->info->pdev);
366 static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
368 struct ipack_addr_space *virt_addr_space;
369 struct tpci200_board *tpci200;
371 tpci200 = check_slot(dev);
375 if (mutex_lock_interruptible(&tpci200->mutex))
380 if (dev->io_space.address == NULL) {
382 "Slot [%d:%d] IO space not mapped !\n",
383 dev->bus_nr, dev->slot);
386 virt_addr_space = &dev->io_space;
389 if (dev->id_space.address == NULL) {
391 "Slot [%d:%d] ID space not mapped !\n",
392 dev->bus_nr, dev->slot);
395 virt_addr_space = &dev->id_space;
397 case IPACK_INT_SPACE:
398 if (dev->int_space.address == NULL) {
400 "Slot [%d:%d] INT space not mapped !\n",
401 dev->bus_nr, dev->slot);
404 virt_addr_space = &dev->int_space;
406 case IPACK_MEM_SPACE:
407 if (dev->mem_space.address == NULL) {
409 "Slot [%d:%d] MEM space not mapped !\n",
410 dev->bus_nr, dev->slot);
413 virt_addr_space = &dev->mem_space;
417 "Slot [%d:%d] space number %d doesn't exist !\n",
418 dev->bus_nr, dev->slot, space);
419 mutex_unlock(&tpci200->mutex);
423 iounmap(virt_addr_space->address);
425 virt_addr_space->address = NULL;
426 virt_addr_space->size = 0;
428 mutex_unlock(&tpci200->mutex);
432 static int tpci200_slot_map_space(struct ipack_device *dev,
433 unsigned int memory_size, int space)
436 unsigned int size_to_map;
437 void __iomem *phys_address;
438 struct ipack_addr_space *virt_addr_space;
439 struct tpci200_board *tpci200;
441 tpci200 = check_slot(dev);
445 if (mutex_lock_interruptible(&tpci200->mutex))
450 if (dev->io_space.address != NULL) {
452 "Slot [%d:%d] IO space already mapped !\n",
453 tpci200->number, dev->slot);
457 virt_addr_space = &dev->io_space;
459 phys_address = tpci200->slots[dev->slot].io_phys.address;
460 size_to_map = tpci200->slots[dev->slot].io_phys.size;
463 if (dev->id_space.address != NULL) {
465 "Slot [%d:%d] ID space already mapped !\n",
466 tpci200->number, dev->slot);
470 virt_addr_space = &dev->id_space;
472 phys_address = tpci200->slots[dev->slot].id_phys.address;
473 size_to_map = tpci200->slots[dev->slot].id_phys.size;
475 case IPACK_INT_SPACE:
476 if (dev->int_space.address != NULL) {
478 "Slot [%d:%d] INT space already mapped !\n",
479 tpci200->number, dev->slot);
483 virt_addr_space = &dev->int_space;
485 phys_address = tpci200->slots[dev->slot].int_phys.address;
486 size_to_map = tpci200->slots[dev->slot].int_phys.size;
488 case IPACK_MEM_SPACE:
489 if (dev->mem_space.address != NULL) {
491 "Slot [%d:%d] MEM space already mapped !\n",
492 tpci200->number, dev->slot);
496 virt_addr_space = &dev->mem_space;
498 if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
500 "Slot [%d:%d] request is 0x%X memory, only 0x%X available !\n",
501 dev->bus_nr, dev->slot, memory_size,
502 tpci200->slots[dev->slot].mem_phys.size);
507 phys_address = tpci200->slots[dev->slot].mem_phys.address;
508 size_to_map = memory_size;
511 dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
512 tpci200->number, dev->slot, space);
517 virt_addr_space->size = size_to_map;
518 virt_addr_space->address =
519 ioremap_nocache((unsigned long)phys_address, size_to_map);
522 mutex_unlock(&tpci200->mutex);
526 static int tpci200_get_clockrate(struct ipack_device *dev)
528 struct tpci200_board *tpci200 = check_slot(dev);
529 __le16 __iomem *addr;
534 addr = &tpci200->info->interface_regs->control[dev->slot];
535 return (ioread16(addr) & TPCI200_CLK32) ? 32 : 8;
538 static int tpci200_set_clockrate(struct ipack_device *dev, int mherz)
540 struct tpci200_board *tpci200 = check_slot(dev);
541 __le16 __iomem *addr;
546 addr = &tpci200->info->interface_regs->control[dev->slot];
550 tpci200_clear_mask(tpci200, addr, TPCI200_CLK32);
553 tpci200_set_mask(tpci200, addr, TPCI200_CLK32);
561 static int tpci200_get_error(struct ipack_device *dev)
563 struct tpci200_board *tpci200 = check_slot(dev);
564 __le16 __iomem *addr;
570 addr = &tpci200->info->interface_regs->status;
571 mask = tpci200_status_error[dev->slot];
572 return (ioread16(addr) & mask) ? 1 : 0;
575 static int tpci200_get_timeout(struct ipack_device *dev)
577 struct tpci200_board *tpci200 = check_slot(dev);
578 __le16 __iomem *addr;
584 addr = &tpci200->info->interface_regs->status;
585 mask = tpci200_status_timeout[dev->slot];
587 return (ioread16(addr) & mask) ? 1 : 0;
590 static int tpci200_reset_timeout(struct ipack_device *dev)
592 struct tpci200_board *tpci200 = check_slot(dev);
593 __le16 __iomem *addr;
599 addr = &tpci200->info->interface_regs->status;
600 mask = tpci200_status_timeout[dev->slot];
602 iowrite16(mask, addr);
606 static void tpci200_uninstall(struct tpci200_board *tpci200)
608 tpci200_unregister(tpci200);
609 kfree(tpci200->slots);
612 static const struct ipack_bus_ops tpci200_bus_ops = {
613 .map_space = tpci200_slot_map_space,
614 .unmap_space = tpci200_slot_unmap_space,
615 .request_irq = tpci200_request_irq,
616 .free_irq = tpci200_free_irq,
617 .get_clockrate = tpci200_get_clockrate,
618 .set_clockrate = tpci200_set_clockrate,
619 .get_error = tpci200_get_error,
620 .get_timeout = tpci200_get_timeout,
621 .reset_timeout = tpci200_reset_timeout,
624 static int tpci200_install(struct tpci200_board *tpci200)
628 tpci200->slots = kzalloc(
629 TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
630 if (tpci200->slots == NULL)
633 res = tpci200_register(tpci200);
635 kfree(tpci200->slots);
636 tpci200->slots = NULL;
640 mutex_init(&tpci200->mutex);
644 static int tpci200_pci_probe(struct pci_dev *pdev,
645 const struct pci_device_id *id)
648 struct tpci200_board *tpci200;
651 tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
655 tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
656 if (!tpci200->info) {
663 /* Obtain a mapping of the carrier's PCI configuration registers */
664 ret = pci_request_region(pdev, TPCI200_CFG_MEM_BAR,
665 KBUILD_MODNAME " Configuration Memory");
667 dev_err(&pdev->dev, "Failed to allocate PCI Configuration Memory");
669 goto out_err_pci_request;
671 tpci200->info->cfg_regs = ioremap_nocache(
672 pci_resource_start(pdev, TPCI200_CFG_MEM_BAR),
673 pci_resource_len(pdev, TPCI200_CFG_MEM_BAR));
674 if (!tpci200->info->cfg_regs) {
675 dev_err(&pdev->dev, "Failed to map PCI Configuration Memory");
677 goto out_err_ioremap;
680 /* Disable byte swapping for 16 bit IP module access. This will ensure
681 * that the Industrypack big endian byte order is preserved by the
683 reg32 = ioread32(tpci200->info->cfg_regs + LAS1_DESC);
684 reg32 |= 1 << LAS_BIT_BIGENDIAN;
685 iowrite32(reg32, tpci200->info->cfg_regs + LAS1_DESC);
687 reg32 = ioread32(tpci200->info->cfg_regs + LAS2_DESC);
688 reg32 |= 1 << LAS_BIT_BIGENDIAN;
689 iowrite32(reg32, tpci200->info->cfg_regs + LAS2_DESC);
691 /* Save struct pci_dev pointer */
692 tpci200->info->pdev = pdev;
693 tpci200->info->id_table = (struct pci_device_id *)id;
695 /* register the device and initialize it */
696 ret = tpci200_install(tpci200);
698 dev_err(&pdev->dev, "error during tpci200 install\n");
700 goto out_err_install;
703 /* Register the carrier in the industry pack bus driver */
704 tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
707 if (!tpci200->info->ipack_bus) {
709 "error registering the carrier on ipack driver\n");
711 goto out_err_bus_register;
714 /* save the bus number given by ipack to logging purpose */
715 tpci200->number = tpci200->info->ipack_bus->bus_nr;
716 dev_set_drvdata(&pdev->dev, tpci200);
718 for (i = 0; i < TPCI200_NB_SLOT; i++)
719 ipack_device_register(tpci200->info->ipack_bus, i);
722 out_err_bus_register:
723 tpci200_uninstall(tpci200);
725 iounmap(tpci200->info->cfg_regs);
727 pci_release_region(pdev, TPCI200_CFG_MEM_BAR);
730 kfree(tpci200->info);
736 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
738 ipack_bus_unregister(tpci200->info->ipack_bus);
739 tpci200_uninstall(tpci200);
741 kfree(tpci200->info);
745 static void __devexit tpci200_pci_remove(struct pci_dev *dev)
747 struct tpci200_board *tpci200 = pci_get_drvdata(dev);
749 __tpci200_pci_remove(tpci200);
752 static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
753 { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
754 TPCI200_SUBDEVICE_ID },
758 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
760 static struct pci_driver tpci200_pci_drv = {
762 .id_table = tpci200_idtable,
763 .probe = tpci200_pci_probe,
764 .remove = __devexit_p(tpci200_pci_remove),
767 static int __init tpci200_drvr_init_module(void)
769 return pci_register_driver(&tpci200_pci_drv);
772 static void __exit tpci200_drvr_exit_module(void)
774 pci_unregister_driver(&tpci200_pci_drv);
777 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
778 MODULE_LICENSE("GPL");
779 module_init(tpci200_drvr_init_module);
780 module_exit(tpci200_drvr_exit_module);