Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tpci200.c
Go to the documentation of this file.
1 
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);
Generated on Thu Jan 10 2013 14:28:59 for Linux Kernel by   doxygen 1.8.2