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 static int tpci200_slot_unregister(struct ipack_device *dev);
29 static struct tpci200_board *check_slot(struct ipack_device *dev)
31 struct tpci200_board *tpci200;
37 tpci200 = dev_get_drvdata(dev->bus->parent);
39 if (tpci200 == NULL) {
40 dev_info(&dev->dev, "carrier board not found\n");
44 if (dev->slot >= TPCI200_NB_SLOT) {
46 "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
47 dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
54 static inline unsigned char __tpci200_read8(void __iomem *address,
57 return ioread8(address + (offset^1));
60 static inline unsigned short __tpci200_read16(void __iomem *address,
63 return ioread16(address + offset);
66 static inline unsigned int __tpci200_read32(void __iomem *address,
69 return swahw32(ioread32(address + offset));
72 static inline void __tpci200_write8(unsigned char value,
73 void __iomem *address, unsigned long offset)
75 iowrite8(value, address+(offset^1));
78 static inline void __tpci200_write16(unsigned short value,
79 void __iomem *address,
82 iowrite16(value, address+offset);
85 static inline void __tpci200_write32(unsigned int value,
86 void __iomem *address,
89 iowrite32(swahw32(value), address+offset);
92 static struct ipack_addr_space *get_slot_address_space(struct ipack_device *dev,
95 struct ipack_addr_space *addr;
99 addr = &dev->io_space;
102 addr = &dev->id_space;
104 case IPACK_MEM_SPACE:
105 addr = &dev->mem_space;
109 "Slot [%d:%d] space number %d doesn't exist !\n",
110 dev->bus_nr, dev->slot, space);
115 if ((addr->size == 0) || (addr->address == NULL)) {
116 dev_err(&dev->dev, "Error, slot space not mapped !\n");
123 static int tpci200_read8(struct ipack_device *dev, int space,
124 unsigned long offset, unsigned char *value)
126 struct ipack_addr_space *addr;
127 struct tpci200_board *tpci200;
129 tpci200 = check_slot(dev);
133 addr = get_slot_address_space(dev, space);
137 if (offset >= addr->size) {
138 dev_err(&dev->dev, "Error, slot space offset error !\n");
142 *value = __tpci200_read8(addr->address, offset);
147 static int tpci200_read16(struct ipack_device *dev, int space,
148 unsigned long offset, unsigned short *value)
150 struct ipack_addr_space *addr;
151 struct tpci200_board *tpci200;
153 tpci200 = check_slot(dev);
157 addr = get_slot_address_space(dev, space);
161 if ((offset+2) >= addr->size) {
162 dev_err(&dev->dev, "Error, slot space offset error !\n");
165 *value = __tpci200_read16(addr->address, offset);
170 static int tpci200_read32(struct ipack_device *dev, int space,
171 unsigned long offset, unsigned int *value)
173 struct ipack_addr_space *addr;
174 struct tpci200_board *tpci200;
176 tpci200 = check_slot(dev);
180 addr = get_slot_address_space(dev, space);
184 if ((offset+4) >= addr->size) {
185 dev_err(&dev->dev, "Error, slot space offset error !\n");
189 *value = __tpci200_read32(addr->address, offset);
194 static int tpci200_write8(struct ipack_device *dev, int space,
195 unsigned long offset, unsigned char value)
197 struct ipack_addr_space *addr;
198 struct tpci200_board *tpci200;
200 tpci200 = check_slot(dev);
204 addr = get_slot_address_space(dev, space);
208 if (offset >= addr->size) {
209 dev_err(&dev->dev, "Error, slot space offset error !\n");
213 __tpci200_write8(value, addr->address, offset);
218 static int tpci200_write16(struct ipack_device *dev, int space,
219 unsigned long offset, unsigned short value)
221 struct ipack_addr_space *addr;
222 struct tpci200_board *tpci200;
224 tpci200 = check_slot(dev);
228 addr = get_slot_address_space(dev, space);
232 if ((offset+2) >= addr->size) {
233 dev_err(&dev->dev, "Error, slot space offset error !\n");
237 __tpci200_write16(value, addr->address, offset);
242 static int tpci200_write32(struct ipack_device *dev, int space,
243 unsigned long offset, unsigned int value)
245 struct ipack_addr_space *addr;
246 struct tpci200_board *tpci200;
248 tpci200 = check_slot(dev);
252 addr = get_slot_address_space(dev, space);
256 if ((offset+4) >= addr->size) {
257 dev_err(&dev->dev, "Error, slot space offset error !\n");
261 __tpci200_write32(value, addr->address, offset);
266 static void tpci200_unregister(struct tpci200_board *tpci200)
270 free_irq(tpci200->info->pdev->irq, (void *) tpci200);
272 pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
273 pci_iounmap(tpci200->info->pdev, tpci200->info->ioidint_space);
274 pci_iounmap(tpci200->info->pdev, tpci200->info->mem8_space);
276 pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
277 pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
278 pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
280 pci_disable_device(tpci200->info->pdev);
281 pci_dev_put(tpci200->info->pdev);
283 for (i = 0; i < TPCI200_NB_SLOT; i++) {
284 tpci200->slots[i].io_phys.address = NULL;
285 tpci200->slots[i].io_phys.size = 0;
286 tpci200->slots[i].id_phys.address = NULL;
287 tpci200->slots[i].id_phys.size = 0;
288 tpci200->slots[i].mem_phys.address = NULL;
289 tpci200->slots[i].mem_phys.size = 0;
293 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
295 struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
297 unsigned short status_reg, reg_value;
298 unsigned short unhandled_ints = 0;
299 irqreturn_t ret = IRQ_NONE;
301 /* Read status register */
302 status_reg = readw(tpci200->info->interface_regs +
305 if (status_reg & TPCI200_SLOT_INT_MASK) {
306 unhandled_ints = status_reg & TPCI200_SLOT_INT_MASK;
307 /* callback to the IRQ handler for the corresponding slot */
308 for (i = 0; i < TPCI200_NB_SLOT; i++) {
309 if ((tpci200->slots[i].irq != NULL) &&
310 (status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2*i)))) {
312 ret = tpci200->slots[i].irq->handler(tpci200->slots[i].irq->arg);
315 readw(tpci200->slots[i].dev->io_space.address +
317 readw(tpci200->slots[i].dev->io_space.address +
320 unhandled_ints &= ~(((TPCI200_A_INT0 | TPCI200_A_INT1) << (2*i)));
324 /* Interrupt not handled are disabled */
325 if (unhandled_ints) {
326 for (i = 0; i < TPCI200_NB_SLOT; i++) {
327 if (unhandled_ints & ((TPCI200_INT0_EN | TPCI200_INT1_EN) << (2*i))) {
328 dev_info(&tpci200->slots[i].dev->dev,
329 "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
332 tpci200->info->interface_regs +
335 ~(TPCI200_INT0_EN | TPCI200_INT1_EN);
337 (tpci200->info->interface_regs +
346 static int tpci200_register(struct tpci200_board *tpci200)
350 unsigned long ioidint_base;
351 unsigned long mem_base;
352 unsigned short slot_ctrl;
354 if (pci_enable_device(tpci200->info->pdev) < 0)
357 /* Request IP interface register (Bar 2) */
358 res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
359 "Carrier IP interface registers");
361 dev_err(&tpci200->info->pdev->dev,
362 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
363 tpci200->info->pdev->bus->number,
364 tpci200->info->pdev->devfn);
365 goto out_disable_pci;
368 /* Request IO ID INT space (Bar 3) */
369 res = pci_request_region(tpci200->info->pdev,
370 TPCI200_IO_ID_INT_SPACES_BAR,
371 "Carrier IO ID INT space");
373 dev_err(&tpci200->info->pdev->dev,
374 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
375 tpci200->info->pdev->bus->number,
376 tpci200->info->pdev->devfn);
377 goto out_release_ip_space;
380 /* Request MEM space (Bar 4) */
381 res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
382 "Carrier MEM space");
384 dev_err(&tpci200->info->pdev->dev,
385 "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
386 tpci200->info->pdev->bus->number,
387 tpci200->info->pdev->devfn);
388 goto out_release_ioid_int_space;
391 /* Map internal tpci200 driver user space */
392 tpci200->info->interface_regs =
393 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
394 TPCI200_IP_INTERFACE_BAR),
396 tpci200->info->ioidint_space =
397 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
398 TPCI200_IO_ID_INT_SPACES_BAR),
399 TPCI200_IOIDINT_SIZE);
400 tpci200->info->mem8_space =
401 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
402 TPCI200_MEM8_SPACE_BAR),
405 ioidint_base = pci_resource_start(tpci200->info->pdev,
406 TPCI200_IO_ID_INT_SPACES_BAR);
407 mem_base = pci_resource_start(tpci200->info->pdev,
408 TPCI200_MEM8_SPACE_BAR);
410 /* Set the default parameters of the slot
411 * INT0 disabled, level sensitive
412 * INT1 disabled, level sensitive
413 * error interrupt disabled
414 * timeout interrupt disabled
415 * recover time disabled
420 /* Set all slot physical address space */
421 for (i = 0; i < TPCI200_NB_SLOT; i++) {
422 tpci200->slots[i].io_phys.address =
423 (void __iomem *)ioidint_base +
424 TPCI200_IO_SPACE_OFF + TPCI200_IO_SPACE_GAP*i;
425 tpci200->slots[i].io_phys.size = TPCI200_IO_SPACE_SIZE;
427 tpci200->slots[i].id_phys.address =
428 (void __iomem *)ioidint_base +
429 TPCI200_ID_SPACE_OFF + TPCI200_ID_SPACE_GAP*i;
430 tpci200->slots[i].id_phys.size = TPCI200_ID_SPACE_SIZE;
432 tpci200->slots[i].mem_phys.address =
433 (void __iomem *)mem_base + TPCI200_MEM8_GAP*i;
434 tpci200->slots[i].mem_phys.size = TPCI200_MEM8_SIZE;
436 writew(slot_ctrl, (tpci200->info->interface_regs +
440 res = request_irq(tpci200->info->pdev->irq,
441 tpci200_interrupt, IRQF_SHARED,
442 KBUILD_MODNAME, (void *) tpci200);
444 dev_err(&tpci200->info->pdev->dev,
445 "(bn 0x%X, sn 0x%X) unable to register IRQ !",
446 tpci200->info->pdev->bus->number,
447 tpci200->info->pdev->devfn);
448 goto out_release_ioid_int_space;
453 out_release_ioid_int_space:
454 pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
455 out_release_ip_space:
456 pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
458 pci_disable_device(tpci200->info->pdev);
462 static int __tpci200_request_irq(struct tpci200_board *tpci200,
463 struct ipack_device *dev)
465 unsigned short slot_ctrl;
467 /* Set the default parameters of the slot
468 * INT0 enabled, level sensitive
469 * INT1 enabled, level sensitive
470 * error interrupt disabled
471 * timeout interrupt disabled
472 * recover time disabled
475 slot_ctrl = TPCI200_INT0_EN | TPCI200_INT1_EN;
476 writew(slot_ctrl, (tpci200->info->interface_regs +
477 control_reg[dev->slot]));
482 static void __tpci200_free_irq(struct tpci200_board *tpci200,
483 struct ipack_device *dev)
485 unsigned short slot_ctrl;
487 /* Set the default parameters of the slot
488 * INT0 disabled, level sensitive
489 * INT1 disabled, level sensitive
490 * error interrupt disabled
491 * timeout interrupt disabled
492 * recover time disabled
496 writew(slot_ctrl, (tpci200->info->interface_regs +
497 control_reg[dev->slot]));
500 static int tpci200_free_irq(struct ipack_device *dev)
502 struct slot_irq *slot_irq;
503 struct tpci200_board *tpci200;
505 tpci200 = check_slot(dev);
509 if (mutex_lock_interruptible(&tpci200->mutex))
512 if (tpci200->slots[dev->slot].irq == NULL) {
513 mutex_unlock(&tpci200->mutex);
517 __tpci200_free_irq(tpci200, dev);
518 slot_irq = tpci200->slots[dev->slot].irq;
519 tpci200->slots[dev->slot].irq = NULL;
522 mutex_unlock(&tpci200->mutex);
526 static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
528 struct ipack_addr_space *virt_addr_space;
529 struct tpci200_board *tpci200;
531 tpci200 = check_slot(dev);
535 if (mutex_lock_interruptible(&tpci200->mutex))
540 if (dev->io_space.address == NULL) {
542 "Slot [%d:%d] IO space not mapped !\n",
543 dev->bus_nr, dev->slot);
546 virt_addr_space = &dev->io_space;
549 if (dev->id_space.address == NULL) {
551 "Slot [%d:%d] ID space not mapped !\n",
552 dev->bus_nr, dev->slot);
555 virt_addr_space = &dev->id_space;
557 case IPACK_MEM_SPACE:
558 if (dev->mem_space.address == NULL) {
560 "Slot [%d:%d] MEM space not mapped !\n",
561 dev->bus_nr, dev->slot);
564 virt_addr_space = &dev->mem_space;
568 "Slot [%d:%d] space number %d doesn't exist !\n",
569 dev->bus_nr, dev->slot, space);
570 mutex_unlock(&tpci200->mutex);
574 iounmap(virt_addr_space->address);
576 virt_addr_space->address = NULL;
577 virt_addr_space->size = 0;
579 mutex_unlock(&tpci200->mutex);
583 static int tpci200_slot_unregister(struct ipack_device *dev)
585 struct tpci200_board *tpci200;
590 tpci200 = check_slot(dev);
594 tpci200_free_irq(dev);
596 if (mutex_lock_interruptible(&tpci200->mutex))
599 tpci200->slots[dev->slot].dev = NULL;
600 ipack_device_unregister(dev);
601 mutex_unlock(&tpci200->mutex);
606 static int tpci200_slot_map_space(struct ipack_device *dev,
607 unsigned int memory_size, int space)
610 unsigned int size_to_map;
611 void __iomem *phys_address;
612 struct ipack_addr_space *virt_addr_space;
613 struct tpci200_board *tpci200;
615 tpci200 = check_slot(dev);
619 if (mutex_lock_interruptible(&tpci200->mutex))
624 if (dev->io_space.address != NULL) {
626 "Slot [%d:%d] IO space already mapped !\n",
627 tpci200->number, dev->slot);
631 virt_addr_space = &dev->io_space;
633 phys_address = tpci200->slots[dev->slot].io_phys.address;
634 size_to_map = tpci200->slots[dev->slot].io_phys.size;
637 if (dev->id_space.address != NULL) {
639 "Slot [%d:%d] ID space already mapped !\n",
640 tpci200->number, dev->slot);
644 virt_addr_space = &dev->id_space;
646 phys_address = tpci200->slots[dev->slot].id_phys.address;
647 size_to_map = tpci200->slots[dev->slot].id_phys.size;
649 case IPACK_MEM_SPACE:
650 if (dev->mem_space.address != NULL) {
652 "Slot [%d:%d] MEM space already mapped !\n",
653 tpci200->number, dev->slot);
657 virt_addr_space = &dev->mem_space;
659 if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
661 "Slot [%d:%d] request is 0x%X memory, only 0x%X available !\n",
662 dev->bus_nr, dev->slot, memory_size,
663 tpci200->slots[dev->slot].mem_phys.size);
668 phys_address = tpci200->slots[dev->slot].mem_phys.address;
669 size_to_map = memory_size;
672 dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
673 tpci200->number, dev->slot, space);
678 virt_addr_space->size = size_to_map;
679 virt_addr_space->address =
680 ioremap_nocache((unsigned long)phys_address, size_to_map);
683 mutex_unlock(&tpci200->mutex);
687 static int tpci200_request_irq(struct ipack_device *dev, int vector,
688 int (*handler)(void *), void *arg)
691 struct slot_irq *slot_irq;
692 struct tpci200_board *tpci200;
694 tpci200 = check_slot(dev);
698 if (mutex_lock_interruptible(&tpci200->mutex))
701 if (tpci200->slots[dev->slot].irq != NULL) {
703 "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
709 slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
710 if (slot_irq == NULL) {
712 "Slot [%d:%d] unable to allocate memory for IRQ !\n",
713 dev->bus_nr, dev->slot);
719 * WARNING: Setup Interrupt Vector in the IndustryPack device
720 * before an IRQ request.
721 * Read the User Manual of your IndustryPack device to know
722 * where to write the vector in memory.
724 slot_irq->vector = vector;
725 slot_irq->handler = handler;
728 tpci200->slots[dev->slot].irq = slot_irq;
729 res = __tpci200_request_irq(tpci200, dev);
732 mutex_unlock(&tpci200->mutex);
736 static void tpci200_uninstall(struct tpci200_board *tpci200)
740 for (i = 0; i < TPCI200_NB_SLOT; i++)
741 tpci200_slot_unregister(tpci200->slots[i].dev);
743 tpci200_unregister(tpci200);
744 kfree(tpci200->slots);
747 static struct ipack_bus_ops tpci200_bus_ops = {
748 .map_space = tpci200_slot_map_space,
749 .unmap_space = tpci200_slot_unmap_space,
750 .request_irq = tpci200_request_irq,
751 .free_irq = tpci200_free_irq,
752 .read8 = tpci200_read8,
753 .read16 = tpci200_read16,
754 .read32 = tpci200_read32,
755 .write8 = tpci200_write8,
756 .write16 = tpci200_write16,
757 .write32 = tpci200_write32,
758 .remove_device = tpci200_slot_unregister,
761 static int tpci200_install(struct tpci200_board *tpci200)
765 tpci200->slots = kzalloc(
766 TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
767 if (tpci200->slots == NULL)
770 res = tpci200_register(tpci200);
772 kfree(tpci200->slots);
773 tpci200->slots = NULL;
777 mutex_init(&tpci200->mutex);
781 static int tpci200_pciprobe(struct pci_dev *pdev,
782 const struct pci_device_id *id)
785 struct tpci200_board *tpci200;
787 tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
791 tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
792 if (!tpci200->info) {
797 /* Save struct pci_dev pointer */
798 tpci200->info->pdev = pdev;
799 tpci200->info->id_table = (struct pci_device_id *)id;
801 /* register the device and initialize it */
802 ret = tpci200_install(tpci200);
804 dev_err(&pdev->dev, "error during tpci200 install\n");
806 goto out_err_install;
809 /* Register the carrier in the industry pack bus driver */
810 tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
813 if (!tpci200->info->ipack_bus) {
815 "error registering the carrier on ipack driver\n");
817 goto out_err_bus_register;
820 /* save the bus number given by ipack to logging purpose */
821 tpci200->number = tpci200->info->ipack_bus->bus_nr;
822 dev_set_drvdata(&pdev->dev, tpci200);
825 * Give the same IRQ number as the slot number.
826 * The TPCI200 has assigned his own two IRQ by PCI bus driver
828 for (i = 0; i < TPCI200_NB_SLOT; i++)
829 tpci200->slots[i].dev =
830 ipack_device_register(tpci200->info->ipack_bus, i, i);
833 out_err_bus_register:
834 tpci200_uninstall(tpci200);
836 kfree(tpci200->info);
842 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
844 tpci200_uninstall(tpci200);
845 ipack_bus_unregister(tpci200->info->ipack_bus);
846 kfree(tpci200->info);
850 static void __devexit tpci200_pci_remove(struct pci_dev *dev)
852 struct tpci200_board *tpci200 = pci_get_drvdata(dev);
854 __tpci200_pci_remove(tpci200);
857 static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
858 { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
859 TPCI200_SUBDEVICE_ID },
863 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
865 static struct pci_driver tpci200_pci_drv = {
867 .id_table = tpci200_idtable,
868 .probe = tpci200_pciprobe,
869 .remove = __devexit_p(tpci200_pci_remove),
872 static int __init tpci200_drvr_init_module(void)
874 return pci_register_driver(&tpci200_pci_drv);
877 static void __exit tpci200_drvr_exit_module(void)
879 pci_unregister_driver(&tpci200_pci_drv);
882 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
883 MODULE_LICENSE("GPL");
884 module_init(tpci200_drvr_init_module);
885 module_exit(tpci200_drvr_exit_module);