drivers/staging/ipack/bridges/tpci200.c

   1 /**
   2  * tpci200.c
   3  *
   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
   8  *
   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.
  12  */
  13
  14 #include <linux/module.h>
  15 #include "tpci200.h"
  16
  17 static struct ipack_bus_ops tpci200_bus_ops;
  18
  19 /* TPCI200 controls registers */
  20 static int control_reg[] = {
  21         TPCI200_CONTROL_A_REG,
  22         TPCI200_CONTROL_B_REG,
  23         TPCI200_CONTROL_C_REG,
  24         TPCI200_CONTROL_D_REG
  25 };
  26
  27 static int tpci200_slot_unregister(struct ipack_device *dev);
  28
  29 static struct tpci200_board *check_slot(struct ipack_device *dev)
  30 {
  31         struct tpci200_board *tpci200;
  32
  33         if (dev == NULL)
  34                 return NULL;
  35
  36
  37         tpci200 = dev_get_drvdata(dev->bus->parent);
  38
  39         if (tpci200 == NULL) {
  40                 dev_info(&dev->dev, "carrier board not found\n");
  41                 return NULL;
  42         }
  43
  44         if (dev->slot >= TPCI200_NB_SLOT) {
  45                 dev_info(&dev->dev,
  46                          "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
  47                          dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
  48                 return NULL;
  49         }
  50
  51         return tpci200;
  52 }
  53
  54 static inline unsigned char __tpci200_read8(void __iomem *address,
  55                                             unsigned long offset)
  56 {
  57         return ioread8(address + (offset^1));
  58 }
  59
  60 static inline unsigned short __tpci200_read16(void __iomem *address,
  61                                               unsigned long offset)
  62 {
  63         return ioread16(address + offset);
  64 }
  65
  66 static inline unsigned int __tpci200_read32(void __iomem *address,
  67                                             unsigned long offset)
  68 {
  69         return swahw32(ioread32(address + offset));
  70 }
  71
  72 static inline void __tpci200_write8(unsigned char value,
  73                                     void __iomem *address, unsigned long offset)
  74 {
  75         iowrite8(value, address+(offset^1));
  76 }
  77
  78 static inline void __tpci200_write16(unsigned short value,
  79                                      void __iomem *address,
  80                                      unsigned long offset)
  81 {
  82         iowrite16(value, address+offset);
  83 }
  84
  85 static inline void __tpci200_write32(unsigned int value,
  86                                      void __iomem *address,
  87                                      unsigned long offset)
  88 {
  89         iowrite32(swahw32(value), address+offset);
  90 }
  91
  92 static struct ipack_addr_space *get_slot_address_space(struct ipack_device *dev,
  93                                                        int space)
  94 {
  95         struct ipack_addr_space *addr;
  96
  97         switch (space) {
  98         case IPACK_IO_SPACE:
  99                 addr = &dev->io_space;
 100                 break;
 101         case IPACK_ID_SPACE:
 102                 addr = &dev->id_space;
 103                 break;
 104         case IPACK_MEM_SPACE:
 105                 addr = &dev->mem_space;
 106                 break;
 107         default:
 108                 dev_err(&dev->dev,
 109                         "Slot [%d:%d] space number %d doesn't exist !\n",
 110                         dev->bus_nr, dev->slot, space);
 111                 return NULL;
 112                 break;
 113         }
 114
 115         if ((addr->size == 0) || (addr->address == NULL)) {
 116                 dev_err(&dev->dev, "Error, slot space not mapped !\n");
 117                 return NULL;
 118         }
 119
 120         return addr;
 121 }
 122
 123 static int tpci200_read8(struct ipack_device *dev, int space,
 124                          unsigned long offset, unsigned char *value)
 125 {
 126         struct ipack_addr_space *addr;
 127         struct tpci200_board *tpci200;
 128
 129         tpci200 = check_slot(dev);
 130         if (tpci200 == NULL)
 131                 return -EINVAL;
 132
 133         addr = get_slot_address_space(dev, space);
 134         if (addr == NULL)
 135                 return -EINVAL;
 136
 137         if (offset >= addr->size) {
 138                 dev_err(&dev->dev, "Error, slot space offset error !\n");
 139                 return -EFAULT;
 140         }
 141
 142         *value = __tpci200_read8(addr->address, offset);
 143
 144         return 0;
 145 }
 146
 147 static int tpci200_read16(struct ipack_device *dev, int space,
 148                           unsigned long offset, unsigned short *value)
 149 {
 150         struct ipack_addr_space *addr;
 151         struct tpci200_board *tpci200;
 152
 153         tpci200 = check_slot(dev);
 154         if (tpci200 == NULL)
 155                 return -EINVAL;
 156
 157         addr = get_slot_address_space(dev, space);
 158         if (addr == NULL)
 159                 return -EINVAL;
 160
 161         if ((offset+2) >= addr->size) {
 162                 dev_err(&dev->dev, "Error, slot space offset error !\n");
 163                 return -EFAULT;
 164         }
 165         *value = __tpci200_read16(addr->address, offset);
 166
 167         return 0;
 168 }
 169
 170 static int tpci200_read32(struct ipack_device *dev, int space,
 171                           unsigned long offset, unsigned int *value)
 172 {
 173         struct ipack_addr_space *addr;
 174         struct tpci200_board *tpci200;
 175
 176         tpci200 = check_slot(dev);
 177         if (tpci200 == NULL)
 178                 return -EINVAL;
 179
 180         addr = get_slot_address_space(dev, space);
 181         if (addr == NULL)
 182                 return -EINVAL;
 183
 184         if ((offset+4) >= addr->size) {
 185                 dev_err(&dev->dev, "Error, slot space offset error !\n");
 186                 return -EFAULT;
 187         }
 188
 189         *value = __tpci200_read32(addr->address, offset);
 190
 191         return 0;
 192 }
 193
 194 static int tpci200_write8(struct ipack_device *dev, int space,
 195                           unsigned long offset, unsigned char value)
 196 {
 197         struct ipack_addr_space *addr;
 198         struct tpci200_board *tpci200;
 199
 200         tpci200 = check_slot(dev);
 201         if (tpci200 == NULL)
 202                 return -EINVAL;
 203
 204         addr = get_slot_address_space(dev, space);
 205         if (addr == NULL)
 206                 return -EINVAL;
 207
 208         if (offset >= addr->size) {
 209                 dev_err(&dev->dev, "Error, slot space offset error !\n");
 210                 return -EFAULT;
 211         }
 212
 213         __tpci200_write8(value, addr->address, offset);
 214
 215         return 0;
 216 }
 217
 218 static int tpci200_write16(struct ipack_device *dev, int space,
 219                            unsigned long offset, unsigned short value)
 220 {
 221         struct ipack_addr_space *addr;
 222         struct tpci200_board *tpci200;
 223
 224         tpci200 = check_slot(dev);
 225         if (tpci200 == NULL)
 226                 return -EINVAL;
 227
 228         addr = get_slot_address_space(dev, space);
 229         if (addr == NULL)
 230                 return -EINVAL;
 231
 232         if ((offset+2) >= addr->size) {
 233                 dev_err(&dev->dev, "Error, slot space offset error !\n");
 234                 return -EFAULT;
 235         }
 236
 237         __tpci200_write16(value, addr->address, offset);
 238
 239         return 0;
 240 }
 241
 242 static int tpci200_write32(struct ipack_device *dev, int space,
 243                            unsigned long offset, unsigned int value)
 244 {
 245         struct ipack_addr_space *addr;
 246         struct tpci200_board *tpci200;
 247
 248         tpci200 = check_slot(dev);
 249         if (tpci200 == NULL)
 250                 return -EINVAL;
 251
 252         addr = get_slot_address_space(dev, space);
 253         if (addr == NULL)
 254                 return -EINVAL;
 255
 256         if ((offset+4) >= addr->size) {
 257                 dev_err(&dev->dev, "Error, slot space offset error !\n");
 258                 return -EFAULT;
 259         }
 260
 261         __tpci200_write32(value, addr->address, offset);
 262
 263         return 0;
 264 }
 265
 266 static void tpci200_unregister(struct tpci200_board *tpci200)
 267 {
 268         int i;
 269
 270         free_irq(tpci200->info->pdev->irq, (void *) tpci200);
 271
 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);
 275
 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);
 279
 280         pci_disable_device(tpci200->info->pdev);
 281         pci_dev_put(tpci200->info->pdev);
 282
 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;
 290         }
 291 }
 292
 293 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
 294 {
 295         struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
 296         int i;
 297         unsigned short status_reg, reg_value;
 298         unsigned short unhandled_ints = 0;
 299         irqreturn_t ret = IRQ_NONE;
 300
 301         /* Read status register */
 302         status_reg = readw(tpci200->info->interface_regs +
 303                            TPCI200_STATUS_REG);
 304
 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)))) {
 311
 312                                 ret = tpci200->slots[i].irq->handler(tpci200->slots[i].irq->arg);
 313
 314                                 /* Dummy reads */
 315                                 readw(tpci200->slots[i].dev->io_space.address +
 316                                       0xC0);
 317                                 readw(tpci200->slots[i].dev->io_space.address +
 318                                       0xC2);
 319
 320                                 unhandled_ints &= ~(((TPCI200_A_INT0 | TPCI200_A_INT1) << (2*i)));
 321                         }
 322                 }
 323         }
 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",
 330                                          tpci200->number, i);
 331                                 reg_value = readw(
 332                                         tpci200->info->interface_regs +
 333                                         control_reg[i]);
 334                                 reg_value &=
 335                                         ~(TPCI200_INT0_EN | TPCI200_INT1_EN);
 336                                 writew(reg_value,
 337                                        (tpci200->info->interface_regs +
 338                                         control_reg[i]));
 339                         }
 340                 }
 341         }
 342
 343         return ret;
 344 }
 345
 346 static int tpci200_register(struct tpci200_board *tpci200)
 347 {
 348         int i;
 349         int res;
 350         unsigned long ioidint_base;
 351         unsigned long mem_base;
 352         unsigned short slot_ctrl;
 353
 354         if (pci_enable_device(tpci200->info->pdev) < 0)
 355                 return -ENODEV;
 356
 357         /* Request IP interface register (Bar 2) */
 358         res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
 359                                  "Carrier IP interface registers");
 360         if (res) {
 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;
 366         }
 367
 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");
 372         if (res) {
 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;
 378         }
 379
 380         /* Request MEM space (Bar 4) */
 381         res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
 382                                  "Carrier MEM space");
 383         if (res) {
 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;
 389         }
 390
 391         /* Map internal tpci200 driver user space */
 392         tpci200->info->interface_regs =
 393                 ioremap(pci_resource_start(tpci200->info->pdev,
 394                                            TPCI200_IP_INTERFACE_BAR),
 395                         TPCI200_IFACE_SIZE);
 396         tpci200->info->ioidint_space =
 397                 ioremap(pci_resource_start(tpci200->info->pdev,
 398                                            TPCI200_IO_ID_INT_SPACES_BAR),
 399                         TPCI200_IOIDINT_SIZE);
 400         tpci200->info->mem8_space =
 401                 ioremap(pci_resource_start(tpci200->info->pdev,
 402                                            TPCI200_MEM8_SPACE_BAR),
 403                         TPCI200_MEM8_SIZE);
 404
 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);
 409
 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
 416          * clock rate 8 MHz
 417          */
 418         slot_ctrl = 0;
 419
 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;
 426
 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;
 431
 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;
 435
 436                 writew(slot_ctrl, (tpci200->info->interface_regs +
 437                                    control_reg[i]));
 438         }
 439
 440         res = request_irq(tpci200->info->pdev->irq,
 441                           tpci200_interrupt, IRQF_SHARED,
 442                           KBUILD_MODNAME, (void *) tpci200);
 443         if (res) {
 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;
 449         }
 450
 451         return 0;
 452
 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);
 457 out_disable_pci:
 458         pci_disable_device(tpci200->info->pdev);
 459         return res;
 460 }
 461
 462 static int __tpci200_request_irq(struct tpci200_board *tpci200,
 463                                  struct ipack_device *dev)
 464 {
 465         unsigned short slot_ctrl;
 466
 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
 473          * clock rate 8 MHz
 474          */
 475         slot_ctrl = TPCI200_INT0_EN | TPCI200_INT1_EN;
 476         writew(slot_ctrl, (tpci200->info->interface_regs +
 477                            control_reg[dev->slot]));
 478
 479         return 0;
 480 }
 481
 482 static void __tpci200_free_irq(struct tpci200_board *tpci200,
 483                                struct ipack_device *dev)
 484 {
 485         unsigned short slot_ctrl;
 486
 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
 493          * clock rate 8 MHz
 494          */
 495         slot_ctrl = 0;
 496         writew(slot_ctrl, (tpci200->info->interface_regs +
 497                            control_reg[dev->slot]));
 498 }
 499
 500 static int tpci200_free_irq(struct ipack_device *dev)
 501 {
 502         struct slot_irq *slot_irq;
 503         struct tpci200_board *tpci200;
 504
 505         tpci200 = check_slot(dev);
 506         if (tpci200 == NULL)
 507                 return -EINVAL;
 508
 509         if (mutex_lock_interruptible(&tpci200->mutex))
 510                 return -ERESTARTSYS;
 511
 512         if (tpci200->slots[dev->slot].irq == NULL) {
 513                 mutex_unlock(&tpci200->mutex);
 514                 return -EINVAL;
 515         }
 516
 517         __tpci200_free_irq(tpci200, dev);
 518         slot_irq = tpci200->slots[dev->slot].irq;
 519         tpci200->slots[dev->slot].irq = NULL;
 520         kfree(slot_irq);
 521
 522         mutex_unlock(&tpci200->mutex);
 523         return 0;
 524 }
 525
 526 static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
 527 {
 528         struct ipack_addr_space *virt_addr_space;
 529         struct tpci200_board *tpci200;
 530
 531         tpci200 = check_slot(dev);
 532         if (tpci200 == NULL)
 533                 return -EINVAL;
 534
 535         if (mutex_lock_interruptible(&tpci200->mutex))
 536                 return -ERESTARTSYS;
 537
 538         switch (space) {
 539         case IPACK_IO_SPACE:
 540                 if (dev->io_space.address == NULL) {
 541                         dev_info(&dev->dev,
 542                                  "Slot [%d:%d] IO space not mapped !\n",
 543                                  dev->bus_nr, dev->slot);
 544                         goto out_unlock;
 545                 }
 546                 virt_addr_space = &dev->io_space;
 547                 break;
 548         case IPACK_ID_SPACE:
 549                 if (dev->id_space.address == NULL) {
 550                         dev_info(&dev->dev,
 551                                  "Slot [%d:%d] ID space not mapped !\n",
 552                                  dev->bus_nr, dev->slot);
 553                         goto out_unlock;
 554                 }
 555                 virt_addr_space = &dev->id_space;
 556                 break;
 557         case IPACK_MEM_SPACE:
 558                 if (dev->mem_space.address == NULL) {
 559                         dev_info(&dev->dev,
 560                                  "Slot [%d:%d] MEM space not mapped !\n",
 561                                  dev->bus_nr, dev->slot);
 562                         goto out_unlock;
 563                 }
 564                 virt_addr_space = &dev->mem_space;
 565                 break;
 566         default:
 567                 dev_err(&dev->dev,
 568                         "Slot [%d:%d] space number %d doesn't exist !\n",
 569                         dev->bus_nr, dev->slot, space);
 570                 mutex_unlock(&tpci200->mutex);
 571                 return -EINVAL;
 572         }
 573
 574         iounmap(virt_addr_space->address);
 575
 576         virt_addr_space->address = NULL;
 577         virt_addr_space->size = 0;
 578 out_unlock:
 579         mutex_unlock(&tpci200->mutex);
 580         return 0;
 581 }
 582
 583 static int tpci200_slot_unregister(struct ipack_device *dev)
 584 {
 585         struct tpci200_board *tpci200;
 586
 587         if (dev == NULL)
 588                 return -ENODEV;
 589
 590         tpci200 = check_slot(dev);
 591         if (tpci200 == NULL)
 592                 return -EINVAL;
 593
 594         tpci200_free_irq(dev);
 595
 596         if (mutex_lock_interruptible(&tpci200->mutex))
 597                 return -ERESTARTSYS;
 598
 599         tpci200->slots[dev->slot].dev = NULL;
 600         ipack_device_unregister(dev);
 601         mutex_unlock(&tpci200->mutex);
 602
 603         return 0;
 604 }
 605
 606 static int tpci200_slot_map_space(struct ipack_device *dev,
 607                                   unsigned int memory_size, int space)
 608 {
 609         int res = 0;
 610         unsigned int size_to_map;
 611         void __iomem *phys_address;
 612         struct ipack_addr_space *virt_addr_space;
 613         struct tpci200_board *tpci200;
 614
 615         tpci200 = check_slot(dev);
 616         if (tpci200 == NULL)
 617                 return -EINVAL;
 618
 619         if (mutex_lock_interruptible(&tpci200->mutex))
 620                 return -ERESTARTSYS;
 621
 622         switch (space) {
 623         case IPACK_IO_SPACE:
 624                 if (dev->io_space.address != NULL) {
 625                         dev_err(&dev->dev,
 626                                 "Slot [%d:%d] IO space already mapped !\n",
 627                                 tpci200->number, dev->slot);
 628                         res = -EINVAL;
 629                         goto out_unlock;
 630                 }
 631                 virt_addr_space = &dev->io_space;
 632
 633                 phys_address = tpci200->slots[dev->slot].io_phys.address;
 634                 size_to_map = tpci200->slots[dev->slot].io_phys.size;
 635                 break;
 636         case IPACK_ID_SPACE:
 637                 if (dev->id_space.address != NULL) {
 638                         dev_err(&dev->dev,
 639                                 "Slot [%d:%d] ID space already mapped !\n",
 640                                 tpci200->number, dev->slot);
 641                         res = -EINVAL;
 642                         goto out_unlock;
 643                 }
 644                 virt_addr_space = &dev->id_space;
 645
 646                 phys_address = tpci200->slots[dev->slot].id_phys.address;
 647                 size_to_map = tpci200->slots[dev->slot].id_phys.size;
 648                 break;
 649         case IPACK_MEM_SPACE:
 650                 if (dev->mem_space.address != NULL) {
 651                         dev_err(&dev->dev,
 652                                 "Slot [%d:%d] MEM space already mapped !\n",
 653                                 tpci200->number, dev->slot);
 654                         res = -EINVAL;
 655                         goto out_unlock;
 656                 }
 657                 virt_addr_space = &dev->mem_space;
 658
 659                 if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
 660                         dev_err(&dev->dev,
 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);
 664                         res = -EINVAL;
 665                         goto out_unlock;
 666                 }
 667
 668                 phys_address = tpci200->slots[dev->slot].mem_phys.address;
 669                 size_to_map = memory_size;
 670                 break;
 671         default:
 672                 dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
 673                         tpci200->number, dev->slot, space);
 674                 res = -EINVAL;
 675                 goto out_unlock;
 676         }
 677
 678         virt_addr_space->size = size_to_map;
 679         virt_addr_space->address =
 680                 ioremap((unsigned long)phys_address, size_to_map);
 681
 682 out_unlock:
 683         mutex_unlock(&tpci200->mutex);
 684         return res;
 685 }
 686
 687 static int tpci200_request_irq(struct ipack_device *dev, int vector,
 688                                int (*handler)(void *), void *arg)
 689 {
 690         int res;
 691         struct slot_irq *slot_irq;
 692         struct tpci200_board *tpci200;
 693
 694         tpci200 = check_slot(dev);
 695         if (tpci200 == NULL)
 696                 return -EINVAL;
 697
 698         if (mutex_lock_interruptible(&tpci200->mutex))
 699                 return -ERESTARTSYS;
 700
 701         if (tpci200->slots[dev->slot].irq != NULL) {
 702                 dev_err(&dev->dev,
 703                         "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
 704                         dev->slot);
 705                 res = -EINVAL;
 706                 goto out_unlock;
 707         }
 708
 709         slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
 710         if (slot_irq == NULL) {
 711                 dev_err(&dev->dev,
 712                         "Slot [%d:%d] unable to allocate memory for IRQ !\n",
 713                         dev->bus_nr, dev->slot);
 714                 res = -ENOMEM;
 715                 goto out_unlock;
 716         }
 717
 718         /*
 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.
 723          */
 724         slot_irq->vector = vector;
 725         slot_irq->handler = handler;
 726         slot_irq->arg = arg;
 727
 728         tpci200->slots[dev->slot].irq = slot_irq;
 729         res = __tpci200_request_irq(tpci200, dev);
 730
 731 out_unlock:
 732         mutex_unlock(&tpci200->mutex);
 733         return res;
 734 }
 735
 736 static void tpci200_uninstall(struct tpci200_board *tpci200)
 737 {
 738         int i;
 739
 740         for (i = 0; i < TPCI200_NB_SLOT; i++)
 741                 tpci200_slot_unregister(tpci200->slots[i].dev);
 742
 743         tpci200_unregister(tpci200);
 744         kfree(tpci200->slots);
 745 }
 746
 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,
 759 };
 760
 761 static int tpci200_install(struct tpci200_board *tpci200)
 762 {
 763         int res;
 764
 765         tpci200->slots = kzalloc(
 766                 TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
 767         if (tpci200->slots == NULL)
 768                 return -ENOMEM;
 769
 770         res = tpci200_register(tpci200);
 771         if (res) {
 772                 kfree(tpci200->slots);
 773                 tpci200->slots = NULL;
 774                 return res;
 775         }
 776
 777         mutex_init(&tpci200->mutex);
 778         return 0;
 779 }
 780
 781 static int tpci200_pciprobe(struct pci_dev *pdev,
 782                             const struct pci_device_id *id)
 783 {
 784         int ret, i;
 785         struct tpci200_board *tpci200;
 786
 787         tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
 788         if (!tpci200)
 789                 return -ENOMEM;
 790
 791         tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
 792         if (!tpci200->info) {
 793                 kfree(tpci200);
 794                 return -ENOMEM;
 795         }
 796
 797         /* Save struct pci_dev pointer */
 798         tpci200->info->pdev = pdev;
 799         tpci200->info->id_table = (struct pci_device_id *)id;
 800
 801         /* register the device and initialize it */
 802         ret = tpci200_install(tpci200);
 803         if (ret) {
 804                 dev_err(&pdev->dev, "Error during tpci200 install !\n");
 805                 kfree(tpci200->info);
 806                 kfree(tpci200);
 807                 return -ENODEV;
 808         }
 809
 810         /* Register the carrier in the industry pack bus driver */
 811         tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
 812                                                       TPCI200_NB_SLOT,
 813                                                       &tpci200_bus_ops);
 814         if (!tpci200->info->ipack_bus) {
 815                 dev_err(&pdev->dev,
 816                         "error registering the carrier on ipack driver\n");
 817                 tpci200_uninstall(tpci200);
 818                 kfree(tpci200->info);
 819                 kfree(tpci200);
 820                 return -EFAULT;
 821         }
 822
 823         /* save the bus number given by ipack to logging purpose */
 824         tpci200->number = tpci200->info->ipack_bus->bus_nr;
 825         dev_set_drvdata(&pdev->dev, tpci200);
 826
 827         /*
 828          * Give the same IRQ number as the slot number.
 829          * The TPCI200 has assigned his own two IRQ by PCI bus driver
 830          */
 831         for (i = 0; i < TPCI200_NB_SLOT; i++)
 832                 tpci200->slots[i].dev =
 833                         ipack_device_register(tpci200->info->ipack_bus, i, i);
 834         return ret;
 835 }
 836
 837 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
 838 {
 839         tpci200_uninstall(tpci200);
 840         ipack_bus_unregister(tpci200->info->ipack_bus);
 841         kfree(tpci200->info);
 842         kfree(tpci200);
 843 }
 844
 845 static void __devexit tpci200_pci_remove(struct pci_dev *dev)
 846 {
 847         struct tpci200_board *tpci200 = pci_get_drvdata(dev);
 848
 849         __tpci200_pci_remove(tpci200);
 850 }
 851
 852 static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
 853         { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
 854           TPCI200_SUBDEVICE_ID },
 855         { 0, },
 856 };
 857
 858 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
 859
 860 static struct pci_driver tpci200_pci_drv = {
 861         .name = "tpci200",
 862         .id_table = tpci200_idtable,
 863         .probe = tpci200_pciprobe,
 864         .remove = __devexit_p(tpci200_pci_remove),
 865 };
 866
 867 static int __init tpci200_drvr_init_module(void)
 868 {
 869         return pci_register_driver(&tpci200_pci_drv);
 870 }
 871
 872 static void __exit tpci200_drvr_exit_module(void)
 873 {
 874         pci_unregister_driver(&tpci200_pci_drv);
 875 }
 876
 877 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
 878 MODULE_LICENSE("GPL");
 879 module_init(tpci200_drvr_init_module);
 880 module_exit(tpci200_drvr_exit_module);