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>
17 static struct ipack_bus_ops tpci200_bus_ops;
19 /* TPCI200 controls registers */
20 static int control_reg[] = {
21 TPCI200_CONTROL_A_REG,
22 TPCI200_CONTROL_B_REG,
23 TPCI200_CONTROL_C_REG,
27 /* Linked list to save the registered devices */
28 static LIST_HEAD(tpci200_list);
30 static int tpci200_slot_unregister(struct ipack_device *dev);
32 static struct tpci200_board *check_slot(struct ipack_device *dev)
34 struct tpci200_board *tpci200;
40 list_for_each_entry(tpci200, &tpci200_list, list) {
41 if (tpci200->number == dev->bus_nr) {
48 dev_err(&dev->dev, "Carrier not found\n");
52 if (dev->slot >= TPCI200_NB_SLOT) {
54 "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
55 dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
62 static inline unsigned char __tpci200_read8(void __iomem *address,
65 return ioread8(address + (offset^1));
68 static inline unsigned short __tpci200_read16(void __iomem *address,
71 return ioread16(address + offset);
74 static inline unsigned int __tpci200_read32(void __iomem *address,
77 return swahw32(ioread32(address + offset));
80 static inline void __tpci200_write8(unsigned char value,
81 void __iomem *address, unsigned long offset)
83 iowrite8(value, address+(offset^1));
86 static inline void __tpci200_write16(unsigned short value,
87 void __iomem *address,
90 iowrite16(value, address+offset);
93 static inline void __tpci200_write32(unsigned int value,
94 void __iomem *address,
97 iowrite32(swahw32(value), address+offset);
100 static struct ipack_addr_space *get_slot_address_space(struct ipack_device *dev,
103 struct ipack_addr_space *addr;
107 addr = &dev->io_space;
110 addr = &dev->id_space;
112 case IPACK_MEM_SPACE:
113 addr = &dev->mem_space;
117 "Slot [%d:%d] space number %d doesn't exist !\n",
118 dev->bus_nr, dev->slot, space);
123 if ((addr->size == 0) || (addr->address == NULL)) {
124 dev_err(&dev->dev, "Error, slot space not mapped !\n");
131 static int tpci200_read8(struct ipack_device *dev, int space,
132 unsigned long offset, unsigned char *value)
134 struct ipack_addr_space *addr;
135 struct tpci200_board *tpci200;
137 tpci200 = check_slot(dev);
141 addr = get_slot_address_space(dev, space);
145 if (offset >= addr->size) {
146 dev_err(&dev->dev, "Error, slot space offset error !\n");
150 *value = __tpci200_read8(addr->address, offset);
155 static int tpci200_read16(struct ipack_device *dev, int space,
156 unsigned long offset, unsigned short *value)
158 struct ipack_addr_space *addr;
159 struct tpci200_board *tpci200;
161 tpci200 = check_slot(dev);
165 addr = get_slot_address_space(dev, space);
169 if ((offset+2) >= addr->size) {
170 dev_err(&dev->dev, "Error, slot space offset error !\n");
173 *value = __tpci200_read16(addr->address, offset);
178 static int tpci200_read32(struct ipack_device *dev, int space,
179 unsigned long offset, unsigned int *value)
181 struct ipack_addr_space *addr;
182 struct tpci200_board *tpci200;
184 tpci200 = check_slot(dev);
188 addr = get_slot_address_space(dev, space);
192 if ((offset+4) >= addr->size) {
193 dev_err(&dev->dev, "Error, slot space offset error !\n");
197 *value = __tpci200_read32(addr->address, offset);
202 static int tpci200_write8(struct ipack_device *dev, int space,
203 unsigned long offset, unsigned char value)
205 struct ipack_addr_space *addr;
206 struct tpci200_board *tpci200;
208 tpci200 = check_slot(dev);
212 addr = get_slot_address_space(dev, space);
216 if (offset >= addr->size) {
217 dev_err(&dev->dev, "Error, slot space offset error !\n");
221 __tpci200_write8(value, addr->address, offset);
226 static int tpci200_write16(struct ipack_device *dev, int space,
227 unsigned long offset, unsigned short value)
229 struct ipack_addr_space *addr;
230 struct tpci200_board *tpci200;
232 tpci200 = check_slot(dev);
236 addr = get_slot_address_space(dev, space);
240 if ((offset+2) >= addr->size) {
241 dev_err(&dev->dev, "Error, slot space offset error !\n");
245 __tpci200_write16(value, addr->address, offset);
250 static int tpci200_write32(struct ipack_device *dev, int space,
251 unsigned long offset, unsigned int value)
253 struct ipack_addr_space *addr;
254 struct tpci200_board *tpci200;
256 tpci200 = check_slot(dev);
260 addr = get_slot_address_space(dev, space);
264 if ((offset+4) >= addr->size) {
265 dev_err(&dev->dev, "Error, slot space offset error !\n");
269 __tpci200_write32(value, addr->address, offset);
274 static void tpci200_unregister(struct tpci200_board *tpci200)
278 free_irq(tpci200->info->pdev->irq, (void *) tpci200);
280 pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
281 pci_iounmap(tpci200->info->pdev, tpci200->info->ioidint_space);
282 pci_iounmap(tpci200->info->pdev, tpci200->info->mem8_space);
284 pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
285 pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
286 pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
288 pci_disable_device(tpci200->info->pdev);
289 pci_dev_put(tpci200->info->pdev);
291 for (i = 0; i < TPCI200_NB_SLOT; i++) {
292 tpci200->slots[i].io_phys.address = NULL;
293 tpci200->slots[i].io_phys.size = 0;
294 tpci200->slots[i].id_phys.address = NULL;
295 tpci200->slots[i].id_phys.size = 0;
296 tpci200->slots[i].mem_phys.address = NULL;
297 tpci200->slots[i].mem_phys.size = 0;
301 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
303 struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
305 unsigned short status_reg, reg_value;
306 unsigned short unhandled_ints = 0;
307 irqreturn_t ret = IRQ_NONE;
309 /* Read status register */
310 status_reg = readw(tpci200->info->interface_regs +
313 if (status_reg & TPCI200_SLOT_INT_MASK) {
314 unhandled_ints = status_reg & TPCI200_SLOT_INT_MASK;
315 /* callback to the IRQ handler for the corresponding slot */
316 for (i = 0; i < TPCI200_NB_SLOT; i++) {
317 if ((tpci200->slots[i].irq != NULL) &&
318 (status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2*i)))) {
320 ret = tpci200->slots[i].irq->handler(tpci200->slots[i].irq->arg);
323 readw(tpci200->slots[i].dev->io_space.address +
325 readw(tpci200->slots[i].dev->io_space.address +
328 unhandled_ints &= ~(((TPCI200_A_INT0 | TPCI200_A_INT1) << (2*i)));
332 /* Interrupt not handled are disabled */
333 if (unhandled_ints) {
334 for (i = 0; i < TPCI200_NB_SLOT; i++) {
335 if (unhandled_ints & ((TPCI200_INT0_EN | TPCI200_INT1_EN) << (2*i))) {
336 dev_info(&tpci200->slots[i].dev->dev,
337 "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
340 tpci200->info->interface_regs +
343 ~(TPCI200_INT0_EN | TPCI200_INT1_EN);
345 (tpci200->info->interface_regs +
354 static int tpci200_register(struct tpci200_board *tpci200)
358 unsigned long ioidint_base;
359 unsigned long mem_base;
360 unsigned short slot_ctrl;
362 if (pci_enable_device(tpci200->info->pdev) < 0)
365 /* Request IP interface register (Bar 2) */
366 res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
367 "Carrier IP interface registers");
369 dev_err(&tpci200->info->pdev->dev,
370 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
371 tpci200->info->pdev->bus->number,
372 tpci200->info->pdev->devfn);
373 goto out_disable_pci;
376 /* Request IO ID INT space (Bar 3) */
377 res = pci_request_region(tpci200->info->pdev,
378 TPCI200_IO_ID_INT_SPACES_BAR,
379 "Carrier IO ID INT space");
381 dev_err(&tpci200->info->pdev->dev,
382 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
383 tpci200->info->pdev->bus->number,
384 tpci200->info->pdev->devfn);
385 goto out_release_ip_space;
388 /* Request MEM space (Bar 4) */
389 res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
390 "Carrier MEM space");
392 dev_err(&tpci200->info->pdev->dev,
393 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
394 tpci200->info->pdev->bus->number,
395 tpci200->info->pdev->devfn);
396 goto out_release_ioid_int_space;
399 /* Map internal tpci200 driver user space */
400 tpci200->info->interface_regs =
401 ioremap(pci_resource_start(tpci200->info->pdev,
402 TPCI200_IP_INTERFACE_BAR),
404 tpci200->info->ioidint_space =
405 ioremap(pci_resource_start(tpci200->info->pdev,
406 TPCI200_IO_ID_INT_SPACES_BAR),
407 TPCI200_IOIDINT_SIZE);
408 tpci200->info->mem8_space =
409 ioremap(pci_resource_start(tpci200->info->pdev,
410 TPCI200_MEM8_SPACE_BAR),
413 ioidint_base = pci_resource_start(tpci200->info->pdev,
414 TPCI200_IO_ID_INT_SPACES_BAR);
415 mem_base = pci_resource_start(tpci200->info->pdev,
416 TPCI200_MEM8_SPACE_BAR);
418 /* Set the default parameters of the slot
419 * INT0 disabled, level sensitive
420 * INT1 disabled, level sensitive
421 * error interrupt disabled
422 * timeout interrupt disabled
423 * recover time disabled
428 /* Set all slot physical address space */
429 for (i = 0; i < TPCI200_NB_SLOT; i++) {
430 tpci200->slots[i].io_phys.address =
431 (void __iomem *)ioidint_base +
432 TPCI200_IO_SPACE_OFF + TPCI200_IO_SPACE_GAP*i;
433 tpci200->slots[i].io_phys.size = TPCI200_IO_SPACE_SIZE;
435 tpci200->slots[i].id_phys.address =
436 (void __iomem *)ioidint_base +
437 TPCI200_ID_SPACE_OFF + TPCI200_ID_SPACE_GAP*i;
438 tpci200->slots[i].id_phys.size = TPCI200_ID_SPACE_SIZE;
440 tpci200->slots[i].mem_phys.address =
441 (void __iomem *)mem_base + TPCI200_MEM8_GAP*i;
442 tpci200->slots[i].mem_phys.size = TPCI200_MEM8_SIZE;
444 writew(slot_ctrl, (tpci200->info->interface_regs +
448 res = request_irq(tpci200->info->pdev->irq,
449 tpci200_interrupt, IRQF_SHARED,
450 KBUILD_MODNAME, (void *) tpci200);
452 dev_err(&tpci200->info->pdev->dev,
453 "(bn 0x%X, sn 0x%X) unable to register IRQ !",
454 tpci200->info->pdev->bus->number,
455 tpci200->info->pdev->devfn);
456 goto out_release_ioid_int_space;
461 out_release_ioid_int_space:
462 pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
463 out_release_ip_space:
464 pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
466 pci_disable_device(tpci200->info->pdev);
470 static int __tpci200_request_irq(struct tpci200_board *tpci200,
471 struct ipack_device *dev)
473 unsigned short slot_ctrl;
475 /* Set the default parameters of the slot
476 * INT0 enabled, level sensitive
477 * INT1 enabled, level sensitive
478 * error interrupt disabled
479 * timeout interrupt disabled
480 * recover time disabled
483 slot_ctrl = TPCI200_INT0_EN | TPCI200_INT1_EN;
484 writew(slot_ctrl, (tpci200->info->interface_regs +
485 control_reg[dev->slot]));
490 static void __tpci200_free_irq(struct tpci200_board *tpci200,
491 struct ipack_device *dev)
493 unsigned short slot_ctrl;
495 /* Set the default parameters of the slot
496 * INT0 disabled, level sensitive
497 * INT1 disabled, level sensitive
498 * error interrupt disabled
499 * timeout interrupt disabled
500 * recover time disabled
504 writew(slot_ctrl, (tpci200->info->interface_regs +
505 control_reg[dev->slot]));
508 static int tpci200_free_irq(struct ipack_device *dev)
510 struct slot_irq *slot_irq;
511 struct tpci200_board *tpci200;
513 tpci200 = check_slot(dev);
517 if (mutex_lock_interruptible(&tpci200->mutex))
520 if (tpci200->slots[dev->slot].irq == NULL) {
521 mutex_unlock(&tpci200->mutex);
525 __tpci200_free_irq(tpci200, dev);
526 slot_irq = tpci200->slots[dev->slot].irq;
527 tpci200->slots[dev->slot].irq = NULL;
530 mutex_unlock(&tpci200->mutex);
534 static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
536 struct ipack_addr_space *virt_addr_space;
537 struct tpci200_board *tpci200;
539 tpci200 = check_slot(dev);
543 if (mutex_lock_interruptible(&tpci200->mutex))
548 if (dev->io_space.address == NULL) {
550 "Slot [%d:%d] IO space not mapped !\n",
551 dev->bus_nr, dev->slot);
554 virt_addr_space = &dev->io_space;
557 if (dev->id_space.address == NULL) {
559 "Slot [%d:%d] ID space not mapped !\n",
560 dev->bus_nr, dev->slot);
563 virt_addr_space = &dev->id_space;
565 case IPACK_MEM_SPACE:
566 if (dev->mem_space.address == NULL) {
568 "Slot [%d:%d] MEM space not mapped !\n",
569 dev->bus_nr, dev->slot);
572 virt_addr_space = &dev->mem_space;
576 "Slot [%d:%d] space number %d doesn't exist !\n",
577 dev->bus_nr, dev->slot, space);
578 mutex_unlock(&tpci200->mutex);
582 iounmap(virt_addr_space->address);
584 virt_addr_space->address = NULL;
585 virt_addr_space->size = 0;
587 mutex_unlock(&tpci200->mutex);
591 static int tpci200_slot_unregister(struct ipack_device *dev)
593 struct tpci200_board *tpci200;
598 tpci200 = check_slot(dev);
602 tpci200_free_irq(dev);
604 if (mutex_lock_interruptible(&tpci200->mutex))
607 ipack_device_unregister(dev);
608 tpci200->slots[dev->slot].dev = NULL;
609 mutex_unlock(&tpci200->mutex);
614 static int tpci200_slot_map_space(struct ipack_device *dev,
615 unsigned int memory_size, int space)
618 unsigned int size_to_map;
619 void __iomem *phys_address;
620 struct ipack_addr_space *virt_addr_space;
621 struct tpci200_board *tpci200;
623 tpci200 = check_slot(dev);
627 if (mutex_lock_interruptible(&tpci200->mutex))
632 if (dev->io_space.address != NULL) {
634 "Slot [%d:%d] IO space already mapped !\n",
635 tpci200->number, dev->slot);
639 virt_addr_space = &dev->io_space;
641 phys_address = tpci200->slots[dev->slot].io_phys.address;
642 size_to_map = tpci200->slots[dev->slot].io_phys.size;
645 if (dev->id_space.address != NULL) {
647 "Slot [%d:%d] ID space already mapped !\n",
648 tpci200->number, dev->slot);
652 virt_addr_space = &dev->id_space;
654 phys_address = tpci200->slots[dev->slot].id_phys.address;
655 size_to_map = tpci200->slots[dev->slot].id_phys.size;
657 case IPACK_MEM_SPACE:
658 if (dev->mem_space.address != NULL) {
660 "Slot [%d:%d] MEM space already mapped !\n",
661 tpci200->number, dev->slot);
665 virt_addr_space = &dev->mem_space;
667 if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
669 "Slot [%d:%d] request is 0x%X memory, only 0x%X available !\n",
670 dev->bus_nr, dev->slot, memory_size,
671 tpci200->slots[dev->slot].mem_phys.size);
676 phys_address = tpci200->slots[dev->slot].mem_phys.address;
677 size_to_map = memory_size;
680 dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
681 tpci200->number, dev->slot, space);
686 virt_addr_space->size = size_to_map;
687 virt_addr_space->address =
688 ioremap((unsigned long)phys_address, size_to_map);
691 mutex_unlock(&tpci200->mutex);
695 static int tpci200_request_irq(struct ipack_device *dev, int vector,
696 int (*handler)(void *), void *arg)
699 struct slot_irq *slot_irq;
700 struct tpci200_board *tpci200;
702 tpci200 = check_slot(dev);
706 if (mutex_lock_interruptible(&tpci200->mutex))
709 if (tpci200->slots[dev->slot].irq != NULL) {
711 "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
717 slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
718 if (slot_irq == NULL) {
720 "Slot [%d:%d] unable to allocate memory for IRQ !\n",
721 dev->bus_nr, dev->slot);
727 * WARNING: Setup Interrupt Vector in the IndustryPack device
728 * before an IRQ request.
729 * Read the User Manual of your IndustryPack device to know
730 * where to write the vector in memory.
732 slot_irq->vector = vector;
733 slot_irq->handler = handler;
736 tpci200->slots[dev->slot].irq = slot_irq;
737 res = __tpci200_request_irq(tpci200, dev);
740 mutex_unlock(&tpci200->mutex);
744 static void tpci200_uninstall(struct tpci200_board *tpci200)
748 for (i = 0; i < TPCI200_NB_SLOT; i++)
749 tpci200_slot_unregister(tpci200->slots[i].dev);
751 tpci200_unregister(tpci200);
752 kfree(tpci200->slots);
755 static struct ipack_bus_ops tpci200_bus_ops = {
756 .map_space = tpci200_slot_map_space,
757 .unmap_space = tpci200_slot_unmap_space,
758 .request_irq = tpci200_request_irq,
759 .free_irq = tpci200_free_irq,
760 .read8 = tpci200_read8,
761 .read16 = tpci200_read16,
762 .read32 = tpci200_read32,
763 .write8 = tpci200_write8,
764 .write16 = tpci200_write16,
765 .write32 = tpci200_write32,
766 .remove_device = tpci200_slot_unregister,
769 static int tpci200_install(struct tpci200_board *tpci200)
773 tpci200->slots = kzalloc(
774 TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
775 if (tpci200->slots == NULL)
778 res = tpci200_register(tpci200);
780 kfree(tpci200->slots);
781 tpci200->slots = NULL;
785 mutex_init(&tpci200->mutex);
789 static int tpci200_pciprobe(struct pci_dev *pdev,
790 const struct pci_device_id *id)
793 struct tpci200_board *tpci200;
795 tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
799 tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
800 if (!tpci200->info) {
805 /* Save struct pci_dev pointer */
806 tpci200->info->pdev = pdev;
807 tpci200->info->id_table = (struct pci_device_id *)id;
809 /* register the device and initialize it */
810 ret = tpci200_install(tpci200);
812 dev_err(&pdev->dev, "Error during tpci200 install !\n");
813 kfree(tpci200->info);
818 /* Register the carrier in the industry pack bus driver */
819 tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
822 if (!tpci200->info->ipack_bus) {
824 "error registering the carrier on ipack driver\n");
825 tpci200_uninstall(tpci200);
826 kfree(tpci200->info);
831 /* save the bus number given by ipack to logging purpose */
832 tpci200->number = tpci200->info->ipack_bus->bus_nr;
833 dev_set_drvdata(&pdev->dev, tpci200);
834 /* add the registered device in an internal linked list */
835 list_add_tail(&tpci200->list, &tpci200_list);
838 * Give the same IRQ number as the slot number.
839 * The TPCI200 has assigned his own two IRQ by PCI bus driver
841 for (i = 0; i < TPCI200_NB_SLOT; i++)
842 tpci200->slots[i].dev =
843 ipack_device_register(tpci200->info->ipack_bus, i, i);
847 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
849 tpci200_uninstall(tpci200);
850 list_del(&tpci200->list);
851 ipack_bus_unregister(tpci200->info->ipack_bus);
852 kfree(tpci200->info);
856 static void __devexit tpci200_pci_remove(struct pci_dev *dev)
858 struct tpci200_board *tpci200, *next;
860 /* Search the registered device to uninstall it */
861 list_for_each_entry_safe(tpci200, next, &tpci200_list, list) {
862 if (tpci200->info->pdev == dev) {
863 __tpci200_pci_remove(tpci200);
869 static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
870 { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
871 TPCI200_SUBDEVICE_ID },
875 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
877 static struct pci_driver tpci200_pci_drv = {
879 .id_table = tpci200_idtable,
880 .probe = tpci200_pciprobe,
881 .remove = __devexit_p(tpci200_pci_remove),
884 static int __init tpci200_drvr_init_module(void)
886 return pci_register_driver(&tpci200_pci_drv);
889 static void __exit tpci200_drvr_exit_module(void)
891 struct tpci200_board *tpci200, *next;
893 list_for_each_entry_safe(tpci200, next, &tpci200_list, list)
894 __tpci200_pci_remove(tpci200);
896 pci_unregister_driver(&tpci200_pci_drv);
899 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
900 MODULE_LICENSE("GPL");
901 module_init(tpci200_drvr_init_module);
902 module_exit(tpci200_drvr_exit_module);