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 <linux/slab.h>
  16 #include "tpci200.h"
  17
  18 static u16 tpci200_status_timeout[] = {
  19         TPCI200_A_TIMEOUT,
  20         TPCI200_B_TIMEOUT,
  21         TPCI200_C_TIMEOUT,
  22         TPCI200_D_TIMEOUT,
  23 };
  24
  25 static u16 tpci200_status_error[] = {
  26         TPCI200_A_ERROR,
  27         TPCI200_B_ERROR,
  28         TPCI200_C_ERROR,
  29         TPCI200_D_ERROR,
  30 };
  31
  32 static struct tpci200_board *check_slot(struct ipack_device *dev)
  33 {
  34         struct tpci200_board *tpci200;
  35
  36         if (dev == NULL)
  37                 return NULL;
  38
  39
  40         tpci200 = dev_get_drvdata(dev->bus->parent);
  41
  42         if (tpci200 == NULL) {
  43                 dev_info(&dev->dev, "carrier board not found\n");
  44                 return NULL;
  45         }
  46
  47         if (dev->slot >= TPCI200_NB_SLOT) {
  48                 dev_info(&dev->dev,
  49                          "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
  50                          dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
  51                 return NULL;
  52         }
  53
  54         return tpci200;
  55 }
  56
  57 static void tpci200_clear_mask(struct tpci200_board *tpci200,
  58                                __le16 __iomem *addr, u16 mask)
  59 {
  60         unsigned long flags;
  61         spin_lock_irqsave(&tpci200->regs_lock, flags);
  62         iowrite16(ioread16(addr) & (~mask), addr);
  63         spin_unlock_irqrestore(&tpci200->regs_lock, flags);
  64 }
  65
  66 static void tpci200_set_mask(struct tpci200_board *tpci200,
  67                              __le16 __iomem *addr, u16 mask)
  68 {
  69         unsigned long flags;
  70         spin_lock_irqsave(&tpci200->regs_lock, flags);
  71         iowrite16(ioread16(addr) | mask, addr);
  72         spin_unlock_irqrestore(&tpci200->regs_lock, flags);
  73 }
  74
  75 static void tpci200_unregister(struct tpci200_board *tpci200)
  76 {
  77         int i;
  78
  79         free_irq(tpci200->info->pdev->irq, (void *) tpci200);
  80
  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);
  85
  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);
  90
  91         pci_disable_device(tpci200->info->pdev);
  92         pci_dev_put(tpci200->info->pdev);
  93
  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;
 103         }
 104 }
 105
 106 static void tpci200_enable_irq(struct tpci200_board *tpci200,
 107                                int islot)
 108 {
 109         tpci200_set_mask(tpci200,
 110                         &tpci200->info->interface_regs->control[islot],
 111                         TPCI200_INT0_EN | TPCI200_INT1_EN);
 112 }
 113
 114 static void tpci200_disable_irq(struct tpci200_board *tpci200,
 115                                 int islot)
 116 {
 117         tpci200_clear_mask(tpci200,
 118                         &tpci200->info->interface_regs->control[islot],
 119                         TPCI200_INT0_EN | TPCI200_INT1_EN);
 120 }
 121
 122 static irqreturn_t tpci200_slot_irq(struct slot_irq *slot_irq)
 123 {
 124         irqreturn_t ret;
 125
 126         if (!slot_irq)
 127                 return -ENODEV;
 128         ret = slot_irq->handler(slot_irq->arg);
 129
 130         return ret;
 131 }
 132
 133 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
 134 {
 135         struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
 136         struct slot_irq *slot_irq;
 137         irqreturn_t ret;
 138         u16 status_reg;
 139         int i;
 140
 141         /* Read status register */
 142         status_reg = ioread16(&tpci200->info->interface_regs->status);
 143
 144         /* Did we cause the interrupt? */
 145         if (!(status_reg & TPCI200_SLOT_INT_MASK))
 146                 return IRQ_NONE;
 147
 148         /* callback to the IRQ handler for the corresponding slot */
 149         rcu_read_lock();
 150         for (i = 0; i < TPCI200_NB_SLOT; i++) {
 151                 if (!(status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2 * i))))
 152                         continue;
 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",
 158                                  tpci200->number, i);
 159                         tpci200_disable_irq(tpci200, i);
 160                 }
 161         }
 162         rcu_read_unlock();
 163
 164         return IRQ_HANDLED;
 165 }
 166
 167 static int tpci200_free_irq(struct ipack_device *dev)
 168 {
 169         struct slot_irq *slot_irq;
 170         struct tpci200_board *tpci200;
 171
 172         tpci200 = check_slot(dev);
 173         if (tpci200 == NULL)
 174                 return -EINVAL;
 175
 176         if (mutex_lock_interruptible(&tpci200->mutex))
 177                 return -ERESTARTSYS;
 178
 179         if (tpci200->slots[dev->slot].irq == NULL) {
 180                 mutex_unlock(&tpci200->mutex);
 181                 return -EINVAL;
 182         }
 183
 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);
 188         synchronize_rcu();
 189         kfree(slot_irq);
 190         mutex_unlock(&tpci200->mutex);
 191         return 0;
 192 }
 193
 194 static int tpci200_request_irq(struct ipack_device *dev,
 195                                irqreturn_t (*handler)(void *), void *arg)
 196 {
 197         int res = 0;
 198         struct slot_irq *slot_irq;
 199         struct tpci200_board *tpci200;
 200
 201         tpci200 = check_slot(dev);
 202         if (tpci200 == NULL)
 203                 return -EINVAL;
 204
 205         if (mutex_lock_interruptible(&tpci200->mutex))
 206                 return -ERESTARTSYS;
 207
 208         if (tpci200->slots[dev->slot].irq != NULL) {
 209                 dev_err(&dev->dev,
 210                         "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
 211                         dev->slot);
 212                 res = -EINVAL;
 213                 goto out_unlock;
 214         }
 215
 216         slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
 217         if (slot_irq == NULL) {
 218                 dev_err(&dev->dev,
 219                         "Slot [%d:%d] unable to allocate memory for IRQ !\n",
 220                         dev->bus_nr, dev->slot);
 221                 res = -ENOMEM;
 222                 goto out_unlock;
 223         }
 224
 225         /*
 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.
 230          */
 231         slot_irq->handler = handler;
 232         slot_irq->arg = arg;
 233         slot_irq->holder = dev;
 234
 235         rcu_assign_pointer(tpci200->slots[dev->slot].irq, slot_irq);
 236         tpci200_enable_irq(tpci200, dev->slot);
 237
 238 out_unlock:
 239         mutex_unlock(&tpci200->mutex);
 240         return res;
 241 }
 242
 243 static int tpci200_register(struct tpci200_board *tpci200)
 244 {
 245         int i;
 246         int res;
 247         unsigned long ioidint_base;
 248         unsigned long mem_base;
 249         unsigned short slot_ctrl;
 250
 251         if (pci_enable_device(tpci200->info->pdev) < 0)
 252                 return -ENODEV;
 253
 254         /* Request IP interface register (Bar 2) */
 255         res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
 256                                  "Carrier IP interface registers");
 257         if (res) {
 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;
 263         }
 264
 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");
 269         if (res) {
 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;
 275         }
 276
 277         /* Request MEM space (Bar 4) */
 278         res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
 279                                  "Carrier MEM space");
 280         if (res) {
 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;
 286         }
 287
 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),
 292                         TPCI200_IFACE_SIZE);
 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),
 300                         TPCI200_MEM8_SIZE);
 301
 302         /* Initialize lock that protects interface_regs */
 303         spin_lock_init(&tpci200->regs_lock);
 304
 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);
 309
 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
 316          * clock rate 8 MHz
 317          */
 318         slot_ctrl = 0;
 319
 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;
 326
 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;
 331
 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;
 336
 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;
 340
 341                 writew(slot_ctrl, &tpci200->info->interface_regs->control[i]);
 342         }
 343
 344         res = request_irq(tpci200->info->pdev->irq,
 345                           tpci200_interrupt, IRQF_SHARED,
 346                           KBUILD_MODNAME, (void *) tpci200);
 347         if (res) {
 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;
 353         }
 354
 355         return 0;
 356
 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);
 361 out_disable_pci:
 362         pci_disable_device(tpci200->info->pdev);
 363         return res;
 364 }
 365
 366 static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
 367 {
 368         struct ipack_addr_space *virt_addr_space;
 369         struct tpci200_board *tpci200;
 370
 371         tpci200 = check_slot(dev);
 372         if (tpci200 == NULL)
 373                 return -EINVAL;
 374
 375         if (mutex_lock_interruptible(&tpci200->mutex))
 376                 return -ERESTARTSYS;
 377
 378         switch (space) {
 379         case IPACK_IO_SPACE:
 380                 if (dev->io_space.address == NULL) {
 381                         dev_info(&dev->dev,
 382                                  "Slot [%d:%d] IO space not mapped !\n",
 383                                  dev->bus_nr, dev->slot);
 384                         goto out_unlock;
 385                 }
 386                 virt_addr_space = &dev->io_space;
 387                 break;
 388         case IPACK_ID_SPACE:
 389                 if (dev->id_space.address == NULL) {
 390                         dev_info(&dev->dev,
 391                                  "Slot [%d:%d] ID space not mapped !\n",
 392                                  dev->bus_nr, dev->slot);
 393                         goto out_unlock;
 394                 }
 395                 virt_addr_space = &dev->id_space;
 396                 break;
 397         case IPACK_INT_SPACE:
 398                 if (dev->int_space.address == NULL) {
 399                         dev_info(&dev->dev,
 400                                  "Slot [%d:%d] INT space not mapped !\n",
 401                                  dev->bus_nr, dev->slot);
 402                         goto out_unlock;
 403                 }
 404                 virt_addr_space = &dev->int_space;
 405                 break;
 406         case IPACK_MEM_SPACE:
 407                 if (dev->mem_space.address == NULL) {
 408                         dev_info(&dev->dev,
 409                                  "Slot [%d:%d] MEM space not mapped !\n",
 410                                  dev->bus_nr, dev->slot);
 411                         goto out_unlock;
 412                 }
 413                 virt_addr_space = &dev->mem_space;
 414                 break;
 415         default:
 416                 dev_err(&dev->dev,
 417                         "Slot [%d:%d] space number %d doesn't exist !\n",
 418                         dev->bus_nr, dev->slot, space);
 419                 mutex_unlock(&tpci200->mutex);
 420                 return -EINVAL;
 421         }
 422
 423         iounmap(virt_addr_space->address);
 424
 425         virt_addr_space->address = NULL;
 426         virt_addr_space->size = 0;
 427 out_unlock:
 428         mutex_unlock(&tpci200->mutex);
 429         return 0;
 430 }
 431
 432 static int tpci200_slot_map_space(struct ipack_device *dev,
 433                                   unsigned int memory_size, int space)
 434 {
 435         int res = 0;
 436         unsigned int size_to_map;
 437         void __iomem *phys_address;
 438         struct ipack_addr_space *virt_addr_space;
 439         struct tpci200_board *tpci200;
 440
 441         tpci200 = check_slot(dev);
 442         if (tpci200 == NULL)
 443                 return -EINVAL;
 444
 445         if (mutex_lock_interruptible(&tpci200->mutex))
 446                 return -ERESTARTSYS;
 447
 448         switch (space) {
 449         case IPACK_IO_SPACE:
 450                 if (dev->io_space.address != NULL) {
 451                         dev_err(&dev->dev,
 452                                 "Slot [%d:%d] IO space already mapped !\n",
 453                                 tpci200->number, dev->slot);
 454                         res = -EINVAL;
 455                         goto out_unlock;
 456                 }
 457                 virt_addr_space = &dev->io_space;
 458
 459                 phys_address = tpci200->slots[dev->slot].io_phys.address;
 460                 size_to_map = tpci200->slots[dev->slot].io_phys.size;
 461                 break;
 462         case IPACK_ID_SPACE:
 463                 if (dev->id_space.address != NULL) {
 464                         dev_err(&dev->dev,
 465                                 "Slot [%d:%d] ID space already mapped !\n",
 466                                 tpci200->number, dev->slot);
 467                         res = -EINVAL;
 468                         goto out_unlock;
 469                 }
 470                 virt_addr_space = &dev->id_space;
 471
 472                 phys_address = tpci200->slots[dev->slot].id_phys.address;
 473                 size_to_map = tpci200->slots[dev->slot].id_phys.size;
 474                 break;
 475         case IPACK_INT_SPACE:
 476                 if (dev->int_space.address != NULL) {
 477                         dev_err(&dev->dev,
 478                                 "Slot [%d:%d] INT space already mapped !\n",
 479                                 tpci200->number, dev->slot);
 480                         res = -EINVAL;
 481                         goto out_unlock;
 482                 }
 483                 virt_addr_space = &dev->int_space;
 484
 485                 phys_address = tpci200->slots[dev->slot].int_phys.address;
 486                 size_to_map = tpci200->slots[dev->slot].int_phys.size;
 487                 break;
 488         case IPACK_MEM_SPACE:
 489                 if (dev->mem_space.address != NULL) {
 490                         dev_err(&dev->dev,
 491                                 "Slot [%d:%d] MEM space already mapped !\n",
 492                                 tpci200->number, dev->slot);
 493                         res = -EINVAL;
 494                         goto out_unlock;
 495                 }
 496                 virt_addr_space = &dev->mem_space;
 497
 498                 if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
 499                         dev_err(&dev->dev,
 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);
 503                         res = -EINVAL;
 504                         goto out_unlock;
 505                 }
 506
 507                 phys_address = tpci200->slots[dev->slot].mem_phys.address;
 508                 size_to_map = memory_size;
 509                 break;
 510         default:
 511                 dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
 512                         tpci200->number, dev->slot, space);
 513                 res = -EINVAL;
 514                 goto out_unlock;
 515         }
 516
 517         virt_addr_space->size = size_to_map;
 518         virt_addr_space->address =
 519                 ioremap_nocache((unsigned long)phys_address, size_to_map);
 520
 521 out_unlock:
 522         mutex_unlock(&tpci200->mutex);
 523         return res;
 524 }
 525
 526 static int tpci200_get_clockrate(struct ipack_device *dev)
 527 {
 528         struct tpci200_board *tpci200 = check_slot(dev);
 529         __le16 __iomem *addr;
 530
 531         if (!tpci200)
 532                 return -ENODEV;
 533
 534         addr = &tpci200->info->interface_regs->control[dev->slot];
 535         return (ioread16(addr) & TPCI200_CLK32) ? 32 : 8;
 536 }
 537
 538 static int tpci200_set_clockrate(struct ipack_device *dev, int mherz)
 539 {
 540         struct tpci200_board *tpci200 = check_slot(dev);
 541         __le16 __iomem *addr;
 542
 543         if (!tpci200)
 544                 return -ENODEV;
 545
 546         addr = &tpci200->info->interface_regs->control[dev->slot];
 547
 548         switch (mherz) {
 549         case 8:
 550                 tpci200_clear_mask(tpci200, addr, TPCI200_CLK32);
 551                 break;
 552         case 32:
 553                 tpci200_set_mask(tpci200, addr, TPCI200_CLK32);
 554                 break;
 555         default:
 556                 return -EINVAL;
 557         }
 558         return 0;
 559 }
 560
 561 static int tpci200_get_error(struct ipack_device *dev)
 562 {
 563         struct tpci200_board *tpci200 = check_slot(dev);
 564         __le16 __iomem *addr;
 565         u16 mask;
 566
 567         if (!tpci200)
 568                 return -ENODEV;
 569
 570         addr = &tpci200->info->interface_regs->status;
 571         mask = tpci200_status_error[dev->slot];
 572         return (ioread16(addr) & mask) ? 1 : 0;
 573 }
 574
 575 static int tpci200_get_timeout(struct ipack_device *dev)
 576 {
 577         struct tpci200_board *tpci200 = check_slot(dev);
 578         __le16 __iomem *addr;
 579         u16 mask;
 580
 581         if (!tpci200)
 582                 return -ENODEV;
 583
 584         addr = &tpci200->info->interface_regs->status;
 585         mask = tpci200_status_timeout[dev->slot];
 586
 587         return (ioread16(addr) & mask) ? 1 : 0;
 588 }
 589
 590 static int tpci200_reset_timeout(struct ipack_device *dev)
 591 {
 592         struct tpci200_board *tpci200 = check_slot(dev);
 593         __le16 __iomem *addr;
 594         u16 mask;
 595
 596         if (!tpci200)
 597                 return -ENODEV;
 598
 599         addr = &tpci200->info->interface_regs->status;
 600         mask = tpci200_status_timeout[dev->slot];
 601
 602         iowrite16(mask, addr);
 603         return 0;
 604 }
 605
 606 static void tpci200_uninstall(struct tpci200_board *tpci200)
 607 {
 608         tpci200_unregister(tpci200);
 609         kfree(tpci200->slots);
 610 }
 611
 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,
 622 };
 623
 624 static int tpci200_install(struct tpci200_board *tpci200)
 625 {
 626         int res;
 627
 628         tpci200->slots = kzalloc(
 629                 TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
 630         if (tpci200->slots == NULL)
 631                 return -ENOMEM;
 632
 633         res = tpci200_register(tpci200);
 634         if (res) {
 635                 kfree(tpci200->slots);
 636                 tpci200->slots = NULL;
 637                 return res;
 638         }
 639
 640         mutex_init(&tpci200->mutex);
 641         return 0;
 642 }
 643
 644 static int tpci200_pci_probe(struct pci_dev *pdev,
 645                              const struct pci_device_id *id)
 646 {
 647         int ret, i;
 648         struct tpci200_board *tpci200;
 649         u32 reg32;
 650
 651         tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
 652         if (!tpci200)
 653                 return -ENOMEM;
 654
 655         tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
 656         if (!tpci200->info) {
 657                 ret = -ENOMEM;
 658                 goto out_err_info;
 659         }
 660
 661         pci_dev_get(pdev);
 662
 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");
 666         if (ret) {
 667                 dev_err(&pdev->dev, "Failed to allocate PCI Configuration Memory");
 668                 ret = -EBUSY;
 669                 goto out_err_pci_request;
 670         }
 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");
 676                 ret = -EFAULT;
 677                 goto out_err_ioremap;
 678         }
 679
 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
 682          * carrier. */
 683         reg32 = ioread32(tpci200->info->cfg_regs + LAS1_DESC);
 684         reg32 |= 1 << LAS_BIT_BIGENDIAN;
 685         iowrite32(reg32, tpci200->info->cfg_regs + LAS1_DESC);
 686
 687         reg32 = ioread32(tpci200->info->cfg_regs + LAS2_DESC);
 688         reg32 |= 1 << LAS_BIT_BIGENDIAN;
 689         iowrite32(reg32, tpci200->info->cfg_regs + LAS2_DESC);
 690
 691         /* Save struct pci_dev pointer */
 692         tpci200->info->pdev = pdev;
 693         tpci200->info->id_table = (struct pci_device_id *)id;
 694
 695         /* register the device and initialize it */
 696         ret = tpci200_install(tpci200);
 697         if (ret) {
 698                 dev_err(&pdev->dev, "error during tpci200 install\n");
 699                 ret = -ENODEV;
 700                 goto out_err_install;
 701         }
 702
 703         /* Register the carrier in the industry pack bus driver */
 704         tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
 705                                                       TPCI200_NB_SLOT,
 706                                                       &tpci200_bus_ops);
 707         if (!tpci200->info->ipack_bus) {
 708                 dev_err(&pdev->dev,
 709                         "error registering the carrier on ipack driver\n");
 710                 ret = -EFAULT;
 711                 goto out_err_bus_register;
 712         }
 713
 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);
 717
 718         for (i = 0; i < TPCI200_NB_SLOT; i++)
 719                 ipack_device_register(tpci200->info->ipack_bus, i);
 720         return 0;
 721
 722 out_err_bus_register:
 723         tpci200_uninstall(tpci200);
 724 out_err_install:
 725         iounmap(tpci200->info->cfg_regs);
 726 out_err_ioremap:
 727         pci_release_region(pdev, TPCI200_CFG_MEM_BAR);
 728 out_err_pci_request:
 729         pci_dev_put(pdev);
 730         kfree(tpci200->info);
 731 out_err_info:
 732         kfree(tpci200);
 733         return ret;
 734 }
 735
 736 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
 737 {
 738         ipack_bus_unregister(tpci200->info->ipack_bus);
 739         tpci200_uninstall(tpci200);
 740
 741         kfree(tpci200->info);
 742         kfree(tpci200);
 743 }
 744
 745 static void __devexit tpci200_pci_remove(struct pci_dev *dev)
 746 {
 747         struct tpci200_board *tpci200 = pci_get_drvdata(dev);
 748
 749         __tpci200_pci_remove(tpci200);
 750 }
 751
 752 static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
 753         { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
 754           TPCI200_SUBDEVICE_ID },
 755         { 0, },
 756 };
 757
 758 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
 759
 760 static struct pci_driver tpci200_pci_drv = {
 761         .name = "tpci200",
 762         .id_table = tpci200_idtable,
 763         .probe = tpci200_pci_probe,
 764         .remove = __devexit_p(tpci200_pci_remove),
 765 };
 766
 767 static int __init tpci200_drvr_init_module(void)
 768 {
 769         return pci_register_driver(&tpci200_pci_drv);
 770 }
 771
 772 static void __exit tpci200_drvr_exit_module(void)
 773 {
 774         pci_unregister_driver(&tpci200_pci_drv);
 775 }
 776
 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);