2 comedi/drivers/jr3_pci.c
3 hardware driver for JR3/PCI force sensor board
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 Description: JR3/PCI force sensor board
26 Author: Anders Blomdell <anders.blomdell@control.lth.se>
28 Devices: [JR3] PCI force sensor board (jr3_pci)
30 The DSP on the board requires initialization code, which can
31 be loaded by placing it in /lib/firmware/comedi.
32 The initialization code should be somewhere on the media you got
33 with your card. One version is available from http://www.comedi.org
34 in the comedi_nonfree_firmware tarball.
36 Configuration options:
37 [0] - PCI bus number - if bus number and slot number are 0,
38 then driver search for first unused card
43 #include "../comedidev.h"
45 #include <linux/delay.h>
46 #include <linux/ctype.h>
47 #include <linux/firmware.h>
48 #include <linux/jiffies.h>
49 #include <linux/slab.h>
50 #include <linux/timer.h>
51 #include <linux/kernel.h>
52 #include "comedi_pci.h"
55 #define PCI_VENDOR_ID_JR3 0x1762
56 #define PCI_DEVICE_ID_JR3_1_CHANNEL 0x3111
57 #define PCI_DEVICE_ID_JR3_2_CHANNEL 0x3112
58 #define PCI_DEVICE_ID_JR3_3_CHANNEL 0x3113
59 #define PCI_DEVICE_ID_JR3_4_CHANNEL 0x3114
61 static int jr3_pci_attach(struct comedi_device *dev,
62 struct comedi_devconfig *it);
63 static int jr3_pci_detach(struct comedi_device *dev);
65 static struct comedi_driver driver_jr3_pci = {
66 .driver_name = "jr3_pci",
67 .module = THIS_MODULE,
68 .attach = jr3_pci_attach,
69 .detach = jr3_pci_detach,
72 static DEFINE_PCI_DEVICE_TABLE(jr3_pci_pci_table) = {
74 PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_1_CHANNEL,
75 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
76 PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_2_CHANNEL,
77 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
78 PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_3_CHANNEL,
79 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
80 PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_4_CHANNEL,
81 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
85 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
87 struct jr3_pci_dev_private {
89 struct pci_dev *pci_dev;
91 volatile struct jr3_t *iobase;
93 struct timer_list timer;
102 struct jr3_pci_subdev_private {
103 volatile struct jr3_channel *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,
118 struct comedi_krange range;
120 const struct comedi_lrange *range_table_list[8 * 7 + 2];
121 unsigned int maxdata_list[8 * 7 + 2];
126 /* Hotplug firmware loading stuff */
127 static int comedi_load_firmware(struct comedi_device *dev, char *name,
128 int (*cb)(struct comedi_device *dev,
129 const u8 *data, size_t size))
132 const struct firmware *fw;
134 static const char *prefix = "comedi/";
135 struct jr3_pci_dev_private *devpriv = dev->private;
137 firmware_path = kmalloc(strlen(prefix) + strlen(name) + 1, GFP_KERNEL);
138 if (!firmware_path) {
141 firmware_path[0] = '\0';
142 strcat(firmware_path, prefix);
143 strcat(firmware_path, name);
144 result = request_firmware(&fw, firmware_path,
145 &devpriv->pci_dev->dev);
150 result = cb(dev, fw->data, fw->size);
151 release_firmware(fw);
153 kfree(firmware_path);
158 static struct poll_delay_t poll_delay_min_max(int min, int max)
160 struct poll_delay_t result;
167 static int is_complete(volatile struct jr3_channel *channel)
169 return get_s16(&channel->command_word0) == 0;
179 static void set_transforms(volatile struct jr3_channel *channel,
180 struct transform_t transf, short num)
184 num &= 0x000f; /* Make sure that 0 <= num <= 15 */
185 for (i = 0; i < 8; i++) {
187 set_u16(&channel->transforms[num].link[i].link_type,
188 transf.link[i].link_type);
190 set_s16(&channel->transforms[num].link[i].link_amount,
191 transf.link[i].link_amount);
193 if (transf.link[i].link_type == end_x_form) {
199 static void use_transform(volatile struct jr3_channel *channel,
202 set_s16(&channel->command_word0, 0x0500 + (transf_num & 0x000f));
205 static void use_offset(volatile struct jr3_channel *channel, short offset_num)
207 set_s16(&channel->command_word0, 0x0600 + (offset_num & 0x000f));
210 static void set_offset(volatile struct jr3_channel *channel)
212 set_s16(&channel->command_word0, 0x0700);
224 static void set_full_scales(volatile struct jr3_channel *channel,
225 struct six_axis_t full_scale)
227 printk("%d %d %d %d %d %d\n",
230 full_scale.fz, full_scale.mx, full_scale.my, full_scale.mz);
231 set_s16(&channel->full_scale.fx, full_scale.fx);
232 set_s16(&channel->full_scale.fy, full_scale.fy);
233 set_s16(&channel->full_scale.fz, full_scale.fz);
234 set_s16(&channel->full_scale.mx, full_scale.mx);
235 set_s16(&channel->full_scale.my, full_scale.my);
236 set_s16(&channel->full_scale.mz, full_scale.mz);
237 set_s16(&channel->command_word0, 0x0a00);
240 static struct six_axis_t get_min_full_scales(volatile struct jr3_channel
243 struct six_axis_t result;
244 result.fx = get_s16(&channel->min_full_scale.fx);
245 result.fy = get_s16(&channel->min_full_scale.fy);
246 result.fz = get_s16(&channel->min_full_scale.fz);
247 result.mx = get_s16(&channel->min_full_scale.mx);
248 result.my = get_s16(&channel->min_full_scale.my);
249 result.mz = get_s16(&channel->min_full_scale.mz);
253 static struct six_axis_t get_max_full_scales(volatile struct jr3_channel
256 struct six_axis_t result;
257 result.fx = get_s16(&channel->max_full_scale.fx);
258 result.fy = get_s16(&channel->max_full_scale.fy);
259 result.fz = get_s16(&channel->max_full_scale.fz);
260 result.mx = get_s16(&channel->max_full_scale.mx);
261 result.my = get_s16(&channel->max_full_scale.my);
262 result.mz = get_s16(&channel->max_full_scale.mz);
266 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
267 struct comedi_subdevice *s,
268 struct comedi_insn *insn, unsigned int *data)
271 struct jr3_pci_subdev_private *p;
275 channel = CR_CHAN(insn->chanspec);
276 if (p == NULL || channel > 57) {
282 if (p->state != state_jr3_done ||
283 (get_u16(&p->channel->errors) & (watch_dog | watch_dog2 |
285 /* No sensor or sensor changed */
286 if (p->state == state_jr3_done) {
287 /* Restart polling */
288 p->state = state_jr3_poll;
292 for (i = 0; i < insn->n; i++) {
297 filter = channel / 8;
298 if (p->state != state_jr3_done) {
352 data[i] = F + 0x4000;
354 } else if (channel == 56) {
355 if (p->state != state_jr3_done) {
359 get_u16(&p->channel->model_no);
361 } else if (channel == 57) {
362 if (p->state != state_jr3_done) {
366 get_u16(&p->channel->serial_no);
374 static int jr3_pci_open(struct comedi_device *dev)
377 struct jr3_pci_dev_private *devpriv = dev->private;
379 printk("jr3_pci_open\n");
380 for (i = 0; i < devpriv->n_channels; i++) {
381 struct jr3_pci_subdev_private *p;
383 p = dev->subdevices[i].private;
385 printk("serial: %p %d (%d)\n", p, p->serial_no,
392 int read_idm_word(const u8 * data, size_t size, int *pos, unsigned int *val)
395 if (pos != 0 && val != 0) {
396 /* Skip over non hex */
397 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++) {
401 for (; *pos < size; (*pos)++) {
403 value = hex_to_bin(data[*pos]);
406 *val = (*val << 4) + value;
414 static int jr3_download_firmware(struct comedi_device *dev, const u8 * data,
418 * IDM file format is:
419 * { count, address, data <count> } *
422 int result, more, pos, OK;
429 unsigned int count, addr;
431 more = more && read_idm_word(data, size, &pos, &count);
432 if (more && count == 0xffff) {
436 more = more && read_idm_word(data, size, &pos, &addr);
437 while (more && count > 0) {
439 more = more && read_idm_word(data, size, &pos, &dummy);
448 struct jr3_pci_dev_private *p = dev->private;
450 for (i = 0; i < p->n_channels; i++) {
451 struct jr3_pci_subdev_private *sp;
453 sp = dev->subdevices[i].private;
457 unsigned int count, addr;
459 && read_idm_word(data, size, &pos, &count);
460 if (more && count == 0xffff) {
464 && read_idm_word(data, size, &pos, &addr);
465 printk("Loading#%d %4.4x bytes at %4.4x\n", i,
467 while (more && count > 0) {
469 /* 16 bit data, never seen in real life!! */
473 && read_idm_word(data,
477 /* printk("jr3_data, not tested\n"); */
478 /* jr3[addr + 0x20000 * pnum] = data1; */
480 /* Download 24 bit program */
481 unsigned int data1, data2;
484 && read_idm_word(data,
488 && read_idm_word(data, size,
514 static struct poll_delay_t jr3_pci_poll_subdevice(struct comedi_subdevice *s)
516 struct poll_delay_t result = poll_delay_min_max(1000, 2000);
517 struct jr3_pci_subdev_private *p = s->private;
521 volatile struct jr3_channel *channel = p->channel;
522 int errors = get_u16(&channel->errors);
524 if (errors != p->errors) {
525 printk("Errors: %x -> %x\n", p->errors, errors);
528 if (errors & (watch_dog | watch_dog2 | sensor_change)) {
529 /* Sensor communication lost, force poll mode */
530 p->state = state_jr3_poll;
534 case state_jr3_poll:{
535 u16 model_no = get_u16(&channel->model_no);
536 u16 serial_no = get_u16(&channel->serial_no);
537 if ((errors & (watch_dog | watch_dog2)) ||
538 model_no == 0 || serial_no == 0) {
540 * Still no sensor, keep on polling. Since it takes up to 10 seconds
541 * for offsets to stabilize, polling each second should suffice.
543 result = poll_delay_min_max(1000, 2000);
547 state_jr3_init_wait_for_offset;
548 result = poll_delay_min_max(1000, 2000);
552 case state_jr3_init_wait_for_offset:{
554 if (p->retries < 10) {
555 /* Wait for offeset to stabilize (< 10 s according to manual) */
556 result = poll_delay_min_max(1000, 2000);
558 struct transform_t transf;
561 get_u16(&channel->model_no);
563 get_u16(&channel->serial_no);
566 ("Setting transform for channel %d\n",
568 printk("Sensor Model = %i\n",
570 printk("Sensor Serial = %i\n",
573 /* Transformation all zeros */
574 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
575 transf.link[i].link_type =
577 transf.link[i].link_amount = 0;
580 set_transforms(channel, transf, 0);
581 use_transform(channel, 0);
583 state_jr3_init_transform_complete;
584 result = poll_delay_min_max(20, 100); /* Allow 20 ms for completion */
587 case state_jr3_init_transform_complete:{
588 if (!is_complete(channel)) {
590 ("state_jr3_init_transform_complete complete = %d\n",
591 is_complete(channel));
592 result = poll_delay_min_max(20, 100);
595 struct six_axis_t min_full_scale;
596 struct six_axis_t max_full_scale;
599 get_min_full_scales(channel);
600 printk("Obtained Min. Full Scales:\n");
601 printk("%i ", (min_full_scale).fx);
602 printk("%i ", (min_full_scale).fy);
603 printk("%i ", (min_full_scale).fz);
604 printk("%i ", (min_full_scale).mx);
605 printk("%i ", (min_full_scale).my);
606 printk("%i ", (min_full_scale).mz);
610 get_max_full_scales(channel);
611 printk("Obtained Max. Full Scales:\n");
612 printk("%i ", (max_full_scale).fx);
613 printk("%i ", (max_full_scale).fy);
614 printk("%i ", (max_full_scale).fz);
615 printk("%i ", (max_full_scale).mx);
616 printk("%i ", (max_full_scale).my);
617 printk("%i ", (max_full_scale).mz);
620 set_full_scales(channel,
624 state_jr3_init_set_full_scale_complete;
625 result = poll_delay_min_max(20, 100); /* Allow 20 ms for completion */
629 case state_jr3_init_set_full_scale_complete:{
630 if (!is_complete(channel)) {
632 ("state_jr3_init_set_full_scale_complete complete = %d\n",
633 is_complete(channel));
634 result = poll_delay_min_max(20, 100);
636 volatile struct force_array *full_scale;
638 /* Use ranges in kN or we will overflow arount 2000N! */
639 full_scale = &channel->full_scale;
640 p->range[0].range.min =
641 -get_s16(&full_scale->fx) * 1000;
642 p->range[0].range.max =
643 get_s16(&full_scale->fx) * 1000;
644 p->range[1].range.min =
645 -get_s16(&full_scale->fy) * 1000;
646 p->range[1].range.max =
647 get_s16(&full_scale->fy) * 1000;
648 p->range[2].range.min =
649 -get_s16(&full_scale->fz) * 1000;
650 p->range[2].range.max =
651 get_s16(&full_scale->fz) * 1000;
652 p->range[3].range.min =
653 -get_s16(&full_scale->mx) * 100;
654 p->range[3].range.max =
655 get_s16(&full_scale->mx) * 100;
656 p->range[4].range.min =
657 -get_s16(&full_scale->my) * 100;
658 p->range[4].range.max =
659 get_s16(&full_scale->my) * 100;
660 p->range[5].range.min =
661 -get_s16(&full_scale->mz) * 100;
662 p->range[5].range.max =
663 get_s16(&full_scale->mz) * 100;
664 p->range[6].range.min = -get_s16(&full_scale->v1) * 100; /* ?? */
665 p->range[6].range.max = get_s16(&full_scale->v1) * 100; /* ?? */
666 p->range[7].range.min = -get_s16(&full_scale->v2) * 100; /* ?? */
667 p->range[7].range.max = get_s16(&full_scale->v2) * 100; /* ?? */
668 p->range[8].range.min = 0;
669 p->range[8].range.max = 65535;
673 for (i = 0; i < 9; i++) {
674 printk("%d %d - %d\n",
685 use_offset(channel, 0);
687 state_jr3_init_use_offset_complete;
688 result = poll_delay_min_max(40, 100); /* Allow 40 ms for completion */
692 case state_jr3_init_use_offset_complete:{
693 if (!is_complete(channel)) {
695 ("state_jr3_init_use_offset_complete complete = %d\n",
696 is_complete(channel));
697 result = poll_delay_min_max(20, 100);
700 ("Default offsets %d %d %d %d %d %d\n",
701 get_s16(&channel->offsets.fx),
702 get_s16(&channel->offsets.fy),
703 get_s16(&channel->offsets.fz),
704 get_s16(&channel->offsets.mx),
705 get_s16(&channel->offsets.my),
706 get_s16(&channel->offsets.mz));
708 set_s16(&channel->offsets.fx, 0);
709 set_s16(&channel->offsets.fy, 0);
710 set_s16(&channel->offsets.fz, 0);
711 set_s16(&channel->offsets.mx, 0);
712 set_s16(&channel->offsets.my, 0);
713 set_s16(&channel->offsets.mz, 0);
717 p->state = state_jr3_done;
721 case state_jr3_done:{
722 poll_delay_min_max(10000, 20000);
726 poll_delay_min_max(1000, 2000);
734 static void jr3_pci_poll_dev(unsigned long data)
737 struct comedi_device *dev = (struct comedi_device *)data;
738 struct jr3_pci_dev_private *devpriv = dev->private;
743 spin_lock_irqsave(&dev->spinlock, flags);
746 /* Poll all channels that are ready to be polled */
747 for (i = 0; i < devpriv->n_channels; i++) {
748 struct jr3_pci_subdev_private *subdevpriv =
749 dev->subdevices[i].private;
750 if (now > subdevpriv->next_time_min) {
751 struct poll_delay_t sub_delay;
753 sub_delay = jr3_pci_poll_subdevice(&dev->subdevices[i]);
754 subdevpriv->next_time_min =
755 jiffies + msecs_to_jiffies(sub_delay.min);
756 subdevpriv->next_time_max =
757 jiffies + msecs_to_jiffies(sub_delay.max);
758 if (sub_delay.max && sub_delay.max < delay) {
760 * Wake up as late as possible -> poll as many channels as possible
763 delay = sub_delay.max;
767 spin_unlock_irqrestore(&dev->spinlock, flags);
769 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
770 add_timer(&devpriv->timer);
773 static int jr3_pci_attach(struct comedi_device *dev,
774 struct comedi_devconfig *it)
777 struct pci_dev *card = NULL;
778 int opt_bus, opt_slot, i;
779 struct jr3_pci_dev_private *devpriv;
781 printk("comedi%d: jr3_pci\n", dev->minor);
783 opt_bus = it->options[0];
784 opt_slot = it->options[1];
786 if (sizeof(struct jr3_channel) != 0xc00) {
787 printk("sizeof(struct jr3_channel) = %x [expected %x]\n",
788 (unsigned)sizeof(struct jr3_channel), 0xc00);
792 result = alloc_private(dev, sizeof(struct jr3_pci_dev_private));
797 devpriv = dev->private;
798 init_timer(&devpriv->timer);
800 card = pci_get_device(PCI_VENDOR_ID_JR3, PCI_ANY_ID, card);
805 switch (card->device) {
806 case PCI_DEVICE_ID_JR3_1_CHANNEL:{
807 devpriv->n_channels = 1;
810 case PCI_DEVICE_ID_JR3_2_CHANNEL:{
811 devpriv->n_channels = 2;
814 case PCI_DEVICE_ID_JR3_3_CHANNEL:{
815 devpriv->n_channels = 3;
818 case PCI_DEVICE_ID_JR3_4_CHANNEL:{
819 devpriv->n_channels = 4;
823 devpriv->n_channels = 0;
826 if (devpriv->n_channels >= 1) {
827 if (opt_bus == 0 && opt_slot == 0) {
828 /* Take first available card */
830 } else if (opt_bus == card->bus->number &&
831 opt_slot == PCI_SLOT(card->devfn)) {
832 /* Take requested card */
839 printk(" no jr3_pci found\n");
842 devpriv->pci_dev = card;
843 dev->board_name = "jr3_pci";
846 result = comedi_pci_enable(card, "jr3_pci");
851 devpriv->pci_enabled = 1;
852 devpriv->iobase = ioremap(pci_resource_start(card, 0),
853 offsetof(struct jr3_t, channel[devpriv->n_channels]));
854 if (!devpriv->iobase)
857 result = alloc_subdevices(dev, devpriv->n_channels);
861 dev->open = jr3_pci_open;
862 for (i = 0; i < devpriv->n_channels; i++) {
863 dev->subdevices[i].type = COMEDI_SUBD_AI;
864 dev->subdevices[i].subdev_flags = SDF_READABLE | SDF_GROUND;
865 dev->subdevices[i].n_chan = 8 * 7 + 2;
866 dev->subdevices[i].insn_read = jr3_pci_ai_insn_read;
867 dev->subdevices[i].private =
868 kzalloc(sizeof(struct jr3_pci_subdev_private), GFP_KERNEL);
869 if (dev->subdevices[i].private) {
870 struct jr3_pci_subdev_private *p;
873 p = dev->subdevices[i].private;
874 p->channel = &devpriv->iobase->channel[i].data;
875 printk("p->channel %p %p (%tx)\n",
876 p->channel, devpriv->iobase,
877 ((char *)(p->channel) -
878 (char *)(devpriv->iobase)));
880 for (j = 0; j < 8; j++) {
883 p->range[j].length = 1;
884 p->range[j].range.min = -1000000;
885 p->range[j].range.max = 1000000;
886 for (k = 0; k < 7; k++) {
887 p->range_table_list[j + k * 8] =
888 (struct comedi_lrange *)&p->
890 p->maxdata_list[j + k * 8] = 0x7fff;
893 p->range[8].length = 1;
894 p->range[8].range.min = 0;
895 p->range[8].range.max = 65536;
897 p->range_table_list[56] =
898 (struct comedi_lrange *)&p->range[8];
899 p->range_table_list[57] =
900 (struct comedi_lrange *)&p->range[8];
901 p->maxdata_list[56] = 0xffff;
902 p->maxdata_list[57] = 0xffff;
903 /* Channel specific range and maxdata */
904 dev->subdevices[i].range_table = 0;
905 dev->subdevices[i].range_table_list =
907 dev->subdevices[i].maxdata = 0;
908 dev->subdevices[i].maxdata_list = p->maxdata_list;
913 devpriv->iobase->channel[0].reset = 0;
915 result = comedi_load_firmware(dev, "jr3pci.idm", jr3_download_firmware);
916 printk("Firmare load %d\n", result);
922 * TODO: use firmware to load preferred offset tables. Suggested
924 * model serial Fx Fy Fz Mx My Mz\n
926 * comedi_load_firmware(dev, "jr3_offsets_table", jr3_download_firmware);
930 * It takes a few milliseconds for software to settle as much as we
931 * can read firmware version
933 msleep_interruptible(25);
934 for (i = 0; i < 0x18; i++) {
936 get_u16(&devpriv->iobase->channel[0].
937 data.copyright[i]) >> 8);
940 /* Start card timer */
941 for (i = 0; i < devpriv->n_channels; i++) {
942 struct jr3_pci_subdev_private *p = dev->subdevices[i].private;
944 p->next_time_min = jiffies + msecs_to_jiffies(500);
945 p->next_time_max = jiffies + msecs_to_jiffies(2000);
948 devpriv->timer.data = (unsigned long)dev;
949 devpriv->timer.function = jr3_pci_poll_dev;
950 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
951 add_timer(&devpriv->timer);
957 MODULE_FIRMWARE("comedi/jr3pci.idm");
959 static int jr3_pci_detach(struct comedi_device *dev)
962 struct jr3_pci_dev_private *devpriv = dev->private;
964 printk("comedi%d: jr3_pci: remove\n", dev->minor);
966 del_timer_sync(&devpriv->timer);
968 if (dev->subdevices) {
969 for (i = 0; i < devpriv->n_channels; i++) {
970 kfree(dev->subdevices[i].private);
974 if (devpriv->iobase) {
975 iounmap((void *)devpriv->iobase);
977 if (devpriv->pci_enabled) {
978 comedi_pci_disable(devpriv->pci_dev);
981 if (devpriv->pci_dev) {
982 pci_dev_put(devpriv->pci_dev);
988 static int __devinit driver_jr3_pci_pci_probe(struct pci_dev *dev,
989 const struct pci_device_id *ent)
991 return comedi_pci_auto_config(dev, driver_jr3_pci.driver_name);
994 static void __devexit driver_jr3_pci_pci_remove(struct pci_dev *dev)
996 comedi_pci_auto_unconfig(dev);
999 static struct pci_driver driver_jr3_pci_pci_driver = {
1000 .id_table = jr3_pci_pci_table,
1001 .probe = &driver_jr3_pci_pci_probe,
1002 .remove = __devexit_p(&driver_jr3_pci_pci_remove)
1005 static int __init driver_jr3_pci_init_module(void)
1009 retval = comedi_driver_register(&driver_jr3_pci);
1013 driver_jr3_pci_pci_driver.name = (char *)driver_jr3_pci.driver_name;
1014 return pci_register_driver(&driver_jr3_pci_pci_driver);
1017 static void __exit driver_jr3_pci_cleanup_module(void)
1019 pci_unregister_driver(&driver_jr3_pci_pci_driver);
1020 comedi_driver_unregister(&driver_jr3_pci);
1023 module_init(driver_jr3_pci_init_module);
1024 module_exit(driver_jr3_pci_cleanup_module);
1026 MODULE_AUTHOR("Comedi http://www.comedi.org");
1027 MODULE_DESCRIPTION("Comedi low-level driver");
1028 MODULE_LICENSE("GPL");