• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**
2  * tpci200.c
3  *
4  * driver for the TEWS TPCI-200 device
5  *
6  * Copyright (C) 2009-2012 CERN (www.cern.ch)
7  * Author: Nicolas Serafini, EIC2 SA
8  * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; version 2 of the License.
13  */
14 
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include "tpci200.h"
18 
19 static const u16 tpci200_status_timeout[] = {
20 	TPCI200_A_TIMEOUT,
21 	TPCI200_B_TIMEOUT,
22 	TPCI200_C_TIMEOUT,
23 	TPCI200_D_TIMEOUT,
24 };
25 
26 static const u16 tpci200_status_error[] = {
27 	TPCI200_A_ERROR,
28 	TPCI200_B_ERROR,
29 	TPCI200_C_ERROR,
30 	TPCI200_D_ERROR,
31 };
32 
33 static const size_t tpci200_space_size[IPACK_SPACE_COUNT] = {
34 	[IPACK_IO_SPACE]    = TPCI200_IO_SPACE_SIZE,
35 	[IPACK_ID_SPACE]    = TPCI200_ID_SPACE_SIZE,
36 	[IPACK_INT_SPACE]   = TPCI200_INT_SPACE_SIZE,
37 	[IPACK_MEM8_SPACE]  = TPCI200_MEM8_SPACE_SIZE,
38 	[IPACK_MEM16_SPACE] = TPCI200_MEM16_SPACE_SIZE,
39 };
40 
41 static const size_t tpci200_space_interval[IPACK_SPACE_COUNT] = {
42 	[IPACK_IO_SPACE]    = TPCI200_IO_SPACE_INTERVAL,
43 	[IPACK_ID_SPACE]    = TPCI200_ID_SPACE_INTERVAL,
44 	[IPACK_INT_SPACE]   = TPCI200_INT_SPACE_INTERVAL,
45 	[IPACK_MEM8_SPACE]  = TPCI200_MEM8_SPACE_INTERVAL,
46 	[IPACK_MEM16_SPACE] = TPCI200_MEM16_SPACE_INTERVAL,
47 };
48 
check_slot(struct ipack_device * dev)49 static struct tpci200_board *check_slot(struct ipack_device *dev)
50 {
51 	struct tpci200_board *tpci200;
52 
53 	if (dev == NULL)
54 		return NULL;
55 
56 
57 	tpci200 = dev_get_drvdata(dev->bus->parent);
58 
59 	if (tpci200 == NULL) {
60 		dev_info(&dev->dev, "carrier board not found\n");
61 		return NULL;
62 	}
63 
64 	if (dev->slot >= TPCI200_NB_SLOT) {
65 		dev_info(&dev->dev,
66 			 "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
67 			 dev->bus->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
68 		return NULL;
69 	}
70 
71 	return tpci200;
72 }
73 
tpci200_clear_mask(struct tpci200_board * tpci200,__le16 __iomem * addr,u16 mask)74 static void tpci200_clear_mask(struct tpci200_board *tpci200,
75 			       __le16 __iomem *addr, u16 mask)
76 {
77 	unsigned long flags;
78 	spin_lock_irqsave(&tpci200->regs_lock, flags);
79 	iowrite16(ioread16(addr) & (~mask), addr);
80 	spin_unlock_irqrestore(&tpci200->regs_lock, flags);
81 }
82 
tpci200_set_mask(struct tpci200_board * tpci200,__le16 __iomem * addr,u16 mask)83 static void tpci200_set_mask(struct tpci200_board *tpci200,
84 			     __le16 __iomem *addr, u16 mask)
85 {
86 	unsigned long flags;
87 	spin_lock_irqsave(&tpci200->regs_lock, flags);
88 	iowrite16(ioread16(addr) | mask, addr);
89 	spin_unlock_irqrestore(&tpci200->regs_lock, flags);
90 }
91 
tpci200_unregister(struct tpci200_board * tpci200)92 static void tpci200_unregister(struct tpci200_board *tpci200)
93 {
94 	free_irq(tpci200->info->pdev->irq, (void *) tpci200);
95 
96 	pci_iounmap(tpci200->info->pdev, tpci200->info->interface_regs);
97 	pci_iounmap(tpci200->info->pdev, tpci200->info->cfg_regs);
98 
99 	pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
100 	pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
101 	pci_release_region(tpci200->info->pdev, TPCI200_MEM16_SPACE_BAR);
102 	pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
103 	pci_release_region(tpci200->info->pdev, TPCI200_CFG_MEM_BAR);
104 
105 	pci_disable_device(tpci200->info->pdev);
106 	pci_dev_put(tpci200->info->pdev);
107 }
108 
tpci200_enable_irq(struct tpci200_board * tpci200,int islot)109 static void tpci200_enable_irq(struct tpci200_board *tpci200,
110 			       int islot)
111 {
112 	tpci200_set_mask(tpci200,
113 			&tpci200->info->interface_regs->control[islot],
114 			TPCI200_INT0_EN | TPCI200_INT1_EN);
115 }
116 
tpci200_disable_irq(struct tpci200_board * tpci200,int islot)117 static void tpci200_disable_irq(struct tpci200_board *tpci200,
118 				int islot)
119 {
120 	tpci200_clear_mask(tpci200,
121 			&tpci200->info->interface_regs->control[islot],
122 			TPCI200_INT0_EN | TPCI200_INT1_EN);
123 }
124 
tpci200_slot_irq(struct slot_irq * slot_irq)125 static irqreturn_t tpci200_slot_irq(struct slot_irq *slot_irq)
126 {
127 	irqreturn_t ret;
128 
129 	if (!slot_irq)
130 		return -ENODEV;
131 	ret = slot_irq->handler(slot_irq->arg);
132 
133 	return ret;
134 }
135 
tpci200_interrupt(int irq,void * dev_id)136 static irqreturn_t tpci200_interrupt(int irq, void *dev_id)
137 {
138 	struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
139 	struct slot_irq *slot_irq;
140 	irqreturn_t ret;
141 	u16 status_reg;
142 	int i;
143 
144 	/* Read status register */
145 	status_reg = ioread16(&tpci200->info->interface_regs->status);
146 
147 	/* Did we cause the interrupt? */
148 	if (!(status_reg & TPCI200_SLOT_INT_MASK))
149 		return IRQ_NONE;
150 
151 	/* callback to the IRQ handler for the corresponding slot */
152 	rcu_read_lock();
153 	for (i = 0; i < TPCI200_NB_SLOT; i++) {
154 		if (!(status_reg & ((TPCI200_A_INT0 | TPCI200_A_INT1) << (2 * i))))
155 			continue;
156 		slot_irq = rcu_dereference(tpci200->slots[i].irq);
157 		ret = tpci200_slot_irq(slot_irq);
158 		if (ret == -ENODEV) {
159 			dev_info(&tpci200->info->pdev->dev,
160 				 "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
161 				 tpci200->number, i);
162 			tpci200_disable_irq(tpci200, i);
163 		}
164 	}
165 	rcu_read_unlock();
166 
167 	return IRQ_HANDLED;
168 }
169 
tpci200_free_irq(struct ipack_device * dev)170 static int tpci200_free_irq(struct ipack_device *dev)
171 {
172 	struct slot_irq *slot_irq;
173 	struct tpci200_board *tpci200;
174 
175 	tpci200 = check_slot(dev);
176 	if (tpci200 == NULL)
177 		return -EINVAL;
178 
179 	if (mutex_lock_interruptible(&tpci200->mutex))
180 		return -ERESTARTSYS;
181 
182 	if (tpci200->slots[dev->slot].irq == NULL) {
183 		mutex_unlock(&tpci200->mutex);
184 		return -EINVAL;
185 	}
186 
187 	tpci200_disable_irq(tpci200, dev->slot);
188 	slot_irq = tpci200->slots[dev->slot].irq;
189 	/* uninstall handler */
190 	RCU_INIT_POINTER(tpci200->slots[dev->slot].irq, NULL);
191 	synchronize_rcu();
192 	kfree(slot_irq);
193 	mutex_unlock(&tpci200->mutex);
194 	return 0;
195 }
196 
tpci200_request_irq(struct ipack_device * dev,irqreturn_t (* handler)(void *),void * arg)197 static int tpci200_request_irq(struct ipack_device *dev,
198 			       irqreturn_t (*handler)(void *), void *arg)
199 {
200 	int res = 0;
201 	struct slot_irq *slot_irq;
202 	struct tpci200_board *tpci200;
203 
204 	tpci200 = check_slot(dev);
205 	if (tpci200 == NULL)
206 		return -EINVAL;
207 
208 	if (mutex_lock_interruptible(&tpci200->mutex))
209 		return -ERESTARTSYS;
210 
211 	if (tpci200->slots[dev->slot].irq != NULL) {
212 		dev_err(&dev->dev,
213 			"Slot [%d:%d] IRQ already registered !\n",
214 			dev->bus->bus_nr,
215 			dev->slot);
216 		res = -EINVAL;
217 		goto out_unlock;
218 	}
219 
220 	slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
221 	if (slot_irq == NULL) {
222 		dev_err(&dev->dev,
223 			"Slot [%d:%d] unable to allocate memory for IRQ !\n",
224 			dev->bus->bus_nr, dev->slot);
225 		res = -ENOMEM;
226 		goto out_unlock;
227 	}
228 
229 	/*
230 	 * WARNING: Setup Interrupt Vector in the IndustryPack device
231 	 * before an IRQ request.
232 	 * Read the User Manual of your IndustryPack device to know
233 	 * where to write the vector in memory.
234 	 */
235 	slot_irq->handler = handler;
236 	slot_irq->arg = arg;
237 	slot_irq->holder = dev;
238 
239 	rcu_assign_pointer(tpci200->slots[dev->slot].irq, slot_irq);
240 	tpci200_enable_irq(tpci200, dev->slot);
241 
242 out_unlock:
243 	mutex_unlock(&tpci200->mutex);
244 	return res;
245 }
246 
tpci200_register(struct tpci200_board * tpci200)247 static int tpci200_register(struct tpci200_board *tpci200)
248 {
249 	int i;
250 	int res;
251 	phys_addr_t ioidint_base;
252 	unsigned short slot_ctrl;
253 
254 	if (pci_enable_device(tpci200->info->pdev) < 0)
255 		return -ENODEV;
256 
257 	/* Request IP interface register (Bar 2) */
258 	res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
259 				 "Carrier IP interface registers");
260 	if (res) {
261 		dev_err(&tpci200->info->pdev->dev,
262 			"(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
263 			tpci200->info->pdev->bus->number,
264 			tpci200->info->pdev->devfn);
265 		goto out_disable_pci;
266 	}
267 
268 	/* Request IO ID INT space (Bar 3) */
269 	res = pci_request_region(tpci200->info->pdev,
270 				 TPCI200_IO_ID_INT_SPACES_BAR,
271 				 "Carrier IO ID INT space");
272 	if (res) {
273 		dev_err(&tpci200->info->pdev->dev,
274 			"(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
275 			tpci200->info->pdev->bus->number,
276 			tpci200->info->pdev->devfn);
277 		goto out_release_ip_space;
278 	}
279 
280 	/* Request MEM8 space (Bar 5) */
281 	res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
282 				 "Carrier MEM8 space");
283 	if (res) {
284 		dev_err(&tpci200->info->pdev->dev,
285 			"(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 5!",
286 			tpci200->info->pdev->bus->number,
287 			tpci200->info->pdev->devfn);
288 		goto out_release_ioid_int_space;
289 	}
290 
291 	/* Request MEM16 space (Bar 4) */
292 	res = pci_request_region(tpci200->info->pdev, TPCI200_MEM16_SPACE_BAR,
293 				 "Carrier MEM16 space");
294 	if (res) {
295 		dev_err(&tpci200->info->pdev->dev,
296 			"(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
297 			tpci200->info->pdev->bus->number,
298 			tpci200->info->pdev->devfn);
299 		goto out_release_mem8_space;
300 	}
301 
302 	/* Map internal tpci200 driver user space */
303 	tpci200->info->interface_regs =
304 		ioremap_nocache(pci_resource_start(tpci200->info->pdev,
305 					   TPCI200_IP_INTERFACE_BAR),
306 			TPCI200_IFACE_SIZE);
307 	if (!tpci200->info->interface_regs) {
308 		dev_err(&tpci200->info->pdev->dev,
309 			"(bn 0x%X, sn 0x%X) failed to map driver user space!",
310 			tpci200->info->pdev->bus->number,
311 			tpci200->info->pdev->devfn);
312 		res = -ENOMEM;
313 		goto out_release_mem8_space;
314 	}
315 
316 	/* Initialize lock that protects interface_regs */
317 	spin_lock_init(&tpci200->regs_lock);
318 
319 	ioidint_base = pci_resource_start(tpci200->info->pdev,
320 					  TPCI200_IO_ID_INT_SPACES_BAR);
321 	tpci200->mod_mem[IPACK_IO_SPACE] = ioidint_base + TPCI200_IO_SPACE_OFF;
322 	tpci200->mod_mem[IPACK_ID_SPACE] = ioidint_base + TPCI200_ID_SPACE_OFF;
323 	tpci200->mod_mem[IPACK_INT_SPACE] =
324 		ioidint_base + TPCI200_INT_SPACE_OFF;
325 	tpci200->mod_mem[IPACK_MEM8_SPACE] =
326 		pci_resource_start(tpci200->info->pdev,
327 				   TPCI200_MEM8_SPACE_BAR);
328 	tpci200->mod_mem[IPACK_MEM16_SPACE] =
329 		pci_resource_start(tpci200->info->pdev,
330 				   TPCI200_MEM16_SPACE_BAR);
331 
332 	/* Set the default parameters of the slot
333 	 * INT0 disabled, level sensitive
334 	 * INT1 disabled, level sensitive
335 	 * error interrupt disabled
336 	 * timeout interrupt disabled
337 	 * recover time disabled
338 	 * clock rate 8 MHz
339 	 */
340 	slot_ctrl = 0;
341 	for (i = 0; i < TPCI200_NB_SLOT; i++)
342 		writew(slot_ctrl, &tpci200->info->interface_regs->control[i]);
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_mem8_space:
358 	pci_release_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR);
359 out_release_ioid_int_space:
360 	pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
361 out_release_ip_space:
362 	pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
363 out_disable_pci:
364 	pci_disable_device(tpci200->info->pdev);
365 	return res;
366 }
367 
tpci200_get_clockrate(struct ipack_device * dev)368 static int tpci200_get_clockrate(struct ipack_device *dev)
369 {
370 	struct tpci200_board *tpci200 = check_slot(dev);
371 	__le16 __iomem *addr;
372 
373 	if (!tpci200)
374 		return -ENODEV;
375 
376 	addr = &tpci200->info->interface_regs->control[dev->slot];
377 	return (ioread16(addr) & TPCI200_CLK32) ? 32 : 8;
378 }
379 
tpci200_set_clockrate(struct ipack_device * dev,int mherz)380 static int tpci200_set_clockrate(struct ipack_device *dev, int mherz)
381 {
382 	struct tpci200_board *tpci200 = check_slot(dev);
383 	__le16 __iomem *addr;
384 
385 	if (!tpci200)
386 		return -ENODEV;
387 
388 	addr = &tpci200->info->interface_regs->control[dev->slot];
389 
390 	switch (mherz) {
391 	case 8:
392 		tpci200_clear_mask(tpci200, addr, TPCI200_CLK32);
393 		break;
394 	case 32:
395 		tpci200_set_mask(tpci200, addr, TPCI200_CLK32);
396 		break;
397 	default:
398 		return -EINVAL;
399 	}
400 	return 0;
401 }
402 
tpci200_get_error(struct ipack_device * dev)403 static int tpci200_get_error(struct ipack_device *dev)
404 {
405 	struct tpci200_board *tpci200 = check_slot(dev);
406 	__le16 __iomem *addr;
407 	u16 mask;
408 
409 	if (!tpci200)
410 		return -ENODEV;
411 
412 	addr = &tpci200->info->interface_regs->status;
413 	mask = tpci200_status_error[dev->slot];
414 	return (ioread16(addr) & mask) ? 1 : 0;
415 }
416 
tpci200_get_timeout(struct ipack_device * dev)417 static int tpci200_get_timeout(struct ipack_device *dev)
418 {
419 	struct tpci200_board *tpci200 = check_slot(dev);
420 	__le16 __iomem *addr;
421 	u16 mask;
422 
423 	if (!tpci200)
424 		return -ENODEV;
425 
426 	addr = &tpci200->info->interface_regs->status;
427 	mask = tpci200_status_timeout[dev->slot];
428 
429 	return (ioread16(addr) & mask) ? 1 : 0;
430 }
431 
tpci200_reset_timeout(struct ipack_device * dev)432 static int tpci200_reset_timeout(struct ipack_device *dev)
433 {
434 	struct tpci200_board *tpci200 = check_slot(dev);
435 	__le16 __iomem *addr;
436 	u16 mask;
437 
438 	if (!tpci200)
439 		return -ENODEV;
440 
441 	addr = &tpci200->info->interface_regs->status;
442 	mask = tpci200_status_timeout[dev->slot];
443 
444 	iowrite16(mask, addr);
445 	return 0;
446 }
447 
tpci200_uninstall(struct tpci200_board * tpci200)448 static void tpci200_uninstall(struct tpci200_board *tpci200)
449 {
450 	tpci200_unregister(tpci200);
451 	kfree(tpci200->slots);
452 }
453 
454 static const struct ipack_bus_ops tpci200_bus_ops = {
455 	.request_irq = tpci200_request_irq,
456 	.free_irq = tpci200_free_irq,
457 	.get_clockrate = tpci200_get_clockrate,
458 	.set_clockrate = tpci200_set_clockrate,
459 	.get_error     = tpci200_get_error,
460 	.get_timeout   = tpci200_get_timeout,
461 	.reset_timeout = tpci200_reset_timeout,
462 };
463 
tpci200_install(struct tpci200_board * tpci200)464 static int tpci200_install(struct tpci200_board *tpci200)
465 {
466 	int res;
467 
468 	tpci200->slots = kcalloc(TPCI200_NB_SLOT, sizeof(struct tpci200_slot),
469 				 GFP_KERNEL);
470 	if (tpci200->slots == NULL)
471 		return -ENOMEM;
472 
473 	res = tpci200_register(tpci200);
474 	if (res) {
475 		kfree(tpci200->slots);
476 		tpci200->slots = NULL;
477 		return res;
478 	}
479 
480 	mutex_init(&tpci200->mutex);
481 	return 0;
482 }
483 
tpci200_release_device(struct ipack_device * dev)484 static void tpci200_release_device(struct ipack_device *dev)
485 {
486 	kfree(dev);
487 }
488 
tpci200_create_device(struct tpci200_board * tpci200,int i)489 static int tpci200_create_device(struct tpci200_board *tpci200, int i)
490 {
491 	int ret;
492 	enum ipack_space space;
493 	struct ipack_device *dev =
494 		kzalloc(sizeof(struct ipack_device), GFP_KERNEL);
495 	if (!dev)
496 		return -ENOMEM;
497 	dev->slot = i;
498 	dev->bus = tpci200->info->ipack_bus;
499 	dev->release = tpci200_release_device;
500 
501 	for (space = 0; space < IPACK_SPACE_COUNT; space++) {
502 		dev->region[space].start =
503 			tpci200->mod_mem[space]
504 			+ tpci200_space_interval[space] * i;
505 		dev->region[space].size = tpci200_space_size[space];
506 	}
507 
508 	ret = ipack_device_init(dev);
509 	if (ret < 0) {
510 		ipack_put_device(dev);
511 		return ret;
512 	}
513 
514 	ret = ipack_device_add(dev);
515 	if (ret < 0)
516 		ipack_put_device(dev);
517 
518 	return ret;
519 }
520 
tpci200_pci_probe(struct pci_dev * pdev,const struct pci_device_id * id)521 static int tpci200_pci_probe(struct pci_dev *pdev,
522 			     const struct pci_device_id *id)
523 {
524 	int ret, i;
525 	struct tpci200_board *tpci200;
526 	u32 reg32;
527 
528 	tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
529 	if (!tpci200)
530 		return -ENOMEM;
531 
532 	tpci200->info = kzalloc(sizeof(struct tpci200_infos), GFP_KERNEL);
533 	if (!tpci200->info) {
534 		ret = -ENOMEM;
535 		goto out_err_info;
536 	}
537 
538 	pci_dev_get(pdev);
539 
540 	/* Obtain a mapping of the carrier's PCI configuration registers */
541 	ret = pci_request_region(pdev, TPCI200_CFG_MEM_BAR,
542 				 KBUILD_MODNAME " Configuration Memory");
543 	if (ret) {
544 		dev_err(&pdev->dev, "Failed to allocate PCI Configuration Memory");
545 		ret = -EBUSY;
546 		goto out_err_pci_request;
547 	}
548 	tpci200->info->cfg_regs = ioremap_nocache(
549 			pci_resource_start(pdev, TPCI200_CFG_MEM_BAR),
550 			pci_resource_len(pdev, TPCI200_CFG_MEM_BAR));
551 	if (!tpci200->info->cfg_regs) {
552 		dev_err(&pdev->dev, "Failed to map PCI Configuration Memory");
553 		ret = -EFAULT;
554 		goto out_err_ioremap;
555 	}
556 
557 	/* Disable byte swapping for 16 bit IP module access. This will ensure
558 	 * that the Industrypack big endian byte order is preserved by the
559 	 * carrier. */
560 	reg32 = ioread32(tpci200->info->cfg_regs + LAS1_DESC);
561 	reg32 |= 1 << LAS_BIT_BIGENDIAN;
562 	iowrite32(reg32, tpci200->info->cfg_regs + LAS1_DESC);
563 
564 	reg32 = ioread32(tpci200->info->cfg_regs + LAS2_DESC);
565 	reg32 |= 1 << LAS_BIT_BIGENDIAN;
566 	iowrite32(reg32, tpci200->info->cfg_regs + LAS2_DESC);
567 
568 	/* Save struct pci_dev pointer */
569 	tpci200->info->pdev = pdev;
570 	tpci200->info->id_table = (struct pci_device_id *)id;
571 
572 	/* register the device and initialize it */
573 	ret = tpci200_install(tpci200);
574 	if (ret) {
575 		dev_err(&pdev->dev, "error during tpci200 install\n");
576 		ret = -ENODEV;
577 		goto out_err_install;
578 	}
579 
580 	/* Register the carrier in the industry pack bus driver */
581 	tpci200->info->ipack_bus = ipack_bus_register(&pdev->dev,
582 						      TPCI200_NB_SLOT,
583 						      &tpci200_bus_ops,
584 						      THIS_MODULE);
585 	if (!tpci200->info->ipack_bus) {
586 		dev_err(&pdev->dev,
587 			"error registering the carrier on ipack driver\n");
588 		ret = -EFAULT;
589 		goto out_err_bus_register;
590 	}
591 
592 	/* save the bus number given by ipack to logging purpose */
593 	tpci200->number = tpci200->info->ipack_bus->bus_nr;
594 	dev_set_drvdata(&pdev->dev, tpci200);
595 
596 	for (i = 0; i < TPCI200_NB_SLOT; i++)
597 		tpci200_create_device(tpci200, i);
598 	return 0;
599 
600 out_err_bus_register:
601 	tpci200_uninstall(tpci200);
602 out_err_install:
603 	iounmap(tpci200->info->cfg_regs);
604 out_err_ioremap:
605 	pci_release_region(pdev, TPCI200_CFG_MEM_BAR);
606 out_err_pci_request:
607 	pci_dev_put(pdev);
608 	kfree(tpci200->info);
609 out_err_info:
610 	kfree(tpci200);
611 	return ret;
612 }
613 
__tpci200_pci_remove(struct tpci200_board * tpci200)614 static void __tpci200_pci_remove(struct tpci200_board *tpci200)
615 {
616 	ipack_bus_unregister(tpci200->info->ipack_bus);
617 	tpci200_uninstall(tpci200);
618 
619 	kfree(tpci200->info);
620 	kfree(tpci200);
621 }
622 
tpci200_pci_remove(struct pci_dev * dev)623 static void tpci200_pci_remove(struct pci_dev *dev)
624 {
625 	struct tpci200_board *tpci200 = pci_get_drvdata(dev);
626 
627 	__tpci200_pci_remove(tpci200);
628 }
629 
630 static const struct pci_device_id tpci200_idtable[] = {
631 	{ TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
632 	  TPCI200_SUBDEVICE_ID },
633 	{ 0, },
634 };
635 
636 MODULE_DEVICE_TABLE(pci, tpci200_idtable);
637 
638 static struct pci_driver tpci200_pci_drv = {
639 	.name = "tpci200",
640 	.id_table = tpci200_idtable,
641 	.probe = tpci200_pci_probe,
642 	.remove = tpci200_pci_remove,
643 };
644 
645 module_pci_driver(tpci200_pci_drv);
646 
647 MODULE_DESCRIPTION("TEWS TPCI-200 device driver");
648 MODULE_LICENSE("GPL");
649