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