1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2010-2013 Bluecherry, LLC <https://www.bluecherrydvr.com>
4  *
5  * Original author:
6  * Ben Collins <bcollins@ubuntu.com>
7  *
8  * Additional work by:
9  * John Brooks <john.brooks@bluecherry.net>
10  */
11 
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/pci.h>
15 #include <linux/interrupt.h>
16 #include <linux/videodev2.h>
17 #include <linux/delay.h>
18 #include <linux/sysfs.h>
19 #include <linux/ktime.h>
20 #include <linux/slab.h>
21 
22 #include "solo6x10.h"
23 #include "solo6x10-tw28.h"
24 
25 MODULE_DESCRIPTION("Softlogic 6x10 MPEG4/H.264/G.723 CODEC V4L2/ALSA Driver");
26 MODULE_AUTHOR("Bluecherry <maintainers@bluecherrydvr.com>");
27 MODULE_VERSION(SOLO6X10_VERSION);
28 MODULE_LICENSE("GPL");
29 
30 static unsigned video_nr = -1;
31 module_param(video_nr, uint, 0644);
32 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect (default)");
33 
34 static int full_eeprom; /* default is only top 64B */
35 module_param(full_eeprom, uint, 0644);
36 MODULE_PARM_DESC(full_eeprom, "Allow access to full 128B EEPROM (dangerous)");
37 
38 
39 static void solo_set_time(struct solo_dev *solo_dev)
40 {
41 	struct timespec64 ts;
42 
43 	ktime_get_ts64(&ts);
44 
45 	/* no overflow because we use monotonic timestamps */
46 	solo_reg_write(solo_dev, SOLO_TIMER_SEC, (u32)ts.tv_sec);
47 	solo_reg_write(solo_dev, SOLO_TIMER_USEC, (u32)ts.tv_nsec / NSEC_PER_USEC);
48 }
49 
50 static void solo_timer_sync(struct solo_dev *solo_dev)
51 {
52 	u32 sec, usec;
53 	struct timespec64 ts;
54 	long diff;
55 
56 	if (solo_dev->type != SOLO_DEV_6110)
57 		return;
58 
59 	if (++solo_dev->time_sync < 60)
60 		return;
61 
62 	solo_dev->time_sync = 0;
63 
64 	sec = solo_reg_read(solo_dev, SOLO_TIMER_SEC);
65 	usec = solo_reg_read(solo_dev, SOLO_TIMER_USEC);
66 
67 	ktime_get_ts64(&ts);
68 
69 	diff = (s32)ts.tv_sec - (s32)sec;
70 	diff = (diff * 1000000)
71 		+ ((s32)(ts.tv_nsec / NSEC_PER_USEC) - (s32)usec);
72 
73 	if (diff > 1000 || diff < -1000) {
74 		solo_set_time(solo_dev);
75 	} else if (diff) {
76 		long usec_lsb = solo_dev->usec_lsb;
77 
78 		usec_lsb -= diff / 4;
79 		if (usec_lsb < 0)
80 			usec_lsb = 0;
81 		else if (usec_lsb > 255)
82 			usec_lsb = 255;
83 
84 		solo_dev->usec_lsb = usec_lsb;
85 		solo_reg_write(solo_dev, SOLO_TIMER_USEC_LSB,
86 			       solo_dev->usec_lsb);
87 	}
88 }
89 
90 static irqreturn_t solo_isr(int irq, void *data)
91 {
92 	struct solo_dev *solo_dev = data;
93 	u32 status;
94 	int i;
95 
96 	status = solo_reg_read(solo_dev, SOLO_IRQ_STAT);
97 	if (!status)
98 		return IRQ_NONE;
99 
100 	/* Acknowledge all interrupts immediately */
101 	solo_reg_write(solo_dev, SOLO_IRQ_STAT, status);
102 
103 	if (status & SOLO_IRQ_PCI_ERR)
104 		solo_p2m_error_isr(solo_dev);
105 
106 	for (i = 0; i < SOLO_NR_P2M; i++)
107 		if (status & SOLO_IRQ_P2M(i))
108 			solo_p2m_isr(solo_dev, i);
109 
110 	if (status & SOLO_IRQ_IIC)
111 		solo_i2c_isr(solo_dev);
112 
113 	if (status & SOLO_IRQ_VIDEO_IN) {
114 		solo_video_in_isr(solo_dev);
115 		solo_timer_sync(solo_dev);
116 	}
117 
118 	if (status & SOLO_IRQ_ENCODER)
119 		solo_enc_v4l2_isr(solo_dev);
120 
121 	if (status & SOLO_IRQ_G723)
122 		solo_g723_isr(solo_dev);
123 
124 	return IRQ_HANDLED;
125 }
126 
127 static void free_solo_dev(struct solo_dev *solo_dev)
128 {
129 	struct pci_dev *pdev = solo_dev->pdev;
130 
131 	if (solo_dev->dev.parent)
132 		device_unregister(&solo_dev->dev);
133 
134 	if (solo_dev->reg_base) {
135 		/* Bring down the sub-devices first */
136 		solo_g723_exit(solo_dev);
137 		solo_enc_v4l2_exit(solo_dev);
138 		solo_enc_exit(solo_dev);
139 		solo_v4l2_exit(solo_dev);
140 		solo_disp_exit(solo_dev);
141 		solo_gpio_exit(solo_dev);
142 		solo_p2m_exit(solo_dev);
143 		solo_i2c_exit(solo_dev);
144 
145 		/* Now cleanup the PCI device */
146 		solo_irq_off(solo_dev, ~0);
147 		free_irq(pdev->irq, solo_dev);
148 		pci_iounmap(pdev, solo_dev->reg_base);
149 	}
150 
151 	pci_release_regions(pdev);
152 	pci_disable_device(pdev);
153 	v4l2_device_unregister(&solo_dev->v4l2_dev);
154 	pci_set_drvdata(pdev, NULL);
155 
156 	kfree(solo_dev);
157 }
158 
159 static ssize_t eeprom_store(struct device *dev, struct device_attribute *attr,
160 			    const char *buf, size_t count)
161 {
162 	struct solo_dev *solo_dev =
163 		container_of(dev, struct solo_dev, dev);
164 	u16 *p = (u16 *)buf;
165 	int i;
166 
167 	if (count & 0x1)
168 		dev_warn(dev, "EEPROM Write not aligned (truncating)\n");
169 
170 	if (!full_eeprom && count > 64) {
171 		dev_warn(dev, "EEPROM Write truncated to 64 bytes\n");
172 		count = 64;
173 	} else if (full_eeprom && count > 128) {
174 		dev_warn(dev, "EEPROM Write truncated to 128 bytes\n");
175 		count = 128;
176 	}
177 
178 	solo_eeprom_ewen(solo_dev, 1);
179 
180 	for (i = full_eeprom ? 0 : 32; i < min((int)(full_eeprom ? 64 : 32),
181 					       (int)(count / 2)); i++)
182 		solo_eeprom_write(solo_dev, i, cpu_to_be16(p[i]));
183 
184 	solo_eeprom_ewen(solo_dev, 0);
185 
186 	return count;
187 }
188 
189 static ssize_t eeprom_show(struct device *dev, struct device_attribute *attr,
190 			   char *buf)
191 {
192 	struct solo_dev *solo_dev =
193 		container_of(dev, struct solo_dev, dev);
194 	u16 *p = (u16 *)buf;
195 	int count = (full_eeprom ? 128 : 64);
196 	int i;
197 
198 	for (i = (full_eeprom ? 0 : 32); i < (count / 2); i++)
199 		p[i] = be16_to_cpu(solo_eeprom_read(solo_dev, i));
200 
201 	return count;
202 }
203 
204 static ssize_t p2m_timeouts_show(struct device *dev,
205 				 struct device_attribute *attr,
206 				 char *buf)
207 {
208 	struct solo_dev *solo_dev =
209 		container_of(dev, struct solo_dev, dev);
210 
211 	return sprintf(buf, "%d\n", solo_dev->p2m_timeouts);
212 }
213 
214 static ssize_t sdram_size_show(struct device *dev,
215 			       struct device_attribute *attr,
216 			       char *buf)
217 {
218 	struct solo_dev *solo_dev =
219 		container_of(dev, struct solo_dev, dev);
220 
221 	return sprintf(buf, "%dMegs\n", solo_dev->sdram_size >> 20);
222 }
223 
224 static ssize_t tw28xx_show(struct device *dev,
225 			   struct device_attribute *attr,
226 			   char *buf)
227 {
228 	struct solo_dev *solo_dev =
229 		container_of(dev, struct solo_dev, dev);
230 
231 	return sprintf(buf, "tw2815[%d] tw2864[%d] tw2865[%d]\n",
232 		       hweight32(solo_dev->tw2815),
233 		       hweight32(solo_dev->tw2864),
234 		       hweight32(solo_dev->tw2865));
235 }
236 
237 static ssize_t input_map_show(struct device *dev,
238 			      struct device_attribute *attr,
239 			      char *buf)
240 {
241 	struct solo_dev *solo_dev =
242 		container_of(dev, struct solo_dev, dev);
243 	unsigned int val;
244 	char *out = buf;
245 
246 	val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_0);
247 	out += sprintf(out, "Channel 0   => Input %d\n", val & 0x1f);
248 	out += sprintf(out, "Channel 1   => Input %d\n", (val >> 5) & 0x1f);
249 	out += sprintf(out, "Channel 2   => Input %d\n", (val >> 10) & 0x1f);
250 	out += sprintf(out, "Channel 3   => Input %d\n", (val >> 15) & 0x1f);
251 	out += sprintf(out, "Channel 4   => Input %d\n", (val >> 20) & 0x1f);
252 	out += sprintf(out, "Channel 5   => Input %d\n", (val >> 25) & 0x1f);
253 
254 	val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_1);
255 	out += sprintf(out, "Channel 6   => Input %d\n", val & 0x1f);
256 	out += sprintf(out, "Channel 7   => Input %d\n", (val >> 5) & 0x1f);
257 	out += sprintf(out, "Channel 8   => Input %d\n", (val >> 10) & 0x1f);
258 	out += sprintf(out, "Channel 9   => Input %d\n", (val >> 15) & 0x1f);
259 	out += sprintf(out, "Channel 10  => Input %d\n", (val >> 20) & 0x1f);
260 	out += sprintf(out, "Channel 11  => Input %d\n", (val >> 25) & 0x1f);
261 
262 	val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_2);
263 	out += sprintf(out, "Channel 12  => Input %d\n", val & 0x1f);
264 	out += sprintf(out, "Channel 13  => Input %d\n", (val >> 5) & 0x1f);
265 	out += sprintf(out, "Channel 14  => Input %d\n", (val >> 10) & 0x1f);
266 	out += sprintf(out, "Channel 15  => Input %d\n", (val >> 15) & 0x1f);
267 	out += sprintf(out, "Spot Output => Input %d\n", (val >> 20) & 0x1f);
268 
269 	return out - buf;
270 }
271 
272 static ssize_t p2m_timeout_store(struct device *dev,
273 				 struct device_attribute *attr,
274 				 const char *buf, size_t count)
275 {
276 	struct solo_dev *solo_dev =
277 		container_of(dev, struct solo_dev, dev);
278 	unsigned long ms;
279 	int ret = kstrtoul(buf, 10, &ms);
280 
281 	if (ret < 0 || ms > 200)
282 		return -EINVAL;
283 	solo_dev->p2m_jiffies = msecs_to_jiffies(ms);
284 
285 	return count;
286 }
287 
288 static ssize_t p2m_timeout_show(struct device *dev,
289 				struct device_attribute *attr,
290 				char *buf)
291 {
292 	struct solo_dev *solo_dev =
293 		container_of(dev, struct solo_dev, dev);
294 
295 	return sprintf(buf, "%ums\n", jiffies_to_msecs(solo_dev->p2m_jiffies));
296 }
297 
298 static ssize_t intervals_show(struct device *dev,
299 			      struct device_attribute *attr,
300 			      char *buf)
301 {
302 	struct solo_dev *solo_dev =
303 		container_of(dev, struct solo_dev, dev);
304 	char *out = buf;
305 	int fps = solo_dev->fps;
306 	int i;
307 
308 	for (i = 0; i < solo_dev->nr_chans; i++) {
309 		out += sprintf(out, "Channel %d: %d/%d (0x%08x)\n",
310 			       i, solo_dev->v4l2_enc[i]->interval, fps,
311 			       solo_reg_read(solo_dev, SOLO_CAP_CH_INTV(i)));
312 	}
313 
314 	return out - buf;
315 }
316 
317 static ssize_t sdram_offsets_show(struct device *dev,
318 				  struct device_attribute *attr,
319 				  char *buf)
320 {
321 	struct solo_dev *solo_dev =
322 		container_of(dev, struct solo_dev, dev);
323 	char *out = buf;
324 
325 	out += sprintf(out, "DISP: 0x%08x @ 0x%08x\n",
326 		       SOLO_DISP_EXT_ADDR,
327 		       SOLO_DISP_EXT_SIZE);
328 
329 	out += sprintf(out, "EOSD: 0x%08x @ 0x%08x (0x%08x * %d)\n",
330 		       SOLO_EOSD_EXT_ADDR,
331 		       SOLO_EOSD_EXT_AREA(solo_dev),
332 		       SOLO_EOSD_EXT_SIZE(solo_dev),
333 		       SOLO_EOSD_EXT_AREA(solo_dev) /
334 		       SOLO_EOSD_EXT_SIZE(solo_dev));
335 
336 	out += sprintf(out, "MOTI: 0x%08x @ 0x%08x\n",
337 		       SOLO_MOTION_EXT_ADDR(solo_dev),
338 		       SOLO_MOTION_EXT_SIZE);
339 
340 	out += sprintf(out, "G723: 0x%08x @ 0x%08x\n",
341 		       SOLO_G723_EXT_ADDR(solo_dev),
342 		       SOLO_G723_EXT_SIZE);
343 
344 	out += sprintf(out, "CAPT: 0x%08x @ 0x%08x (0x%08x * %d)\n",
345 		       SOLO_CAP_EXT_ADDR(solo_dev),
346 		       SOLO_CAP_EXT_SIZE(solo_dev),
347 		       SOLO_CAP_PAGE_SIZE,
348 		       SOLO_CAP_EXT_SIZE(solo_dev) / SOLO_CAP_PAGE_SIZE);
349 
350 	out += sprintf(out, "EREF: 0x%08x @ 0x%08x (0x%08x * %d)\n",
351 		       SOLO_EREF_EXT_ADDR(solo_dev),
352 		       SOLO_EREF_EXT_AREA(solo_dev),
353 		       SOLO_EREF_EXT_SIZE,
354 		       SOLO_EREF_EXT_AREA(solo_dev) / SOLO_EREF_EXT_SIZE);
355 
356 	out += sprintf(out, "MPEG: 0x%08x @ 0x%08x\n",
357 		       SOLO_MP4E_EXT_ADDR(solo_dev),
358 		       SOLO_MP4E_EXT_SIZE(solo_dev));
359 
360 	out += sprintf(out, "JPEG: 0x%08x @ 0x%08x\n",
361 		       SOLO_JPEG_EXT_ADDR(solo_dev),
362 		       SOLO_JPEG_EXT_SIZE(solo_dev));
363 
364 	return out - buf;
365 }
366 
367 static ssize_t sdram_show(struct file *file, struct kobject *kobj,
368 			  struct bin_attribute *a, char *buf,
369 			  loff_t off, size_t count)
370 {
371 	struct device *dev = kobj_to_dev(kobj);
372 	struct solo_dev *solo_dev =
373 		container_of(dev, struct solo_dev, dev);
374 	const int size = solo_dev->sdram_size;
375 
376 	if (off >= size)
377 		return 0;
378 
379 	if (off + count > size)
380 		count = size - off;
381 
382 	if (solo_p2m_dma(solo_dev, 0, buf, off, count, 0, 0))
383 		return -EIO;
384 
385 	return count;
386 }
387 
388 static const struct device_attribute solo_dev_attrs[] = {
389 	__ATTR(eeprom, 0640, eeprom_show, eeprom_store),
390 	__ATTR(p2m_timeout, 0644, p2m_timeout_show, p2m_timeout_store),
391 	__ATTR_RO(p2m_timeouts),
392 	__ATTR_RO(sdram_size),
393 	__ATTR_RO(tw28xx),
394 	__ATTR_RO(input_map),
395 	__ATTR_RO(intervals),
396 	__ATTR_RO(sdram_offsets),
397 };
398 
399 static void solo_device_release(struct device *dev)
400 {
401 	/* Do nothing */
402 }
403 
404 static int solo_sysfs_init(struct solo_dev *solo_dev)
405 {
406 	struct bin_attribute *sdram_attr = &solo_dev->sdram_attr;
407 	struct device *dev = &solo_dev->dev;
408 	const char *driver;
409 	int i;
410 
411 	if (solo_dev->type == SOLO_DEV_6110)
412 		driver = "solo6110";
413 	else
414 		driver = "solo6010";
415 
416 	dev->release = solo_device_release;
417 	dev->parent = &solo_dev->pdev->dev;
418 	set_dev_node(dev, dev_to_node(&solo_dev->pdev->dev));
419 	dev_set_name(dev, "%s-%d-%d", driver, solo_dev->vfd->num,
420 		     solo_dev->nr_chans);
421 
422 	if (device_register(dev)) {
423 		put_device(dev);
424 		dev->parent = NULL;
425 		return -ENOMEM;
426 	}
427 
428 	for (i = 0; i < ARRAY_SIZE(solo_dev_attrs); i++) {
429 		if (device_create_file(dev, &solo_dev_attrs[i])) {
430 			device_unregister(dev);
431 			return -ENOMEM;
432 		}
433 	}
434 
435 	sysfs_attr_init(&sdram_attr->attr);
436 	sdram_attr->attr.name = "sdram";
437 	sdram_attr->attr.mode = 0440;
438 	sdram_attr->read = sdram_show;
439 	sdram_attr->size = solo_dev->sdram_size;
440 
441 	if (device_create_bin_file(dev, sdram_attr)) {
442 		device_unregister(dev);
443 		return -ENOMEM;
444 	}
445 
446 	return 0;
447 }
448 
449 static int solo_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
450 {
451 	struct solo_dev *solo_dev;
452 	int ret;
453 	u8 chip_id;
454 
455 	solo_dev = kzalloc(sizeof(*solo_dev), GFP_KERNEL);
456 	if (solo_dev == NULL)
457 		return -ENOMEM;
458 
459 	if (id->driver_data == SOLO_DEV_6010)
460 		dev_info(&pdev->dev, "Probing Softlogic 6010\n");
461 	else
462 		dev_info(&pdev->dev, "Probing Softlogic 6110\n");
463 
464 	solo_dev->type = id->driver_data;
465 	solo_dev->pdev = pdev;
466 	ret = v4l2_device_register(&pdev->dev, &solo_dev->v4l2_dev);
467 	if (ret)
468 		goto fail_probe;
469 
470 	/* Only for during init */
471 	solo_dev->p2m_jiffies = msecs_to_jiffies(100);
472 
473 	ret = pci_enable_device(pdev);
474 	if (ret)
475 		goto fail_probe;
476 
477 	pci_set_master(pdev);
478 
479 	/* RETRY/TRDY Timeout disabled */
480 	pci_write_config_byte(pdev, 0x40, 0x00);
481 	pci_write_config_byte(pdev, 0x41, 0x00);
482 
483 	ret = pci_request_regions(pdev, SOLO6X10_NAME);
484 	if (ret)
485 		goto fail_probe;
486 
487 	solo_dev->reg_base = pci_ioremap_bar(pdev, 0);
488 	if (solo_dev->reg_base == NULL) {
489 		ret = -ENOMEM;
490 		goto fail_probe;
491 	}
492 
493 	chip_id = solo_reg_read(solo_dev, SOLO_CHIP_OPTION) &
494 				SOLO_CHIP_ID_MASK;
495 	switch (chip_id) {
496 	case 7:
497 		solo_dev->nr_chans = 16;
498 		solo_dev->nr_ext = 5;
499 		break;
500 	case 6:
501 		solo_dev->nr_chans = 8;
502 		solo_dev->nr_ext = 2;
503 		break;
504 	default:
505 		dev_warn(&pdev->dev, "Invalid chip_id 0x%02x, assuming 4 ch\n",
506 			 chip_id);
507 		fallthrough;
508 	case 5:
509 		solo_dev->nr_chans = 4;
510 		solo_dev->nr_ext = 1;
511 	}
512 
513 	/* Disable all interrupts to start */
514 	solo_irq_off(solo_dev, ~0);
515 
516 	/* Initial global settings */
517 	if (solo_dev->type == SOLO_DEV_6010) {
518 		solo_dev->clock_mhz = 108;
519 		solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT
520 			| SOLO_SYS_CFG_INPUTDIV(25)
521 			| SOLO_SYS_CFG_FEEDBACKDIV(solo_dev->clock_mhz * 2 - 2)
522 			| SOLO_SYS_CFG_OUTDIV(3);
523 		solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config);
524 	} else {
525 		u32 divq, divf;
526 
527 		solo_dev->clock_mhz = 135;
528 
529 		if (solo_dev->clock_mhz < 125) {
530 			divq = 3;
531 			divf = (solo_dev->clock_mhz * 4) / 3 - 1;
532 		} else {
533 			divq = 2;
534 			divf = (solo_dev->clock_mhz * 2) / 3 - 1;
535 		}
536 
537 		solo_reg_write(solo_dev, SOLO_PLL_CONFIG,
538 			       (1 << 20) | /* PLL_RANGE */
539 			       (8 << 15) | /* PLL_DIVR  */
540 			       (divq << 12) |
541 			       (divf <<  4) |
542 			       (1 <<  1)   /* PLL_FSEN */);
543 
544 		solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT;
545 	}
546 
547 	solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config);
548 	solo_reg_write(solo_dev, SOLO_TIMER_CLOCK_NUM,
549 		       solo_dev->clock_mhz - 1);
550 
551 	/* PLL locking time of 1ms */
552 	mdelay(1);
553 
554 	ret = request_irq(pdev->irq, solo_isr, IRQF_SHARED, SOLO6X10_NAME,
555 			  solo_dev);
556 	if (ret)
557 		goto fail_probe;
558 
559 	/* Handle this from the start */
560 	solo_irq_on(solo_dev, SOLO_IRQ_PCI_ERR);
561 
562 	ret = solo_i2c_init(solo_dev);
563 	if (ret)
564 		goto fail_probe;
565 
566 	/* Setup the DMA engine */
567 	solo_reg_write(solo_dev, SOLO_DMA_CTRL,
568 		       SOLO_DMA_CTRL_REFRESH_CYCLE(1) |
569 		       SOLO_DMA_CTRL_SDRAM_SIZE(2) |
570 		       SOLO_DMA_CTRL_SDRAM_CLK_INVERT |
571 		       SOLO_DMA_CTRL_READ_CLK_SELECT |
572 		       SOLO_DMA_CTRL_LATENCY(1));
573 
574 	/* Undocumented crap */
575 	solo_reg_write(solo_dev, SOLO_DMA_CTRL1,
576 		       solo_dev->type == SOLO_DEV_6010 ? 0x100 : 0x300);
577 
578 	if (solo_dev->type != SOLO_DEV_6010) {
579 		solo_dev->usec_lsb = 0x3f;
580 		solo_set_time(solo_dev);
581 	}
582 
583 	/* Disable watchdog */
584 	solo_reg_write(solo_dev, SOLO_WATCHDOG, 0);
585 
586 	/* Initialize sub components */
587 
588 	ret = solo_p2m_init(solo_dev);
589 	if (ret)
590 		goto fail_probe;
591 
592 	ret = solo_disp_init(solo_dev);
593 	if (ret)
594 		goto fail_probe;
595 
596 	ret = solo_gpio_init(solo_dev);
597 	if (ret)
598 		goto fail_probe;
599 
600 	ret = solo_tw28_init(solo_dev);
601 	if (ret)
602 		goto fail_probe;
603 
604 	ret = solo_v4l2_init(solo_dev, video_nr);
605 	if (ret)
606 		goto fail_probe;
607 
608 	ret = solo_enc_init(solo_dev);
609 	if (ret)
610 		goto fail_probe;
611 
612 	ret = solo_enc_v4l2_init(solo_dev, video_nr);
613 	if (ret)
614 		goto fail_probe;
615 
616 	ret = solo_g723_init(solo_dev);
617 	if (ret)
618 		goto fail_probe;
619 
620 	ret = solo_sysfs_init(solo_dev);
621 	if (ret)
622 		goto fail_probe;
623 
624 	/* Now that init is over, set this lower */
625 	solo_dev->p2m_jiffies = msecs_to_jiffies(20);
626 
627 	return 0;
628 
629 fail_probe:
630 	free_solo_dev(solo_dev);
631 	return ret;
632 }
633 
634 static void solo_pci_remove(struct pci_dev *pdev)
635 {
636 	struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev);
637 	struct solo_dev *solo_dev = container_of(v4l2_dev, struct solo_dev, v4l2_dev);
638 
639 	free_solo_dev(solo_dev);
640 }
641 
642 static const struct pci_device_id solo_id_table[] = {
643 	/* 6010 based cards */
644 	{ PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6010),
645 	  .driver_data = SOLO_DEV_6010 },
646 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_4),
647 	  .driver_data = SOLO_DEV_6010 },
648 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_9),
649 	  .driver_data = SOLO_DEV_6010 },
650 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_16),
651 	  .driver_data = SOLO_DEV_6010 },
652 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_4),
653 	  .driver_data = SOLO_DEV_6010 },
654 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_9),
655 	  .driver_data = SOLO_DEV_6010 },
656 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_16),
657 	  .driver_data = SOLO_DEV_6010 },
658 	/* 6110 based cards */
659 	{ PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6110),
660 	  .driver_data = SOLO_DEV_6110 },
661 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_4),
662 	  .driver_data = SOLO_DEV_6110 },
663 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_8),
664 	  .driver_data = SOLO_DEV_6110 },
665 	{ PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_16),
666 	  .driver_data = SOLO_DEV_6110 },
667 	{0,}
668 };
669 
670 MODULE_DEVICE_TABLE(pci, solo_id_table);
671 
672 static struct pci_driver solo_pci_driver = {
673 	.name = SOLO6X10_NAME,
674 	.id_table = solo_id_table,
675 	.probe = solo_pci_probe,
676 	.remove = solo_pci_remove,
677 };
678 
679 module_pci_driver(solo_pci_driver);
680