1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40#include <linux/kernel.h>
41#include <linux/module.h>
42#include <linux/delay.h>
43#include <linux/ctype.h>
44#include <linux/jiffies.h>
45#include <linux/slab.h>
46#include <linux/timer.h>
47
48#include "../comedi_pci.h"
49
50#include "jr3_pci.h"
51
52#define PCI_VENDOR_ID_JR3 0x1762
53
54enum jr3_pci_boardid {
55 BOARD_JR3_1,
56 BOARD_JR3_2,
57 BOARD_JR3_3,
58 BOARD_JR3_4,
59};
60
61struct jr3_pci_board {
62 const char *name;
63 int n_subdevs;
64};
65
66static const struct jr3_pci_board jr3_pci_boards[] = {
67 [BOARD_JR3_1] = {
68 .name = "jr3_pci_1",
69 .n_subdevs = 1,
70 },
71 [BOARD_JR3_2] = {
72 .name = "jr3_pci_2",
73 .n_subdevs = 2,
74 },
75 [BOARD_JR3_3] = {
76 .name = "jr3_pci_3",
77 .n_subdevs = 3,
78 },
79 [BOARD_JR3_4] = {
80 .name = "jr3_pci_4",
81 .n_subdevs = 4,
82 },
83};
84
85struct jr3_pci_transform {
86 struct {
87 u16 link_type;
88 s16 link_amount;
89 } link[8];
90};
91
92struct jr3_pci_poll_delay {
93 int min;
94 int max;
95};
96
97struct jr3_pci_dev_private {
98 struct jr3_t __iomem *iobase;
99 struct timer_list timer;
100};
101
102struct jr3_pci_subdev_private {
103 struct jr3_channel __iomem *channel;
104 unsigned long next_time_min;
105 unsigned long next_time_max;
106 enum { state_jr3_poll,
107 state_jr3_init_wait_for_offset,
108 state_jr3_init_transform_complete,
109 state_jr3_init_set_full_scale_complete,
110 state_jr3_init_use_offset_complete,
111 state_jr3_done
112 } state;
113 int serial_no;
114 int model_no;
115 struct {
116 int length;
117 struct comedi_krange range;
118 } range[9];
119 const struct comedi_lrange *range_table_list[8 * 7 + 2];
120 unsigned int maxdata_list[8 * 7 + 2];
121 u16 errors;
122 int retries;
123};
124
125static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max)
126{
127 struct jr3_pci_poll_delay result;
128
129 result.min = min;
130 result.max = max;
131 return result;
132}
133
134static int is_complete(struct jr3_channel __iomem *channel)
135{
136 return get_s16(&channel->command_word0) == 0;
137}
138
139static void set_transforms(struct jr3_channel __iomem *channel,
140 struct jr3_pci_transform transf, short num)
141{
142 int i;
143
144 num &= 0x000f;
145 for (i = 0; i < 8; i++) {
146 set_u16(&channel->transforms[num].link[i].link_type,
147 transf.link[i].link_type);
148 udelay(1);
149 set_s16(&channel->transforms[num].link[i].link_amount,
150 transf.link[i].link_amount);
151 udelay(1);
152 if (transf.link[i].link_type == end_x_form)
153 break;
154 }
155}
156
157static void use_transform(struct jr3_channel __iomem *channel,
158 short transf_num)
159{
160 set_s16(&channel->command_word0, 0x0500 + (transf_num & 0x000f));
161}
162
163static void use_offset(struct jr3_channel __iomem *channel, short offset_num)
164{
165 set_s16(&channel->command_word0, 0x0600 + (offset_num & 0x000f));
166}
167
168static void set_offset(struct jr3_channel __iomem *channel)
169{
170 set_s16(&channel->command_word0, 0x0700);
171}
172
173struct six_axis_t {
174 s16 fx;
175 s16 fy;
176 s16 fz;
177 s16 mx;
178 s16 my;
179 s16 mz;
180};
181
182static void set_full_scales(struct jr3_channel __iomem *channel,
183 struct six_axis_t full_scale)
184{
185 set_s16(&channel->full_scale.fx, full_scale.fx);
186 set_s16(&channel->full_scale.fy, full_scale.fy);
187 set_s16(&channel->full_scale.fz, full_scale.fz);
188 set_s16(&channel->full_scale.mx, full_scale.mx);
189 set_s16(&channel->full_scale.my, full_scale.my);
190 set_s16(&channel->full_scale.mz, full_scale.mz);
191 set_s16(&channel->command_word0, 0x0a00);
192}
193
194static struct six_axis_t get_min_full_scales(struct jr3_channel __iomem
195 *channel)
196{
197 struct six_axis_t result;
198
199 result.fx = get_s16(&channel->min_full_scale.fx);
200 result.fy = get_s16(&channel->min_full_scale.fy);
201 result.fz = get_s16(&channel->min_full_scale.fz);
202 result.mx = get_s16(&channel->min_full_scale.mx);
203 result.my = get_s16(&channel->min_full_scale.my);
204 result.mz = get_s16(&channel->min_full_scale.mz);
205 return result;
206}
207
208static struct six_axis_t get_max_full_scales(struct jr3_channel __iomem
209 *channel)
210{
211 struct six_axis_t result;
212
213 result.fx = get_s16(&channel->max_full_scale.fx);
214 result.fy = get_s16(&channel->max_full_scale.fy);
215 result.fz = get_s16(&channel->max_full_scale.fz);
216 result.mx = get_s16(&channel->max_full_scale.mx);
217 result.my = get_s16(&channel->max_full_scale.my);
218 result.mz = get_s16(&channel->max_full_scale.mz);
219 return result;
220}
221
222static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
223 struct comedi_subdevice *s,
224 unsigned int chan)
225{
226 struct jr3_pci_subdev_private *spriv = s->private;
227 unsigned int val = 0;
228
229 if (spriv->state != state_jr3_done)
230 return 0;
231
232 if (chan < 56) {
233 unsigned int axis = chan % 8;
234 unsigned int filter = chan / 8;
235
236 switch (axis) {
237 case 0:
238 val = get_s16(&spriv->channel->filter[filter].fx);
239 break;
240 case 1:
241 val = get_s16(&spriv->channel->filter[filter].fy);
242 break;
243 case 2:
244 val = get_s16(&spriv->channel->filter[filter].fz);
245 break;
246 case 3:
247 val = get_s16(&spriv->channel->filter[filter].mx);
248 break;
249 case 4:
250 val = get_s16(&spriv->channel->filter[filter].my);
251 break;
252 case 5:
253 val = get_s16(&spriv->channel->filter[filter].mz);
254 break;
255 case 6:
256 val = get_s16(&spriv->channel->filter[filter].v1);
257 break;
258 case 7:
259 val = get_s16(&spriv->channel->filter[filter].v2);
260 break;
261 }
262 val += 0x4000;
263 } else if (chan == 56) {
264 val = get_u16(&spriv->channel->model_no);
265 } else if (chan == 57) {
266 val = get_u16(&spriv->channel->serial_no);
267 }
268
269 return val;
270}
271
272static int jr3_pci_ai_insn_read(struct comedi_device *dev,
273 struct comedi_subdevice *s,
274 struct comedi_insn *insn,
275 unsigned int *data)
276{
277 struct jr3_pci_subdev_private *spriv = s->private;
278 unsigned int chan = CR_CHAN(insn->chanspec);
279 u16 errors;
280 int i;
281
282 if (!spriv)
283 return -EINVAL;
284
285 errors = get_u16(&spriv->channel->errors);
286 if (spriv->state != state_jr3_done ||
287 (errors & (watch_dog | watch_dog2 | sensor_change))) {
288
289 if (spriv->state == state_jr3_done) {
290
291 spriv->state = state_jr3_poll;
292 }
293 return -EAGAIN;
294 }
295
296 for (i = 0; i < insn->n; i++)
297 data[i] = jr3_pci_ai_read_chan(dev, s, chan);
298
299 return insn->n;
300}
301
302static int jr3_pci_open(struct comedi_device *dev)
303{
304 struct jr3_pci_subdev_private *spriv;
305 struct comedi_subdevice *s;
306 int i;
307
308 dev_dbg(dev->class_dev, "jr3_pci_open\n");
309 for (i = 0; i < dev->n_subdevices; i++) {
310 s = &dev->subdevices[i];
311 spriv = s->private;
312 if (spriv)
313 dev_dbg(dev->class_dev, "serial: %p %d (%d)\n",
314 spriv, spriv->serial_no, s->index);
315 }
316 return 0;
317}
318
319static int read_idm_word(const u8 *data, size_t size, int *pos,
320 unsigned int *val)
321{
322 int result = 0;
323 int value;
324
325 if (pos && val) {
326
327 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++)
328 ;
329
330 *val = 0;
331 for (; *pos < size; (*pos)++) {
332 value = hex_to_bin(data[*pos]);
333 if (value >= 0) {
334 result = 1;
335 *val = (*val << 4) + value;
336 } else {
337 break;
338 }
339 }
340 }
341 return result;
342}
343
344static int jr3_check_firmware(struct comedi_device *dev,
345 const u8 *data, size_t size)
346{
347 int more = 1;
348 int pos = 0;
349
350
351
352
353
354
355 while (more) {
356 unsigned int count = 0;
357 unsigned int addr = 0;
358
359 more = more && read_idm_word(data, size, &pos, &count);
360 if (more && count == 0xffff)
361 return 0;
362
363 more = more && read_idm_word(data, size, &pos, &addr);
364 while (more && count > 0) {
365 unsigned int dummy = 0;
366
367 more = more && read_idm_word(data, size, &pos, &dummy);
368 count--;
369 }
370 }
371
372 return -ENODATA;
373}
374
375static void jr3_write_firmware(struct comedi_device *dev,
376 int subdev, const u8 *data, size_t size)
377{
378 struct jr3_pci_dev_private *devpriv = dev->private;
379 struct jr3_t __iomem *iobase = devpriv->iobase;
380 u32 __iomem *lo;
381 u32 __iomem *hi;
382 int more = 1;
383 int pos = 0;
384
385 while (more) {
386 unsigned int count = 0;
387 unsigned int addr = 0;
388
389 more = more && read_idm_word(data, size, &pos, &count);
390 if (more && count == 0xffff)
391 return;
392
393 more = more && read_idm_word(data, size, &pos, &addr);
394
395 dev_dbg(dev->class_dev, "Loading#%d %4.4x bytes at %4.4x\n",
396 subdev, count, addr);
397
398 while (more && count > 0) {
399 if (addr & 0x4000) {
400
401 unsigned int data1 = 0;
402
403 more = more &&
404 read_idm_word(data, size, &pos, &data1);
405 count--;
406
407 } else {
408
409 unsigned int data1 = 0;
410 unsigned int data2 = 0;
411
412 lo = &iobase->channel[subdev].program_lo[addr];
413 hi = &iobase->channel[subdev].program_hi[addr];
414
415 more = more &&
416 read_idm_word(data, size, &pos, &data1);
417 more = more &&
418 read_idm_word(data, size, &pos, &data2);
419 count -= 2;
420 if (more) {
421 set_u16(lo, data1);
422 udelay(1);
423 set_u16(hi, data2);
424 udelay(1);
425 }
426 }
427 addr++;
428 }
429 }
430}
431
432static int jr3_download_firmware(struct comedi_device *dev,
433 const u8 *data, size_t size,
434 unsigned long context)
435{
436 int subdev;
437 int ret;
438
439
440 ret = jr3_check_firmware(dev, data, size);
441 if (ret)
442 return ret;
443
444
445 for (subdev = 0; subdev < dev->n_subdevices; subdev++)
446 jr3_write_firmware(dev, subdev, data, size);
447
448 return 0;
449}
450
451static struct jr3_pci_poll_delay
452jr3_pci_poll_subdevice(struct comedi_subdevice *s)
453{
454 struct jr3_pci_subdev_private *spriv = s->private;
455 struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);
456 struct jr3_channel __iomem *channel;
457 u16 model_no;
458 u16 serial_no;
459 int errors;
460 int i;
461
462 if (!spriv)
463 return result;
464
465 channel = spriv->channel;
466 errors = get_u16(&channel->errors);
467
468 if (errors != spriv->errors)
469 spriv->errors = errors;
470
471
472 if (errors & (watch_dog | watch_dog2 | sensor_change))
473 spriv->state = state_jr3_poll;
474
475 switch (spriv->state) {
476 case state_jr3_poll:
477 model_no = get_u16(&channel->model_no);
478 serial_no = get_u16(&channel->serial_no);
479
480 if ((errors & (watch_dog | watch_dog2)) ||
481 model_no == 0 || serial_no == 0) {
482
483
484
485
486
487 } else {
488 spriv->retries = 0;
489 spriv->state = state_jr3_init_wait_for_offset;
490 }
491 break;
492 case state_jr3_init_wait_for_offset:
493 spriv->retries++;
494 if (spriv->retries < 10) {
495
496
497
498
499 } else {
500 struct jr3_pci_transform transf;
501
502 spriv->model_no = get_u16(&channel->model_no);
503 spriv->serial_no = get_u16(&channel->serial_no);
504
505
506 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
507 transf.link[i].link_type = (enum link_types)0;
508 transf.link[i].link_amount = 0;
509 }
510
511 set_transforms(channel, transf, 0);
512 use_transform(channel, 0);
513 spriv->state = state_jr3_init_transform_complete;
514
515 result = poll_delay_min_max(20, 100);
516 }
517 break;
518 case state_jr3_init_transform_complete:
519 if (!is_complete(channel)) {
520 result = poll_delay_min_max(20, 100);
521 } else {
522
523 struct six_axis_t min_full_scale;
524 struct six_axis_t max_full_scale;
525
526 min_full_scale = get_min_full_scales(channel);
527 max_full_scale = get_max_full_scales(channel);
528 set_full_scales(channel, max_full_scale);
529
530 spriv->state = state_jr3_init_set_full_scale_complete;
531
532 result = poll_delay_min_max(20, 100);
533 }
534 break;
535 case state_jr3_init_set_full_scale_complete:
536 if (!is_complete(channel)) {
537 result = poll_delay_min_max(20, 100);
538 } else {
539 struct force_array __iomem *fs = &channel->full_scale;
540
541
542 spriv->range[0].range.min = -get_s16(&fs->fx) * 1000;
543 spriv->range[0].range.max = get_s16(&fs->fx) * 1000;
544 spriv->range[1].range.min = -get_s16(&fs->fy) * 1000;
545 spriv->range[1].range.max = get_s16(&fs->fy) * 1000;
546 spriv->range[2].range.min = -get_s16(&fs->fz) * 1000;
547 spriv->range[2].range.max = get_s16(&fs->fz) * 1000;
548 spriv->range[3].range.min = -get_s16(&fs->mx) * 100;
549 spriv->range[3].range.max = get_s16(&fs->mx) * 100;
550 spriv->range[4].range.min = -get_s16(&fs->my) * 100;
551 spriv->range[4].range.max = get_s16(&fs->my) * 100;
552 spriv->range[5].range.min = -get_s16(&fs->mz) * 100;
553
554 spriv->range[5].range.max = get_s16(&fs->mz) * 100;
555 spriv->range[6].range.min = -get_s16(&fs->v1) * 100;
556 spriv->range[6].range.max = get_s16(&fs->v1) * 100;
557 spriv->range[7].range.min = -get_s16(&fs->v2) * 100;
558 spriv->range[7].range.max = get_s16(&fs->v2) * 100;
559 spriv->range[8].range.min = 0;
560 spriv->range[8].range.max = 65535;
561
562 use_offset(channel, 0);
563 spriv->state = state_jr3_init_use_offset_complete;
564
565 result = poll_delay_min_max(40, 100);
566 }
567 break;
568 case state_jr3_init_use_offset_complete:
569 if (!is_complete(channel)) {
570 result = poll_delay_min_max(20, 100);
571 } else {
572 set_s16(&channel->offsets.fx, 0);
573 set_s16(&channel->offsets.fy, 0);
574 set_s16(&channel->offsets.fz, 0);
575 set_s16(&channel->offsets.mx, 0);
576 set_s16(&channel->offsets.my, 0);
577 set_s16(&channel->offsets.mz, 0);
578
579 set_offset(channel);
580
581 spriv->state = state_jr3_done;
582 }
583 break;
584 case state_jr3_done:
585 result = poll_delay_min_max(10000, 20000);
586 break;
587 default:
588 break;
589 }
590
591 return result;
592}
593
594static void jr3_pci_poll_dev(unsigned long data)
595{
596 struct comedi_device *dev = (struct comedi_device *)data;
597 struct jr3_pci_dev_private *devpriv = dev->private;
598 struct jr3_pci_subdev_private *spriv;
599 struct comedi_subdevice *s;
600 unsigned long flags;
601 unsigned long now;
602 int delay;
603 int i;
604
605 spin_lock_irqsave(&dev->spinlock, flags);
606 delay = 1000;
607 now = jiffies;
608
609
610 for (i = 0; i < dev->n_subdevices; i++) {
611 s = &dev->subdevices[i];
612 spriv = s->private;
613
614 if (now > spriv->next_time_min) {
615 struct jr3_pci_poll_delay sub_delay;
616
617 sub_delay = jr3_pci_poll_subdevice(s);
618
619 spriv->next_time_min = jiffies +
620 msecs_to_jiffies(sub_delay.min);
621 spriv->next_time_max = jiffies +
622 msecs_to_jiffies(sub_delay.max);
623
624 if (sub_delay.max && sub_delay.max < delay)
625
626
627
628
629 delay = sub_delay.max;
630 }
631 }
632 spin_unlock_irqrestore(&dev->spinlock, flags);
633
634 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
635 add_timer(&devpriv->timer);
636}
637
638static struct jr3_pci_subdev_private *
639jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s)
640{
641 struct jr3_pci_dev_private *devpriv = dev->private;
642 struct jr3_pci_subdev_private *spriv;
643 int j;
644 int k;
645
646 spriv = comedi_alloc_spriv(s, sizeof(*spriv));
647 if (!spriv)
648 return NULL;
649
650 spriv->channel = &devpriv->iobase->channel[s->index].data;
651
652 for (j = 0; j < 8; j++) {
653 spriv->range[j].length = 1;
654 spriv->range[j].range.min = -1000000;
655 spriv->range[j].range.max = 1000000;
656
657 for (k = 0; k < 7; k++) {
658 spriv->range_table_list[j + k * 8] =
659 (struct comedi_lrange *)&spriv->range[j];
660 spriv->maxdata_list[j + k * 8] = 0x7fff;
661 }
662 }
663 spriv->range[8].length = 1;
664 spriv->range[8].range.min = 0;
665 spriv->range[8].range.max = 65536;
666
667 spriv->range_table_list[56] = (struct comedi_lrange *)&spriv->range[8];
668 spriv->range_table_list[57] = (struct comedi_lrange *)&spriv->range[8];
669 spriv->maxdata_list[56] = 0xffff;
670 spriv->maxdata_list[57] = 0xffff;
671
672 dev_dbg(dev->class_dev, "p->channel %p %p (%tx)\n",
673 spriv->channel, devpriv->iobase,
674 ((char __iomem *)spriv->channel -
675 (char __iomem *)devpriv->iobase));
676
677 return spriv;
678}
679
680static int jr3_pci_auto_attach(struct comedi_device *dev,
681 unsigned long context)
682{
683 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
684 static const struct jr3_pci_board *board;
685 struct jr3_pci_dev_private *devpriv;
686 struct jr3_pci_subdev_private *spriv;
687 struct comedi_subdevice *s;
688 int ret;
689 int i;
690
691 if (sizeof(struct jr3_channel) != 0xc00) {
692 dev_err(dev->class_dev,
693 "sizeof(struct jr3_channel) = %x [expected %x]\n",
694 (unsigned int)sizeof(struct jr3_channel), 0xc00);
695 return -EINVAL;
696 }
697
698 if (context < ARRAY_SIZE(jr3_pci_boards))
699 board = &jr3_pci_boards[context];
700 if (!board)
701 return -ENODEV;
702 dev->board_ptr = board;
703 dev->board_name = board->name;
704
705 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
706 if (!devpriv)
707 return -ENOMEM;
708
709 ret = comedi_pci_enable(dev);
710 if (ret)
711 return ret;
712
713 devpriv->iobase = pci_ioremap_bar(pcidev, 0);
714 if (!devpriv->iobase)
715 return -ENOMEM;
716
717 ret = comedi_alloc_subdevices(dev, board->n_subdevs);
718 if (ret)
719 return ret;
720
721 dev->open = jr3_pci_open;
722 for (i = 0; i < dev->n_subdevices; i++) {
723 s = &dev->subdevices[i];
724 s->type = COMEDI_SUBD_AI;
725 s->subdev_flags = SDF_READABLE | SDF_GROUND;
726 s->n_chan = 8 * 7 + 2;
727 s->insn_read = jr3_pci_ai_insn_read;
728
729 spriv = jr3_pci_alloc_spriv(dev, s);
730 if (spriv) {
731
732 s->range_table_list = spriv->range_table_list;
733 s->maxdata_list = spriv->maxdata_list;
734 }
735 }
736
737
738 writel(0, &devpriv->iobase->channel[0].reset);
739
740 ret = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
741 "comedi/jr3pci.idm",
742 jr3_download_firmware, 0);
743 dev_dbg(dev->class_dev, "Firmware load %d\n", ret);
744 if (ret < 0)
745 return ret;
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760 msleep_interruptible(25);
761 for (i = 0; i < 0x18; i++) {
762 dev_dbg(dev->class_dev, "%c\n",
763 get_u16(&devpriv->iobase->channel[0].
764 data.copyright[i]) >> 8);
765 }
766
767
768 for (i = 0; i < dev->n_subdevices; i++) {
769 s = &dev->subdevices[i];
770 spriv = s->private;
771
772 spriv->next_time_min = jiffies + msecs_to_jiffies(500);
773 spriv->next_time_max = jiffies + msecs_to_jiffies(2000);
774 }
775
776 setup_timer(&devpriv->timer, jr3_pci_poll_dev, (unsigned long)dev);
777 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
778 add_timer(&devpriv->timer);
779
780 return 0;
781}
782
783static void jr3_pci_detach(struct comedi_device *dev)
784{
785 struct jr3_pci_dev_private *devpriv = dev->private;
786
787 if (devpriv) {
788 del_timer_sync(&devpriv->timer);
789
790 if (devpriv->iobase)
791 iounmap(devpriv->iobase);
792 }
793 comedi_pci_disable(dev);
794}
795
796static struct comedi_driver jr3_pci_driver = {
797 .driver_name = "jr3_pci",
798 .module = THIS_MODULE,
799 .auto_attach = jr3_pci_auto_attach,
800 .detach = jr3_pci_detach,
801};
802
803static int jr3_pci_pci_probe(struct pci_dev *dev,
804 const struct pci_device_id *id)
805{
806 return comedi_pci_auto_config(dev, &jr3_pci_driver, id->driver_data);
807}
808
809static const struct pci_device_id jr3_pci_pci_table[] = {
810 { PCI_VDEVICE(JR3, 0x1111), BOARD_JR3_1 },
811 { PCI_VDEVICE(JR3, 0x3111), BOARD_JR3_1 },
812 { PCI_VDEVICE(JR3, 0x3112), BOARD_JR3_2 },
813 { PCI_VDEVICE(JR3, 0x3113), BOARD_JR3_3 },
814 { PCI_VDEVICE(JR3, 0x3114), BOARD_JR3_4 },
815 { 0 }
816};
817MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
818
819static struct pci_driver jr3_pci_pci_driver = {
820 .name = "jr3_pci",
821 .id_table = jr3_pci_pci_table,
822 .probe = jr3_pci_pci_probe,
823 .remove = comedi_pci_auto_unconfig,
824};
825module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
826
827MODULE_AUTHOR("Comedi http://www.comedi.org");
828MODULE_DESCRIPTION("Comedi low-level driver");
829MODULE_LICENSE("GPL");
830MODULE_FIRMWARE("comedi/jr3pci.idm");
831