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