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