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 u16 tpci200_status_timeout[] = {
  18         TPCI200_A_TIMEOUT,
  19         TPCI200_B_TIMEOUT,
  20         TPCI200_C_TIMEOUT,
  21         TPCI200_D_TIMEOUT,
  22 };
  23
  24 static u16 tpci200_status_error[] = {
  25         TPCI200_A_ERROR,
  26         TPCI200_B_ERROR,
  27         TPCI200_C_ERROR,
  28         TPCI200_D_ERROR,
  29 };
  30
  31 static struct tpci200_board *check_slot(struct ipack_device *dev)
  32 {
  33         struct tpci200_board *tpci200;
  34
  35         if (dev == NULL)
  36                 return NULL;
  37
  38
  39         tpci200 = dev_get_drvdata(dev->bus->parent);
  40
  41         if (tpci200 == NULL) {
  42                 dev_info(&dev->dev, "carrier board not found\n");
  43                 return NULL;
  44         }
  45
  46         if (dev->slot >= TPCI200_NB_SLOT) {
  47                 dev_info(&dev->dev,
  48                          "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
  49                          dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
  50                 return NULL;
  51         }
  52
  53         return tpci200;
  54 }
  55
  56 static void tpci200_clear_mask(struct tpci200_board *tpci200,
  57                                __le16 __iomem *addr, u16 mask)
  58 {
  59         unsigned long flags;
  60         spin_lock_irqsave(&tpci200->regs_lock, flags);
  61         iowrite16(ioread16(addr) & (~mask), addr);
  62         spin_unlock_irqrestore(&tpci200->regs_lock, flags);
  63 }
  64
  65 static void tpci200_set_mask(struct tpci200_board *tpci200,
  66                              __le16 __iomem *addr, u16 mask)
  67 {
  68         unsigned long flags;
  69         spin_lock_irqsave(&tpci200->regs_lock, flags);
  70         iowrite16(ioread16(addr) | mask, addr);
  71         spin_unlock_irqrestore(&tpci200->regs_lock, flags);
  72 }
  73
  74 static void tpci200_unregister(struct tpci200_board *tpci200)
  75 {
  76         int i;
  77
  78         free_irq(tpci200->info->pdev->irq, (void *) tpci200);
  79
  80         pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
  81         pci_iounmap(tpci200->info->pdev, tpci200->info->ioidint_space);
  82         pci_iounmap(tpci200->info->pdev, tpci200->info->mem8_space);
  83         pci_iounmap(tpci200->info->pdev, tpci200->info->cfg_regs);
  84
  85         pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
  86         pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
  87         pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
  88         pci_release_region(tpci200->info->pdev, TPCI200_CFG_MEM_BAR);
  89
  90         pci_disable_device(tpci200->info->pdev);
  91         pci_dev_put(tpci200->info->pdev);
  92
  93         for (i = 0; i < TPCI200_NB_SLOT; i++) {
  94                 tpci200->slots[i].io_phys.address = NULL;
  95                 tpci200->slots[i].io_phys.size = 0;
  96                 tpci200->slots[i].id_phys.address = NULL;
  97                 tpci200->slots[i].id_phys.size = 0;
  98                 tpci200->slots[i].int_phys.address = NULL;
  99                 tpci200->slots[i].int_phys.size = 0;
 100                 tpci200->slots[i].mem_phys.address = NULL;
 101                 tpci200->slots[i].mem_phys.size = 0;
 102         }
 103 }
 104
 105 static void tpci200_enable_irq(struct tpci200_board *tpci200,
 106                                int islot)
 107 {
 108         tpci200_set_mask(tpci200,
 109                         &tpci200->info->interface_regs->control[islot],
 110                         TPCI200_INT0_EN | TPCI200_INT1_EN);
 111 }
 112
 113 static void tpci200_disable_irq(struct tpci200_board *tpci200,
 114                                 int islot)
 115 {
 116         tpci200_clear_mask(tpci200,
 117                         &tpci200->info->interface_regs->control[islot],
 118                         TPCI200_INT0_EN | TPCI200_INT1_EN);
 119 }
 120
 121 static irqreturn_t tpci200_slot_irq(struct slot_irq *slot_irq)
 122 {
 123         irqreturn_t ret;
 124
 125         if (!slot_irq)
 126                 return -ENODEV;
 127         ret = slot_irq->handler(slot_irq->arg);
 128
 129         return ret;
 130 }
 131
 132 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
 133 {
 134         struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
 135         struct slot_irq *slot_irq;
 136         irqreturn_t ret;
 137         u16 status_reg;
 138         int i;
 139
 140         /* Read status register */
 141         status_reg = ioread16(&tpci200->info->interface_regs->status);
 142
 143         /* Did we cause the interrupt? */
 144         if (!(status_reg & TPCI200_SLOT_INT_MASK))
 145                 return IRQ_NONE;
 146
 147         /* callback to the IRQ handler for the corresponding slot */
 148         rcu_read_lock();
 149         for (i = 0; i < TPCI200_NB_SLOT; i++) {
 150                 if (!(status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2 * i))))
 151                         continue;
 152                 slot_irq = rcu_dereference(tpci200->slots[i].irq);
 153                 ret = tpci200_slot_irq(slot_irq);
 154                 if (ret == -ENODEV) {
 155                         dev_info(&tpci200->info->pdev->dev,
 156                                  "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
 157                                  tpci200->number, i);
 158                         tpci200_disable_irq(tpci200, i);
 159                 }
 160         }
 161         rcu_read_unlock();
 162
 163         return IRQ_HANDLED;
 164 }
 165
 166 static int tpci200_free_irq(struct ipack_device *dev)
 167 {
 168         struct slot_irq *slot_irq;
 169         struct tpci200_board *tpci200;
 170
 171         tpci200 = check_slot(dev);
 172         if (tpci200 == NULL)
 173                 return -EINVAL;
 174
 175         if (mutex_lock_interruptible(&tpci200->mutex))
 176                 return -ERESTARTSYS;
 177
 178         if (tpci200->slots[dev->slot].irq == NULL) {
 179                 mutex_unlock(&tpci200->mutex);
 180                 return -EINVAL;
 181         }
 182
 183         tpci200_disable_irq(tpci200, dev->slot);
 184         slot_irq = tpci200->slots[dev->slot].irq;
 185         /* uninstall handler */
 186         RCU_INIT_POINTER(tpci200->slots[dev->slot].irq, NULL);
 187         synchronize_rcu();
 188         kfree(slot_irq);
 189         mutex_unlock(&tpci200->mutex);
 190         return 0;
 191 }
 192
 193 static int tpci200_request_irq(struct ipack_device *dev,
 194                                irqreturn_t (*handler)(void *), void *arg)
 195 {
 196         int res = 0;
 197         struct slot_irq *slot_irq;
 198         struct tpci200_board *tpci200;
 199
 200         tpci200 = check_slot(dev);
 201         if (tpci200 == NULL)
 202                 return -EINVAL;
 203
 204         if (mutex_lock_interruptible(&tpci200->mutex))
 205                 return -ERESTARTSYS;
 206
 207         if (tpci200->slots[dev->slot].irq != NULL) {
 208                 dev_err(&dev->dev,
 209                         "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
 210                         dev->slot);
 211                 res = -EINVAL;
 212                 goto out_unlock;
 213         }
 214
 215         slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
 216         if (slot_irq == NULL) {
 217                 dev_err(&dev->dev,
 218                         "Slot [%d:%d] unable to allocate memory for IRQ !\n",
 219                         dev->bus_nr, dev->slot);
 220                 res = -ENOMEM;
 221                 goto out_unlock;
 222         }
 223
 224         /*
 225          * WARNING: Setup Interrupt Vector in the IndustryPack device
 226          * before an IRQ request.
 227          * Read the User Manual of your IndustryPack device to know
 228          * where to write the vector in memory.
 229          */
 230         slot_irq->handler = handler;
 231         slot_irq->arg = arg;
 232         slot_irq->holder = dev;
 233
 234         rcu_assign_pointer(tpci200->slots[dev->slot].irq, slot_irq);
 235         tpci200_enable_irq(tpci200, dev->slot);
 236
 237 out_unlock:
 238         mutex_unlock(&tpci200->mutex);
 239         return res;
 240 }
 241
 242 static int tpci200_register(struct tpci200_board *tpci200)
 243 {
 244         int i;
 245         int res;
 246         unsigned long ioidint_base;
 247         unsigned long mem_base;
 248         unsigned short slot_ctrl;
 249
 250         if (pci_enable_device(tpci200->info->pdev) < 0)
 251                 return -ENODEV;
 252
 253         /* Request IP interface register (Bar 2) */
 254         res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
 255                                  "Carrier IP interface registers");
 256         if (res) {
 257                 dev_err(&tpci200->info->pdev->dev,
 258                         "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
 259                         tpci200->info->pdev->bus->number,
 260                         tpci200->info->pdev->devfn);
 261                 goto out_disable_pci;
 262         }
 263
 264         /* Request IO ID INT space (Bar 3) */
 265         res = pci_request_region(tpci200->info->pdev,
 266                                  TPCI200_IO_ID_INT_SPACES_BAR,
 267                                  "Carrier IO ID INT space");
 268         if (res) {
 269                 dev_err(&tpci200->info->pdev->dev,
 270                         "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
 271                         tpci200->info->pdev->bus->number,
 272                         tpci200->info->pdev->devfn);
 273                 goto out_release_ip_space;
 274         }
 275
 276         /* Request MEM space (Bar 4) */
 277         res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
 278                                  "Carrier MEM space");
 279         if (res) {
 280                 dev_err(&tpci200->info->pdev->dev,
 281                         "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
 282                         tpci200->info->pdev->bus->number,
 283                         tpci200->info->pdev->devfn);
 284                 goto out_release_ioid_int_space;
 285         }
 286
 287         /* Map internal tpci200 driver user space */
 288         tpci200->info->interface_regs =
 289                 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
 290                                            TPCI200_IP_INTERFACE_BAR),
 291                         TPCI200_IFACE_SIZE);
 292         tpci200->info->ioidint_space =
 293                 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
 294                                            TPCI200_IO_ID_INT_SPACES_BAR),
 295                         TPCI200_IOIDINT_SIZE);
 296         tpci200->info->mem8_space =
 297                 ioremap_nocache(pci_resource_start(tpci200->info->pdev,
 298                                            TPCI200_MEM8_SPACE_BAR),
 299                         TPCI200_MEM8_SIZE);
 300
 301         /* Initialize lock that protects interface_regs */
 302         spin_lock_init(&tpci200->regs_lock);
 303
 304         ioidint_base = pci_resource_start(tpci200->info->pdev,
 305                                           TPCI200_IO_ID_INT_SPACES_BAR);
 306         mem_base = pci_resource_start(tpci200->info->pdev,
 307                                       TPCI200_MEM8_SPACE_BAR);
 308
 309         /* Set the default parameters of the slot
 310          * INT0 disabled, level sensitive
 311          * INT1 disabled, level sensitive
 312          * error interrupt disabled
 313          * timeout interrupt disabled
 314          * recover time disabled
 315          * clock rate 8 MHz
 316          */
 317         slot_ctrl = 0;
 318
 319         /* Set all slot physical address space */
 320         for (i = 0; i < TPCI200_NB_SLOT; i++) {
 321                 tpci200->slots[i].io_phys.address =
 322                         (void __iomem *)ioidint_base +
 323                         TPCI200_IO_SPACE_OFF + TPCI200_IO_SPACE_GAP*i;
 324                 tpci200->slots[i].io_phys.size = TPCI200_IO_SPACE_SIZE;
 325
 326                 tpci200->slots[i].id_phys.address =
 327                         (void __iomem *)ioidint_base +
 328                         TPCI200_ID_SPACE_OFF + TPCI200_ID_SPACE_GAP*i;
 329                 tpci200->slots[i].id_phys.size = TPCI200_ID_SPACE_SIZE;
 330
 331                 tpci200->slots[i].int_phys.address =
 332                         (void __iomem *)ioidint_base +
 333                         TPCI200_INT_SPACE_OFF + TPCI200_INT_SPACE_GAP * i;
 334                 tpci200->slots[i].int_phys.size = TPCI200_INT_SPACE_SIZE;
 335
 336                 tpci200->slots[i].mem_phys.address =
 337                         (void __iomem *)mem_base + TPCI200_MEM8_GAP*i;
 338                 tpci200->slots[i].mem_phys.size = TPCI200_MEM8_SIZE;
 339
 340                 writew(slot_ctrl, &tpci200->info->interface_regs->control[i]);
 341         }
 342
 343         res = request_irq(tpci200->info->pdev->irq,
 344                           tpci200_interrupt, IRQF_SHARED,
 345                           KBUILD_MODNAME, (void *) tpci200);
 346         if (res) {
 347                 dev_err(&tpci200->info->pdev->dev,
 348                         "(bn 0x%X, sn 0x%X) unable to register IRQ !",
 349                         tpci200->info->pdev->bus->number,
 350                         tpci200->info->pdev->devfn);
 351                 goto out_release_ioid_int_space;
 352         }
 353
 354         return 0;
 355
 356 out_release_ioid_int_space:
 357         pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
 358 out_release_ip_space:
 359         pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
 360 out_disable_pci:
 361         pci_disable_device(tpci200->info->pdev);
 362         return res;
 363 }
 364
 365 static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
 366 {
 367         struct ipack_addr_space *virt_addr_space;
 368         struct tpci200_board *tpci200;
 369
 370         tpci200 = check_slot(dev);
 371         if (tpci200 == NULL)
 372                 return -EINVAL;
 373
 374         if (mutex_lock_interruptible(&tpci200->mutex))
 375                 return -ERESTARTSYS;
 376
 377         switch (space) {
 378         case IPACK_IO_SPACE:
 379                 if (dev->io_space.address == NULL) {
 380                         dev_info(&dev->dev,
 381                                  "Slot [%d:%d] IO space not mapped !\n",
 382                                  dev->bus_nr, dev->slot);
 383                         goto out_unlock;
 384                 }
 385                 virt_addr_space = &dev->io_space;
 386                 break;
 387         case IPACK_ID_SPACE:
 388                 if (dev->id_space.address == NULL) {
 389                         dev_info(&dev->dev,
 390                                  "Slot [%d:%d] ID space not mapped !\n",
 391                                  dev->bus_nr, dev->slot);
 392                         goto out_unlock;
 393                 }
 394                 virt_addr_space = &dev->id_space;
 395                 break;
 396         case IPACK_INT_SPACE:
 397                 if (dev->int_space.address == NULL) {
 398                         dev_info(&dev->dev,
 399                                  "Slot [%d:%d] INT space not mapped !\n",
 400                                  dev->bus_nr, dev->slot);
 401                         goto out_unlock;
 402                 }
 403                 virt_addr_space = &dev->int_space;
 404                 break;
 405         case IPACK_MEM_SPACE:
 406                 if (dev->mem_space.address == NULL) {
 407                         dev_info(&dev->dev,
 408                                  "Slot [%d:%d] MEM space not mapped !\n",
 409                                  dev->bus_nr, dev->slot);
 410                         goto out_unlock;
 411                 }
 412                 virt_addr_space = &dev->mem_space;
 413                 break;
 414         default:
 415                 dev_err(&dev->dev,
 416                         "Slot [%d:%d] space number %d doesn't exist !\n",
 417                         dev->bus_nr, dev->slot, space);
 418                 mutex_unlock(&tpci200->mutex);
 419                 return -EINVAL;
 420         }
 421
 422         iounmap(virt_addr_space->address);
 423
 424         virt_addr_space->address = NULL;
 425         virt_addr_space->size = 0;
 426 out_unlock:
 427         mutex_unlock(&tpci200->mutex);
 428         return 0;
 429 }
 430
 431 static int tpci200_slot_map_space(struct ipack_device *dev,
 432                                   unsigned int memory_size, int space)
 433 {
 434         int res = 0;
 435         unsigned int size_to_map;
 436         void __iomem *phys_address;
 437         struct ipack_addr_space *virt_addr_space;
 438         struct tpci200_board *tpci200;
 439
 440         tpci200 = check_slot(dev);
 441         if (tpci200 == NULL)
 442                 return -EINVAL;
 443
 444         if (mutex_lock_interruptible(&tpci200->mutex))
 445                 return -ERESTARTSYS;
 446
 447         switch (space) {
 448         case IPACK_IO_SPACE:
 449                 if (dev->io_space.address != NULL) {
 450                         dev_err(&dev->dev,
 451                                 "Slot [%d:%d] IO space already mapped !\n",
 452                                 tpci200->number, dev->slot);
 453                         res = -EINVAL;
 454                         goto out_unlock;
 455                 }
 456                 virt_addr_space = &dev->io_space;
 457
 458                 phys_address = tpci200->slots[dev->slot].io_phys.address;
 459                 size_to_map = tpci200->slots[dev->slot].io_phys.size;
 460                 break;
 461         case IPACK_ID_SPACE:
 462                 if (dev->id_space.address != NULL) {
 463                         dev_err(&dev->dev,
 464                                 "Slot [%d:%d] ID space already mapped !\n",
 465                                 tpci200->number, dev->slot);
 466                         res = -EINVAL;
 467                         goto out_unlock;
 468                 }
 469                 virt_addr_space = &dev->id_space;
 470
 471                 phys_address = tpci200->slots[dev->slot].id_phys.address;
 472                 size_to_map = tpci200->slots[dev->slot].id_phys.size;
 473                 break;
 474         case IPACK_INT_SPACE:
 475                 if (dev->int_space.address != NULL) {
 476                         dev_err(&dev->dev,
 477                                 "Slot [%d:%d] INT space already mapped !\n",
 478                                 tpci200->number, dev->slot);
 479                         res = -EINVAL;
 480                         goto out_unlock;
 481                 }
 482                 virt_addr_space = &dev->int_space;
 483
 484                 phys_address = tpci200->slots[dev->slot].int_phys.address;
 485                 size_to_map = tpci200->slots[dev->slot].int_phys.size;
 486                 break;
 487         case IPACK_MEM_SPACE:
 488                 if (dev->mem_space.address != NULL) {
 489                         dev_err(&dev->dev,
 490                                 "Slot [%d:%d] MEM space already mapped !\n",
 491                                 tpci200->number, dev->slot);
 492                         res = -EINVAL;
 493                         goto out_unlock;
 494                 }
 495                 virt_addr_space = &dev->mem_space;
 496
 497                 if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
 498                         dev_err(&dev->dev,
 499                                 "Slot [%d:%d] request is 0x%X memory, only 0x%X available !\n",
 500                                 dev->bus_nr, dev->slot, memory_size,
 501                                 tpci200->slots[dev->slot].mem_phys.size);
 502                         res = -EINVAL;
 503                         goto out_unlock;
 504                 }
 505
 506                 phys_address = tpci200->slots[dev->slot].mem_phys.address;
 507                 size_to_map = memory_size;
 508                 break;
 509         default:
 510                 dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
 511                         tpci200->number, dev->slot, space);
 512                 res = -EINVAL;
 513                 goto out_unlock;
 514         }
 515
 516         virt_addr_space->size = size_to_map;
 517         virt_addr_space->address =
 518                 ioremap_nocache((unsigned long)phys_address, size_to_map);
 519
 520 out_unlock:
 521         mutex_unlock(&tpci200->mutex);
 522         return res;
 523 }
 524
 525 static int tpci200_get_clockrate(struct ipack_device *dev)
 526 {
 527         struct tpci200_board *tpci200 = check_slot(dev);
 528         __le16 __iomem *addr;
 529
 530         if (!tpci200)
 531                 return -ENODEV;
 532
 533         addr = &tpci200->info->interface_regs->control[dev->slot];
 534         return (ioread16(addr) & TPCI200_CLK32) ? 32 : 8;
 535 }
 536
 537 static int tpci200_set_clockrate(struct ipack_device *dev, int mherz)
 538 {
 539         struct tpci200_board *tpci200 = check_slot(dev);
 540         __le16 __iomem *addr;
 541
 542         if (!tpci200)
 543                 return -ENODEV;
 544
 545         addr = &tpci200->info->interface_regs->control[dev->slot];
 546
 547         switch (mherz) {
 548         case 8:
 549                 tpci200_clear_mask(tpci200, addr, TPCI200_CLK32);
 550                 break;
 551         case 32:
 552                 tpci200_set_mask(tpci200, addr, TPCI200_CLK32);
 553                 break;
 554         default:
 555                 return -EINVAL;
 556         }
 557         return 0;
 558 }
 559
 560 static int tpci200_get_error(struct ipack_device *dev)
 561 {
 562         struct tpci200_board *tpci200 = check_slot(dev);
 563         __le16 __iomem *addr;
 564         u16 mask;
 565
 566         if (!tpci200)
 567                 return -ENODEV;
 568
 569         addr = &tpci200->info->interface_regs->status;
 570         mask = tpci200_status_error[dev->slot];
 571         return (ioread16(addr) & mask) ? 1 : 0;
 572 }
 573
 574 static int tpci200_get_timeout(struct ipack_device *dev)
 575 {
 576         struct tpci200_board *tpci200 = check_slot(dev);
 577         __le16 __iomem *addr;
 578         u16 mask;
 579
 580         if (!tpci200)
 581                 return -ENODEV;
 582
 583         addr = &tpci200->info->interface_regs->status;
 584         mask = tpci200_status_timeout[dev->slot];
 585
 586         return (ioread16(addr) & mask) ? 1 : 0;
 587 }
 588
 589 static int tpci200_reset_timeout(struct ipack_device *dev)
 590 {
 591         struct tpci200_board *tpci200 = check_slot(dev);
 592         __le16 __iomem *addr;
 593         u16 mask;
 594
 595         if (!tpci200)
 596                 return -ENODEV;
 597
 598         addr = &tpci200->info->interface_regs->status;
 599         mask = tpci200_status_timeout[dev->slot];
 600
 601         iowrite16(mask, addr);
 602         return 0;
 603 }
 604
 605 static void tpci200_uninstall(struct tpci200_board *tpci200)
 606 {
 607         tpci200_unregister(tpci200);
 608         kfree(tpci200->slots);
 609 }
 610
 611 static const struct ipack_bus_ops tpci200_bus_ops = {
 612         .map_space = tpci200_slot_map_space,
 613         .unmap_space = tpci200_slot_unmap_space,
 614         .request_irq = tpci200_request_irq,
 615         .free_irq = tpci200_free_irq,
 616         .get_clockrate = tpci200_get_clockrate,
 617         .set_clockrate = tpci200_set_clockrate,
 618         .get_error     = tpci200_get_error,
 619         .get_timeout   = tpci200_get_timeout,
 620         .reset_timeout = tpci200_reset_timeout,
 621 };
 622
 623 static int tpci200_install(struct tpci200_board *tpci200)
 624 {
 625         int res;
 626
 627         tpci200->slots = kzalloc(
 628                 TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
 629         if (tpci200->slots == NULL)
 630                 return -ENOMEM;
 631
 632         res = tpci200_register(tpci200);
 633         if (res) {
 634                 kfree(tpci200->slots);
 635                 tpci200->slots = NULL;
 636                 return res;
 637         }
 638
 639         mutex_init(&tpci200->mutex);
 640         return 0;
 641 }
 642
 643 static int tpci200_pci_probe(struct pci_dev *pdev,
 644                              const struct pci_device_id *id)
 645 {
 646         int ret, i;
 647         struct tpci200_board *tpci200;
 648         u32 reg32;
 649
 650         tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
 651         if (!tpci200)
 652                 return -ENOMEM;
 653
 654         tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
 655         if (!tpci200->info) {
 656                 ret = -ENOMEM;
 657                 goto out_err_info;
 658         }
 659
 660         pci_dev_get(pdev);
 661
 662         /* Obtain a mapping of the carrier's PCI configuration registers */
 663         ret = pci_request_region(pdev, TPCI200_CFG_MEM_BAR,
 664                                  KBUILD_MODNAME " Configuration Memory");
 665         if (ret) {
 666                 dev_err(&pdev->dev, "Failed to allocate PCI Configuration Memory");
 667                 ret = -EBUSY;
 668                 goto out_err_pci_request;
 669         }
 670         tpci200->info->cfg_regs = ioremap_nocache(
 671                         pci_resource_start(pdev, TPCI200_CFG_MEM_BAR),
 672                         pci_resource_len(pdev, TPCI200_CFG_MEM_BAR));
 673         if (!tpci200->info->cfg_regs) {
 674                 dev_err(&pdev->dev, "Failed to map PCI Configuration Memory");
 675                 ret = -EFAULT;
 676                 goto out_err_ioremap;
 677         }
 678
 679         /* Disable byte swapping for 16 bit IP module access. This will ensure
 680          * that the Industrypack big endian byte order is preserved by the
 681          * carrier. */
 682         reg32 = ioread32(tpci200->info->cfg_regs + LAS1_DESC);
 683         reg32 |= 1 << LAS_BIT_BIGENDIAN;
 684         iowrite32(reg32, tpci200->info->cfg_regs + LAS1_DESC);
 685
 686         reg32 = ioread32(tpci200->info->cfg_regs + LAS2_DESC);
 687         reg32 |= 1 << LAS_BIT_BIGENDIAN;
 688         iowrite32(reg32, tpci200->info->cfg_regs + LAS2_DESC);
 689
 690         /* Save struct pci_dev pointer */
 691         tpci200->info->pdev = pdev;
 692         tpci200->info->id_table = (struct pci_device_id *)id;
 693
 694         /* register the device and initialize it */
 695         ret = tpci200_install(tpci200);
 696         if (ret) {
 697                 dev_err(&pdev->dev, "error during tpci200 install\n");
 698                 ret = -ENODEV;
 699                 goto out_err_install;
 700         }
 701
 702         /* Register the carrier in the industry pack bus driver */
 703         tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
 704                                                       TPCI200_NB_SLOT,
 705                                                       &tpci200_bus_ops);
 706         if (!tpci200->info->ipack_bus) {
 707                 dev_err(&pdev->dev,
 708                         "error registering the carrier on ipack driver\n");
 709                 ret = -EFAULT;
 710                 goto out_err_bus_register;
 711         }
 712
 713         /* save the bus number given by ipack to logging purpose */
 714         tpci200->number = tpci200->info->ipack_bus->bus_nr;
 715         dev_set_drvdata(&pdev->dev, tpci200);
 716
 717         for (i = 0; i < TPCI200_NB_SLOT; i++)
 718                 ipack_device_register(tpci200->info->ipack_bus, i);
 719         return 0;
 720
 721 out_err_bus_register:
 722         tpci200_uninstall(tpci200);
 723 out_err_install:
 724         iounmap(tpci200->info->cfg_regs);
 725 out_err_ioremap:
 726         pci_release_region(pdev, TPCI200_CFG_MEM_BAR);
 727 out_err_pci_request:
 728         pci_dev_put(pdev);
 729         kfree(tpci200->info);
 730 out_err_info:
 731         kfree(tpci200);
 732         return ret;
 733 }
 734
 735 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
 736 {
 737         ipack_bus_unregister(tpci200->info->ipack_bus);
 738         tpci200_uninstall(tpci200);
 739
 740         kfree(tpci200->info);
 741         kfree(tpci200);
 742 }
 743
 744 static void __devexit tpci200_pci_remove(struct pci_dev *dev)
 745 {
 746         struct tpci200_board *tpci200 = pci_get_drvdata(dev);
 747
 748         __tpci200_pci_remove(tpci200);
 749 }
 750
 751 static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
 752         { TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
 753           TPCI200_SUBDEVICE_ID },
 754         { 0, },
 755 };
 756
 757 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
 758
 759 static struct pci_driver tpci200_pci_drv = {
 760         .name = "tpci200",
 761         .id_table = tpci200_idtable,
 762         .probe = tpci200_pci_probe,
 763         .remove = __devexit_p(tpci200_pci_remove),
 764 };
 765
 766 static int __init tpci200_drvr_init_module(void)
 767 {
 768         return pci_register_driver(&tpci200_pci_drv);
 769 }
 770
 771 static void __exit tpci200_drvr_exit_module(void)
 772 {
 773         pci_unregister_driver(&tpci200_pci_drv);
 774 }
 775
 776 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
 777 MODULE_LICENSE("GPL");
 778 module_init(tpci200_drvr_init_module);
 779 module_exit(tpci200_drvr_exit_module);