This source file includes following definitions.
- solo_set_time
- solo_timer_sync
- solo_isr
- free_solo_dev
- eeprom_store
- eeprom_show
- p2m_timeouts_show
- sdram_size_show
- tw28xx_show
- input_map_show
- p2m_timeout_store
- p2m_timeout_show
- intervals_show
- sdram_offsets_show
- sdram_show
- solo_device_release
- solo_sysfs_init
- solo_pci_probe
- solo_pci_remove
1
2
3
4
5
6
7
8
9
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;
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
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
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
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
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 = container_of(kobj, struct device, 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
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 dev->parent = NULL;
424 return -ENOMEM;
425 }
426
427 for (i = 0; i < ARRAY_SIZE(solo_dev_attrs); i++) {
428 if (device_create_file(dev, &solo_dev_attrs[i])) {
429 device_unregister(dev);
430 return -ENOMEM;
431 }
432 }
433
434 sysfs_attr_init(&sdram_attr->attr);
435 sdram_attr->attr.name = "sdram";
436 sdram_attr->attr.mode = 0440;
437 sdram_attr->read = sdram_show;
438 sdram_attr->size = solo_dev->sdram_size;
439
440 if (device_create_bin_file(dev, sdram_attr)) {
441 device_unregister(dev);
442 return -ENOMEM;
443 }
444
445 return 0;
446 }
447
448 static int solo_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
449 {
450 struct solo_dev *solo_dev;
451 int ret;
452 u8 chip_id;
453
454 solo_dev = kzalloc(sizeof(*solo_dev), GFP_KERNEL);
455 if (solo_dev == NULL)
456 return -ENOMEM;
457
458 if (id->driver_data == SOLO_DEV_6010)
459 dev_info(&pdev->dev, "Probing Softlogic 6010\n");
460 else
461 dev_info(&pdev->dev, "Probing Softlogic 6110\n");
462
463 solo_dev->type = id->driver_data;
464 solo_dev->pdev = pdev;
465 ret = v4l2_device_register(&pdev->dev, &solo_dev->v4l2_dev);
466 if (ret)
467 goto fail_probe;
468
469
470 solo_dev->p2m_jiffies = msecs_to_jiffies(100);
471
472 ret = pci_enable_device(pdev);
473 if (ret)
474 goto fail_probe;
475
476 pci_set_master(pdev);
477
478
479 pci_write_config_byte(pdev, 0x40, 0x00);
480 pci_write_config_byte(pdev, 0x41, 0x00);
481
482 ret = pci_request_regions(pdev, SOLO6X10_NAME);
483 if (ret)
484 goto fail_probe;
485
486 solo_dev->reg_base = pci_ioremap_bar(pdev, 0);
487 if (solo_dev->reg_base == NULL) {
488 ret = -ENOMEM;
489 goto fail_probe;
490 }
491
492 chip_id = solo_reg_read(solo_dev, SOLO_CHIP_OPTION) &
493 SOLO_CHIP_ID_MASK;
494 switch (chip_id) {
495 case 7:
496 solo_dev->nr_chans = 16;
497 solo_dev->nr_ext = 5;
498 break;
499 case 6:
500 solo_dev->nr_chans = 8;
501 solo_dev->nr_ext = 2;
502 break;
503 default:
504 dev_warn(&pdev->dev, "Invalid chip_id 0x%02x, assuming 4 ch\n",
505 chip_id);
506
507 case 5:
508 solo_dev->nr_chans = 4;
509 solo_dev->nr_ext = 1;
510 }
511
512
513 solo_irq_off(solo_dev, ~0);
514
515
516 if (solo_dev->type == SOLO_DEV_6010) {
517 solo_dev->clock_mhz = 108;
518 solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT
519 | SOLO_SYS_CFG_INPUTDIV(25)
520 | SOLO_SYS_CFG_FEEDBACKDIV(solo_dev->clock_mhz * 2 - 2)
521 | SOLO_SYS_CFG_OUTDIV(3);
522 solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config);
523 } else {
524 u32 divq, divf;
525
526 solo_dev->clock_mhz = 135;
527
528 if (solo_dev->clock_mhz < 125) {
529 divq = 3;
530 divf = (solo_dev->clock_mhz * 4) / 3 - 1;
531 } else {
532 divq = 2;
533 divf = (solo_dev->clock_mhz * 2) / 3 - 1;
534 }
535
536 solo_reg_write(solo_dev, SOLO_PLL_CONFIG,
537 (1 << 20) |
538 (8 << 15) |
539 (divq << 12) |
540 (divf << 4) |
541 (1 << 1) );
542
543 solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT;
544 }
545
546 solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config);
547 solo_reg_write(solo_dev, SOLO_TIMER_CLOCK_NUM,
548 solo_dev->clock_mhz - 1);
549
550
551 mdelay(1);
552
553 ret = request_irq(pdev->irq, solo_isr, IRQF_SHARED, SOLO6X10_NAME,
554 solo_dev);
555 if (ret)
556 goto fail_probe;
557
558
559 solo_irq_on(solo_dev, SOLO_IRQ_PCI_ERR);
560
561 ret = solo_i2c_init(solo_dev);
562 if (ret)
563 goto fail_probe;
564
565
566 solo_reg_write(solo_dev, SOLO_DMA_CTRL,
567 SOLO_DMA_CTRL_REFRESH_CYCLE(1) |
568 SOLO_DMA_CTRL_SDRAM_SIZE(2) |
569 SOLO_DMA_CTRL_SDRAM_CLK_INVERT |
570 SOLO_DMA_CTRL_READ_CLK_SELECT |
571 SOLO_DMA_CTRL_LATENCY(1));
572
573
574 solo_reg_write(solo_dev, SOLO_DMA_CTRL1,
575 solo_dev->type == SOLO_DEV_6010 ? 0x100 : 0x300);
576
577 if (solo_dev->type != SOLO_DEV_6010) {
578 solo_dev->usec_lsb = 0x3f;
579 solo_set_time(solo_dev);
580 }
581
582
583 solo_reg_write(solo_dev, SOLO_WATCHDOG, 0);
584
585
586
587 ret = solo_p2m_init(solo_dev);
588 if (ret)
589 goto fail_probe;
590
591 ret = solo_disp_init(solo_dev);
592 if (ret)
593 goto fail_probe;
594
595 ret = solo_gpio_init(solo_dev);
596 if (ret)
597 goto fail_probe;
598
599 ret = solo_tw28_init(solo_dev);
600 if (ret)
601 goto fail_probe;
602
603 ret = solo_v4l2_init(solo_dev, video_nr);
604 if (ret)
605 goto fail_probe;
606
607 ret = solo_enc_init(solo_dev);
608 if (ret)
609 goto fail_probe;
610
611 ret = solo_enc_v4l2_init(solo_dev, video_nr);
612 if (ret)
613 goto fail_probe;
614
615 ret = solo_g723_init(solo_dev);
616 if (ret)
617 goto fail_probe;
618
619 ret = solo_sysfs_init(solo_dev);
620 if (ret)
621 goto fail_probe;
622
623
624 solo_dev->p2m_jiffies = msecs_to_jiffies(20);
625
626 return 0;
627
628 fail_probe:
629 free_solo_dev(solo_dev);
630 return ret;
631 }
632
633 static void solo_pci_remove(struct pci_dev *pdev)
634 {
635 struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev);
636 struct solo_dev *solo_dev = container_of(v4l2_dev, struct solo_dev, v4l2_dev);
637
638 free_solo_dev(solo_dev);
639 }
640
641 static const struct pci_device_id solo_id_table[] = {
642
643 { PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6010),
644 .driver_data = SOLO_DEV_6010 },
645 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_4),
646 .driver_data = SOLO_DEV_6010 },
647 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_9),
648 .driver_data = SOLO_DEV_6010 },
649 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_16),
650 .driver_data = SOLO_DEV_6010 },
651 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_4),
652 .driver_data = SOLO_DEV_6010 },
653 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_9),
654 .driver_data = SOLO_DEV_6010 },
655 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_16),
656 .driver_data = SOLO_DEV_6010 },
657
658 { PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6110),
659 .driver_data = SOLO_DEV_6110 },
660 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_4),
661 .driver_data = SOLO_DEV_6110 },
662 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_8),
663 .driver_data = SOLO_DEV_6110 },
664 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_16),
665 .driver_data = SOLO_DEV_6110 },
666 {0,}
667 };
668
669 MODULE_DEVICE_TABLE(pci, solo_id_table);
670
671 static struct pci_driver solo_pci_driver = {
672 .name = SOLO6X10_NAME,
673 .id_table = solo_id_table,
674 .probe = solo_pci_probe,
675 .remove = solo_pci_remove,
676 };
677
678 module_pci_driver(solo_pci_driver);