1 /*
2 comedi/drivers/jr3_pci.c
3 hardware driver for JR3/PCI force sensor board
4
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
7
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.
12
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.
17
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.
21
22 */
23 /*
24 Driver: jr3_pci
25 Description: JR3/PCI force sensor board
26 Author: Anders Blomdell <anders.blomdell@control.lth.se>
27 Status: works
28 Devices: [JR3] PCI force sensor board (jr3_pci)
29
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.
35
36 Configuration options:
37 [0] - PCI bus number - if bus number and slot number are 0,
38 then driver search for first unused card
39 [1] - PCI slot number
40
41 */
42
43 #include "../comedidev.h"
44
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"
53 #include "jr3_pci.h"
54
55 #define PCI_VENDOR_ID_JR3 0x1762
56 #define PCI_DEVICE_ID_JR3_1_CHANNEL 0x3111
57 #define PCI_DEVICE_ID_JR3_1_CHANNEL_NEW 0x1111
58 #define PCI_DEVICE_ID_JR3_2_CHANNEL 0x3112
59 #define PCI_DEVICE_ID_JR3_3_CHANNEL 0x3113
60 #define PCI_DEVICE_ID_JR3_4_CHANNEL 0x3114
61
62 static int jr3_pci_attach(struct comedi_device *dev,
63 struct comedi_devconfig *it);
64 static int jr3_pci_detach(struct comedi_device *dev);
65
66 static struct comedi_driver driver_jr3_pci = {
67 .driver_name = "jr3_pci",
68 .module = THIS_MODULE,
69 .attach = jr3_pci_attach,
70 .detach = jr3_pci_detach,
71 };
72
73 static DEFINE_PCI_DEVICE_TABLE(jr3_pci_pci_table) = {
74 { PCI_DEVICE(PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_1_CHANNEL) },
75 { PCI_DEVICE(PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_1_CHANNEL_NEW) },
76 { PCI_DEVICE(PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_2_CHANNEL) },
77 { PCI_DEVICE(PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_3_CHANNEL) },
78 { PCI_DEVICE(PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_4_CHANNEL) },
79 {0}
80 };
81
82 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
83
84 struct jr3_pci_dev_private {
85
86 struct pci_dev *pci_dev;
87 int pci_enabled;
88 volatile struct jr3_t *iobase;
89 int n_channels;
90 struct timer_list timer;
91 };
92
93 struct poll_delay_t {
94
95 int min;
96 int max;
97 };
98
99 struct jr3_pci_subdev_private {
100 volatile struct jr3_channel *channel;
101 unsigned long next_time_min;
102 unsigned long next_time_max;
103 enum { state_jr3_poll,
104 state_jr3_init_wait_for_offset,
105 state_jr3_init_transform_complete,
106 state_jr3_init_set_full_scale_complete,
107 state_jr3_init_use_offset_complete,
108 state_jr3_done
109 } state;
110 int channel_no;
111 int serial_no;
112 int model_no;
113 struct {
114 int length;
115 struct comedi_krange range;
116 } range[9];
117 const struct comedi_lrange *range_table_list[8 * 7 + 2];
118 unsigned int maxdata_list[8 * 7 + 2];
119 u16 errors;
120 int retries;
121 };
122
123 /* Hotplug firmware loading stuff */
comedi_load_firmware(struct comedi_device * dev,char * name,int (* cb)(struct comedi_device * dev,const u8 * data,size_t size))124 static int comedi_load_firmware(struct comedi_device *dev, char *name,
125 int (*cb)(struct comedi_device *dev,
126 const u8 *data, size_t size))
127 {
128 int result = 0;
129 const struct firmware *fw;
130 char *firmware_path;
131 static const char *prefix = "comedi/";
132 struct jr3_pci_dev_private *devpriv = dev->private;
133
134 firmware_path = kmalloc(strlen(prefix) + strlen(name) + 1, GFP_KERNEL);
135 if (!firmware_path) {
136 result = -ENOMEM;
137 } else {
138 firmware_path[0] = '\0';
139 strcat(firmware_path, prefix);
140 strcat(firmware_path, name);
141 result = request_firmware(&fw, firmware_path,
142 &devpriv->pci_dev->dev);
143 if (result == 0) {
144 if (!cb)
145 result = -EINVAL;
146 else
147 result = cb(dev, fw->data, fw->size);
148 release_firmware(fw);
149 }
150 kfree(firmware_path);
151 }
152 return result;
153 }
154
poll_delay_min_max(int min,int max)155 static struct poll_delay_t poll_delay_min_max(int min, int max)
156 {
157 struct poll_delay_t result;
158
159 result.min = min;
160 result.max = max;
161 return result;
162 }
163
is_complete(volatile struct jr3_channel * channel)164 static int is_complete(volatile struct jr3_channel *channel)
165 {
166 return get_s16(&channel->command_word0) == 0;
167 }
168
169 struct transform_t {
170 struct {
171 u16 link_type;
172 s16 link_amount;
173 } link[8];
174 };
175
set_transforms(volatile struct jr3_channel * channel,struct transform_t transf,short num)176 static void set_transforms(volatile struct jr3_channel *channel,
177 struct transform_t transf, short num)
178 {
179 int i;
180
181 num &= 0x000f; /* Make sure that 0 <= num <= 15 */
182 for (i = 0; i < 8; i++) {
183
184 set_u16(&channel->transforms[num].link[i].link_type,
185 transf.link[i].link_type);
186 udelay(1);
187 set_s16(&channel->transforms[num].link[i].link_amount,
188 transf.link[i].link_amount);
189 udelay(1);
190 if (transf.link[i].link_type == end_x_form)
191 break;
192 }
193 }
194
use_transform(volatile struct jr3_channel * channel,short transf_num)195 static void use_transform(volatile struct jr3_channel *channel,
196 short transf_num)
197 {
198 set_s16(&channel->command_word0, 0x0500 + (transf_num & 0x000f));
199 }
200
use_offset(volatile struct jr3_channel * channel,short offset_num)201 static void use_offset(volatile struct jr3_channel *channel, short offset_num)
202 {
203 set_s16(&channel->command_word0, 0x0600 + (offset_num & 0x000f));
204 }
205
set_offset(volatile struct jr3_channel * channel)206 static void set_offset(volatile struct jr3_channel *channel)
207 {
208 set_s16(&channel->command_word0, 0x0700);
209 }
210
211 struct six_axis_t {
212 s16 fx;
213 s16 fy;
214 s16 fz;
215 s16 mx;
216 s16 my;
217 s16 mz;
218 };
219
set_full_scales(volatile struct jr3_channel * channel,struct six_axis_t full_scale)220 static void set_full_scales(volatile struct jr3_channel *channel,
221 struct six_axis_t full_scale)
222 {
223 printk("%d %d %d %d %d %d\n",
224 full_scale.fx,
225 full_scale.fy,
226 full_scale.fz, full_scale.mx, full_scale.my, full_scale.mz);
227 set_s16(&channel->full_scale.fx, full_scale.fx);
228 set_s16(&channel->full_scale.fy, full_scale.fy);
229 set_s16(&channel->full_scale.fz, full_scale.fz);
230 set_s16(&channel->full_scale.mx, full_scale.mx);
231 set_s16(&channel->full_scale.my, full_scale.my);
232 set_s16(&channel->full_scale.mz, full_scale.mz);
233 set_s16(&channel->command_word0, 0x0a00);
234 }
235
get_min_full_scales(volatile struct jr3_channel * channel)236 static struct six_axis_t get_min_full_scales(volatile struct jr3_channel
237 *channel)
238 {
239 struct six_axis_t result;
240 result.fx = get_s16(&channel->min_full_scale.fx);
241 result.fy = get_s16(&channel->min_full_scale.fy);
242 result.fz = get_s16(&channel->min_full_scale.fz);
243 result.mx = get_s16(&channel->min_full_scale.mx);
244 result.my = get_s16(&channel->min_full_scale.my);
245 result.mz = get_s16(&channel->min_full_scale.mz);
246 return result;
247 }
248
get_max_full_scales(volatile struct jr3_channel * channel)249 static struct six_axis_t get_max_full_scales(volatile struct jr3_channel
250 *channel)
251 {
252 struct six_axis_t result;
253 result.fx = get_s16(&channel->max_full_scale.fx);
254 result.fy = get_s16(&channel->max_full_scale.fy);
255 result.fz = get_s16(&channel->max_full_scale.fz);
256 result.mx = get_s16(&channel->max_full_scale.mx);
257 result.my = get_s16(&channel->max_full_scale.my);
258 result.mz = get_s16(&channel->max_full_scale.mz);
259 return result;
260 }
261
jr3_pci_ai_insn_read(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_insn * insn,unsigned int * data)262 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
263 struct comedi_subdevice *s,
264 struct comedi_insn *insn, unsigned int *data)
265 {
266 int result;
267 struct jr3_pci_subdev_private *p;
268 int channel;
269
270 p = s->private;
271 channel = CR_CHAN(insn->chanspec);
272 if (p == NULL || channel > 57) {
273 result = -EINVAL;
274 } else {
275 int i;
276
277 result = insn->n;
278 if (p->state != state_jr3_done ||
279 (get_u16(&p->channel->errors) & (watch_dog | watch_dog2 |
280 sensor_change))) {
281 /* No sensor or sensor changed */
282 if (p->state == state_jr3_done) {
283 /* Restart polling */
284 p->state = state_jr3_poll;
285 }
286 result = -EAGAIN;
287 }
288 for (i = 0; i < insn->n; i++) {
289 if (channel < 56) {
290 int axis, filter;
291
292 axis = channel % 8;
293 filter = channel / 8;
294 if (p->state != state_jr3_done) {
295 data[i] = 0;
296 } else {
297 int F = 0;
298 switch (axis) {
299 case 0:{
300 F = get_s16
301 (&p->channel->filter
302 [filter].fx);
303 }
304 break;
305 case 1:{
306 F = get_s16
307 (&p->channel->filter
308 [filter].fy);
309 }
310 break;
311 case 2:{
312 F = get_s16
313 (&p->channel->filter
314 [filter].fz);
315 }
316 break;
317 case 3:{
318 F = get_s16
319 (&p->channel->filter
320 [filter].mx);
321 }
322 break;
323 case 4:{
324 F = get_s16
325 (&p->channel->filter
326 [filter].my);
327 }
328 break;
329 case 5:{
330 F = get_s16
331 (&p->channel->filter
332 [filter].mz);
333 }
334 break;
335 case 6:{
336 F = get_s16
337 (&p->channel->filter
338 [filter].v1);
339 }
340 break;
341 case 7:{
342 F = get_s16
343 (&p->channel->filter
344 [filter].v2);
345 }
346 break;
347 }
348 data[i] = F + 0x4000;
349 }
350 } else if (channel == 56) {
351 if (p->state != state_jr3_done) {
352 data[i] = 0;
353 } else {
354 data[i] =
355 get_u16(&p->channel->model_no);
356 }
357 } else if (channel == 57) {
358 if (p->state != state_jr3_done) {
359 data[i] = 0;
360 } else {
361 data[i] =
362 get_u16(&p->channel->serial_no);
363 }
364 }
365 }
366 }
367 return result;
368 }
369
jr3_pci_open(struct comedi_device * dev)370 static int jr3_pci_open(struct comedi_device *dev)
371 {
372 int i;
373 struct jr3_pci_dev_private *devpriv = dev->private;
374
375 dev_dbg(dev->hw_dev, "jr3_pci_open\n");
376 for (i = 0; i < devpriv->n_channels; i++) {
377 struct jr3_pci_subdev_private *p;
378
379 p = dev->subdevices[i].private;
380 if (p) {
381 dev_dbg(dev->hw_dev, "serial: %p %d (%d)\n", p,
382 p->serial_no, p->channel_no);
383 }
384 }
385 return 0;
386 }
387
read_idm_word(const u8 * data,size_t size,int * pos,unsigned int * val)388 int read_idm_word(const u8 * data, size_t size, int *pos, unsigned int *val)
389 {
390 int result = 0;
391 if (pos != 0 && val != 0) {
392 /* Skip over non hex */
393 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++) {
394 }
395 /* Collect value */
396 *val = 0;
397 for (; *pos < size; (*pos)++) {
398 int value;
399 value = hex_to_bin(data[*pos]);
400 if (value >= 0) {
401 result = 1;
402 *val = (*val << 4) + value;
403 } else
404 break;
405 }
406 }
407 return result;
408 }
409
jr3_download_firmware(struct comedi_device * dev,const u8 * data,size_t size)410 static int jr3_download_firmware(struct comedi_device *dev, const u8 * data,
411 size_t size)
412 {
413 /*
414 * IDM file format is:
415 * { count, address, data <count> } *
416 * ffff
417 */
418 int result, more, pos, OK;
419
420 result = 0;
421 more = 1;
422 pos = 0;
423 OK = 0;
424 while (more) {
425 unsigned int count, addr;
426
427 more = more && read_idm_word(data, size, &pos, &count);
428 if (more && count == 0xffff) {
429 OK = 1;
430 break;
431 }
432 more = more && read_idm_word(data, size, &pos, &addr);
433 while (more && count > 0) {
434 unsigned int dummy;
435 more = more && read_idm_word(data, size, &pos, &dummy);
436 count--;
437 }
438 }
439
440 if (!OK) {
441 result = -ENODATA;
442 } else {
443 int i;
444 struct jr3_pci_dev_private *p = dev->private;
445
446 for (i = 0; i < p->n_channels; i++) {
447 struct jr3_pci_subdev_private *sp;
448
449 sp = dev->subdevices[i].private;
450 more = 1;
451 pos = 0;
452 while (more) {
453 unsigned int count, addr;
454 more = more
455 && read_idm_word(data, size, &pos, &count);
456 if (more && count == 0xffff)
457 break;
458 more = more
459 && read_idm_word(data, size, &pos, &addr);
460 dev_dbg(dev->hw_dev, "Loading#%d %4.4x bytes at %4.4x\n",
461 i, count, addr);
462 while (more && count > 0) {
463 if (addr & 0x4000) {
464 /* 16 bit data, never seen in real life!! */
465 unsigned int data1;
466
467 more = more
468 && read_idm_word(data,
469 size, &pos,
470 &data1);
471 count--;
472 /* printk("jr3_data, not tested\n"); */
473 /* jr3[addr + 0x20000 * pnum] = data1; */
474 } else {
475 /* Download 24 bit program */
476 unsigned int data1, data2;
477
478 more = more
479 && read_idm_word(data,
480 size, &pos,
481 &data1);
482 more = more
483 && read_idm_word(data, size,
484 &pos,
485 &data2);
486 count -= 2;
487 if (more) {
488 set_u16(&p->
489 iobase->channel
490 [i].program_low
491 [addr], data1);
492 udelay(1);
493 set_u16(&p->
494 iobase->channel
495 [i].program_high
496 [addr], data2);
497 udelay(1);
498
499 }
500 }
501 addr++;
502 }
503 }
504 }
505 }
506 return result;
507 }
508
jr3_pci_poll_subdevice(struct comedi_subdevice * s)509 static struct poll_delay_t jr3_pci_poll_subdevice(struct comedi_subdevice *s)
510 {
511 struct poll_delay_t result = poll_delay_min_max(1000, 2000);
512 struct jr3_pci_subdev_private *p = s->private;
513 int i;
514
515 if (p) {
516 volatile struct jr3_channel *channel = p->channel;
517 int errors = get_u16(&channel->errors);
518
519 if (errors != p->errors) {
520 printk("Errors: %x -> %x\n", p->errors, errors);
521 p->errors = errors;
522 }
523 if (errors & (watch_dog | watch_dog2 | sensor_change)) {
524 /* Sensor communication lost, force poll mode */
525 p->state = state_jr3_poll;
526
527 }
528 switch (p->state) {
529 case state_jr3_poll:{
530 u16 model_no = get_u16(&channel->model_no);
531 u16 serial_no = get_u16(&channel->serial_no);
532 if ((errors & (watch_dog | watch_dog2)) ||
533 model_no == 0 || serial_no == 0) {
534 /*
535 * Still no sensor, keep on polling. Since it takes up to 10 seconds
536 * for offsets to stabilize, polling each second should suffice.
537 */
538 result = poll_delay_min_max(1000, 2000);
539 } else {
540 p->retries = 0;
541 p->state =
542 state_jr3_init_wait_for_offset;
543 result = poll_delay_min_max(1000, 2000);
544 }
545 }
546 break;
547 case state_jr3_init_wait_for_offset:{
548 p->retries++;
549 if (p->retries < 10) {
550 /* Wait for offeset to stabilize (< 10 s according to manual) */
551 result = poll_delay_min_max(1000, 2000);
552 } else {
553 struct transform_t transf;
554
555 p->model_no =
556 get_u16(&channel->model_no);
557 p->serial_no =
558 get_u16(&channel->serial_no);
559
560 printk
561 ("Setting transform for channel %d\n",
562 p->channel_no);
563 printk("Sensor Model = %i\n",
564 p->model_no);
565 printk("Sensor Serial = %i\n",
566 p->serial_no);
567
568 /* Transformation all zeros */
569 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
570 transf.link[i].link_type =
571 (enum link_types)0;
572 transf.link[i].link_amount = 0;
573 }
574
575 set_transforms(channel, transf, 0);
576 use_transform(channel, 0);
577 p->state =
578 state_jr3_init_transform_complete;
579 result = poll_delay_min_max(20, 100); /* Allow 20 ms for completion */
580 }
581 } break;
582 case state_jr3_init_transform_complete:{
583 if (!is_complete(channel)) {
584 printk
585 ("state_jr3_init_transform_complete complete = %d\n",
586 is_complete(channel));
587 result = poll_delay_min_max(20, 100);
588 } else {
589 /* Set full scale */
590 struct six_axis_t min_full_scale;
591 struct six_axis_t max_full_scale;
592
593 min_full_scale =
594 get_min_full_scales(channel);
595 printk("Obtained Min. Full Scales:\n");
596 printk(KERN_DEBUG "%i ", (min_full_scale).fx);
597 printk(KERN_CONT "%i ", (min_full_scale).fy);
598 printk(KERN_CONT "%i ", (min_full_scale).fz);
599 printk(KERN_CONT "%i ", (min_full_scale).mx);
600 printk(KERN_CONT "%i ", (min_full_scale).my);
601 printk(KERN_CONT "%i ", (min_full_scale).mz);
602 printk(KERN_CONT "\n");
603
604 max_full_scale =
605 get_max_full_scales(channel);
606 printk("Obtained Max. Full Scales:\n");
607 printk(KERN_DEBUG "%i ", (max_full_scale).fx);
608 printk(KERN_CONT "%i ", (max_full_scale).fy);
609 printk(KERN_CONT "%i ", (max_full_scale).fz);
610 printk(KERN_CONT "%i ", (max_full_scale).mx);
611 printk(KERN_CONT "%i ", (max_full_scale).my);
612 printk(KERN_CONT "%i ", (max_full_scale).mz);
613 printk(KERN_CONT "\n");
614
615 set_full_scales(channel,
616 max_full_scale);
617
618 p->state =
619 state_jr3_init_set_full_scale_complete;
620 result = poll_delay_min_max(20, 100); /* Allow 20 ms for completion */
621 }
622 }
623 break;
624 case state_jr3_init_set_full_scale_complete:{
625 if (!is_complete(channel)) {
626 printk
627 ("state_jr3_init_set_full_scale_complete complete = %d\n",
628 is_complete(channel));
629 result = poll_delay_min_max(20, 100);
630 } else {
631 volatile struct force_array *full_scale;
632
633 /* Use ranges in kN or we will overflow arount 2000N! */
634 full_scale = &channel->full_scale;
635 p->range[0].range.min =
636 -get_s16(&full_scale->fx) * 1000;
637 p->range[0].range.max =
638 get_s16(&full_scale->fx) * 1000;
639 p->range[1].range.min =
640 -get_s16(&full_scale->fy) * 1000;
641 p->range[1].range.max =
642 get_s16(&full_scale->fy) * 1000;
643 p->range[2].range.min =
644 -get_s16(&full_scale->fz) * 1000;
645 p->range[2].range.max =
646 get_s16(&full_scale->fz) * 1000;
647 p->range[3].range.min =
648 -get_s16(&full_scale->mx) * 100;
649 p->range[3].range.max =
650 get_s16(&full_scale->mx) * 100;
651 p->range[4].range.min =
652 -get_s16(&full_scale->my) * 100;
653 p->range[4].range.max =
654 get_s16(&full_scale->my) * 100;
655 p->range[5].range.min =
656 -get_s16(&full_scale->mz) * 100;
657 p->range[5].range.max =
658 get_s16(&full_scale->mz) * 100;
659 p->range[6].range.min = -get_s16(&full_scale->v1) * 100; /* ?? */
660 p->range[6].range.max = get_s16(&full_scale->v1) * 100; /* ?? */
661 p->range[7].range.min = -get_s16(&full_scale->v2) * 100; /* ?? */
662 p->range[7].range.max = get_s16(&full_scale->v2) * 100; /* ?? */
663 p->range[8].range.min = 0;
664 p->range[8].range.max = 65535;
665
666 {
667 int i;
668 for (i = 0; i < 9; i++) {
669 printk("%d %d - %d\n",
670 i,
671 p->
672 range[i].range.
673 min,
674 p->
675 range[i].range.
676 max);
677 }
678 }
679
680 use_offset(channel, 0);
681 p->state =
682 state_jr3_init_use_offset_complete;
683 result = poll_delay_min_max(40, 100); /* Allow 40 ms for completion */
684 }
685 }
686 break;
687 case state_jr3_init_use_offset_complete:{
688 if (!is_complete(channel)) {
689 printk
690 ("state_jr3_init_use_offset_complete complete = %d\n",
691 is_complete(channel));
692 result = poll_delay_min_max(20, 100);
693 } else {
694 printk
695 ("Default offsets %d %d %d %d %d %d\n",
696 get_s16(&channel->offsets.fx),
697 get_s16(&channel->offsets.fy),
698 get_s16(&channel->offsets.fz),
699 get_s16(&channel->offsets.mx),
700 get_s16(&channel->offsets.my),
701 get_s16(&channel->offsets.mz));
702
703 set_s16(&channel->offsets.fx, 0);
704 set_s16(&channel->offsets.fy, 0);
705 set_s16(&channel->offsets.fz, 0);
706 set_s16(&channel->offsets.mx, 0);
707 set_s16(&channel->offsets.my, 0);
708 set_s16(&channel->offsets.mz, 0);
709
710 set_offset(channel);
711
712 p->state = state_jr3_done;
713 }
714 }
715 break;
716 case state_jr3_done:{
717 poll_delay_min_max(10000, 20000);
718 }
719 break;
720 default:{
721 poll_delay_min_max(1000, 2000);
722 }
723 break;
724 }
725 }
726 return result;
727 }
728
jr3_pci_poll_dev(unsigned long data)729 static void jr3_pci_poll_dev(unsigned long data)
730 {
731 unsigned long flags;
732 struct comedi_device *dev = (struct comedi_device *)data;
733 struct jr3_pci_dev_private *devpriv = dev->private;
734 unsigned long now;
735 int delay;
736 int i;
737
738 spin_lock_irqsave(&dev->spinlock, flags);
739 delay = 1000;
740 now = jiffies;
741 /* Poll all channels that are ready to be polled */
742 for (i = 0; i < devpriv->n_channels; i++) {
743 struct jr3_pci_subdev_private *subdevpriv =
744 dev->subdevices[i].private;
745 if (now > subdevpriv->next_time_min) {
746 struct poll_delay_t sub_delay;
747
748 sub_delay = jr3_pci_poll_subdevice(&dev->subdevices[i]);
749 subdevpriv->next_time_min =
750 jiffies + msecs_to_jiffies(sub_delay.min);
751 subdevpriv->next_time_max =
752 jiffies + msecs_to_jiffies(sub_delay.max);
753 if (sub_delay.max && sub_delay.max < delay) {
754 /*
755 * Wake up as late as possible -> poll as many channels as possible
756 * at once
757 */
758 delay = sub_delay.max;
759 }
760 }
761 }
762 spin_unlock_irqrestore(&dev->spinlock, flags);
763
764 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
765 add_timer(&devpriv->timer);
766 }
767
jr3_pci_attach(struct comedi_device * dev,struct comedi_devconfig * it)768 static int jr3_pci_attach(struct comedi_device *dev,
769 struct comedi_devconfig *it)
770 {
771 int result = 0;
772 struct pci_dev *card = NULL;
773 int opt_bus, opt_slot, i;
774 struct jr3_pci_dev_private *devpriv;
775
776 opt_bus = it->options[0];
777 opt_slot = it->options[1];
778
779 if (sizeof(struct jr3_channel) != 0xc00) {
780 dev_err(dev->hw_dev, "sizeof(struct jr3_channel) = %x [expected %x]\n",
781 (unsigned)sizeof(struct jr3_channel), 0xc00);
782 return -EINVAL;
783 }
784
785 result = alloc_private(dev, sizeof(struct jr3_pci_dev_private));
786 if (result < 0)
787 return -ENOMEM;
788 card = NULL;
789 devpriv = dev->private;
790 init_timer(&devpriv->timer);
791 while (1) {
792 card = pci_get_device(PCI_VENDOR_ID_JR3, PCI_ANY_ID, card);
793 if (card == NULL) {
794 /* No card found */
795 break;
796 } else {
797 switch (card->device) {
798 case PCI_DEVICE_ID_JR3_1_CHANNEL:{
799 devpriv->n_channels = 1;
800 }
801 break;
802 case PCI_DEVICE_ID_JR3_1_CHANNEL_NEW:{
803 devpriv->n_channels = 1;
804 }
805 break;
806 case PCI_DEVICE_ID_JR3_2_CHANNEL:{
807 devpriv->n_channels = 2;
808 }
809 break;
810 case PCI_DEVICE_ID_JR3_3_CHANNEL:{
811 devpriv->n_channels = 3;
812 }
813 break;
814 case PCI_DEVICE_ID_JR3_4_CHANNEL:{
815 devpriv->n_channels = 4;
816 }
817 break;
818 default:{
819 devpriv->n_channels = 0;
820 }
821 }
822 if (devpriv->n_channels >= 1) {
823 if (opt_bus == 0 && opt_slot == 0) {
824 /* Take first available card */
825 break;
826 } else if (opt_bus == card->bus->number &&
827 opt_slot == PCI_SLOT(card->devfn)) {
828 /* Take requested card */
829 break;
830 }
831 }
832 }
833 }
834 if (!card) {
835 dev_err(dev->hw_dev, "no jr3_pci found\n");
836 return -EIO;
837 } else {
838 devpriv->pci_dev = card;
839 dev->board_name = "jr3_pci";
840 }
841
842 result = comedi_pci_enable(card, "jr3_pci");
843 if (result < 0)
844 return -EIO;
845
846 devpriv->pci_enabled = 1;
847 devpriv->iobase = ioremap(pci_resource_start(card, 0),
848 offsetof(struct jr3_t, channel[devpriv->n_channels]));
849 if (!devpriv->iobase)
850 return -ENOMEM;
851
852 result = alloc_subdevices(dev, devpriv->n_channels);
853 if (result < 0)
854 goto out;
855
856 dev->open = jr3_pci_open;
857 for (i = 0; i < devpriv->n_channels; i++) {
858 dev->subdevices[i].type = COMEDI_SUBD_AI;
859 dev->subdevices[i].subdev_flags = SDF_READABLE | SDF_GROUND;
860 dev->subdevices[i].n_chan = 8 * 7 + 2;
861 dev->subdevices[i].insn_read = jr3_pci_ai_insn_read;
862 dev->subdevices[i].private =
863 kzalloc(sizeof(struct jr3_pci_subdev_private), GFP_KERNEL);
864 if (dev->subdevices[i].private) {
865 struct jr3_pci_subdev_private *p;
866 int j;
867
868 p = dev->subdevices[i].private;
869 p->channel = &devpriv->iobase->channel[i].data;
870 dev_dbg(dev->hw_dev, "p->channel %p %p (%tx)\n",
871 p->channel, devpriv->iobase,
872 ((char *)(p->channel) -
873 (char *)(devpriv->iobase)));
874 p->channel_no = i;
875 for (j = 0; j < 8; j++) {
876 int k;
877
878 p->range[j].length = 1;
879 p->range[j].range.min = -1000000;
880 p->range[j].range.max = 1000000;
881 for (k = 0; k < 7; k++) {
882 p->range_table_list[j + k * 8] =
883 (struct comedi_lrange *)&p->
884 range[j];
885 p->maxdata_list[j + k * 8] = 0x7fff;
886 }
887 }
888 p->range[8].length = 1;
889 p->range[8].range.min = 0;
890 p->range[8].range.max = 65536;
891
892 p->range_table_list[56] =
893 (struct comedi_lrange *)&p->range[8];
894 p->range_table_list[57] =
895 (struct comedi_lrange *)&p->range[8];
896 p->maxdata_list[56] = 0xffff;
897 p->maxdata_list[57] = 0xffff;
898 /* Channel specific range and maxdata */
899 dev->subdevices[i].range_table = 0;
900 dev->subdevices[i].range_table_list =
901 p->range_table_list;
902 dev->subdevices[i].maxdata = 0;
903 dev->subdevices[i].maxdata_list = p->maxdata_list;
904 }
905 }
906
907 /* Reset DSP card */
908 devpriv->iobase->channel[0].reset = 0;
909
910 result = comedi_load_firmware(dev, "jr3pci.idm", jr3_download_firmware);
911 dev_dbg(dev->hw_dev, "Firmare load %d\n", result);
912
913 if (result < 0)
914 goto out;
915 /*
916 * TODO: use firmware to load preferred offset tables. Suggested
917 * format:
918 * model serial Fx Fy Fz Mx My Mz\n
919 *
920 * comedi_load_firmware(dev, "jr3_offsets_table", jr3_download_firmware);
921 */
922
923 /*
924 * It takes a few milliseconds for software to settle as much as we
925 * can read firmware version
926 */
927 msleep_interruptible(25);
928 for (i = 0; i < 0x18; i++) {
929 dev_dbg(dev->hw_dev, "%c\n",
930 get_u16(&devpriv->iobase->channel[0].
931 data.copyright[i]) >> 8);
932 }
933
934 /* Start card timer */
935 for (i = 0; i < devpriv->n_channels; i++) {
936 struct jr3_pci_subdev_private *p = dev->subdevices[i].private;
937
938 p->next_time_min = jiffies + msecs_to_jiffies(500);
939 p->next_time_max = jiffies + msecs_to_jiffies(2000);
940 }
941
942 devpriv->timer.data = (unsigned long)dev;
943 devpriv->timer.function = jr3_pci_poll_dev;
944 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
945 add_timer(&devpriv->timer);
946
947 out:
948 return result;
949 }
950
951 MODULE_FIRMWARE("comedi/jr3pci.idm");
952
jr3_pci_detach(struct comedi_device * dev)953 static int jr3_pci_detach(struct comedi_device *dev)
954 {
955 int i;
956 struct jr3_pci_dev_private *devpriv = dev->private;
957
958 if (devpriv) {
959 del_timer_sync(&devpriv->timer);
960
961 if (dev->subdevices) {
962 for (i = 0; i < devpriv->n_channels; i++)
963 kfree(dev->subdevices[i].private);
964 }
965
966 if (devpriv->iobase)
967 iounmap((void *)devpriv->iobase);
968 if (devpriv->pci_enabled)
969 comedi_pci_disable(devpriv->pci_dev);
970
971 if (devpriv->pci_dev)
972 pci_dev_put(devpriv->pci_dev);
973 }
974 return 0;
975 }
976
driver_jr3_pci_pci_probe(struct pci_dev * dev,const struct pci_device_id * ent)977 static int __devinit driver_jr3_pci_pci_probe(struct pci_dev *dev,
978 const struct pci_device_id *ent)
979 {
980 return comedi_pci_auto_config(dev, driver_jr3_pci.driver_name);
981 }
982
driver_jr3_pci_pci_remove(struct pci_dev * dev)983 static void __devexit driver_jr3_pci_pci_remove(struct pci_dev *dev)
984 {
985 comedi_pci_auto_unconfig(dev);
986 }
987
988 static struct pci_driver driver_jr3_pci_pci_driver = {
989 .id_table = jr3_pci_pci_table,
990 .probe = &driver_jr3_pci_pci_probe,
991 .remove = __devexit_p(&driver_jr3_pci_pci_remove)
992 };
993
driver_jr3_pci_init_module(void)994 static int __init driver_jr3_pci_init_module(void)
995 {
996 int retval;
997
998 retval = comedi_driver_register(&driver_jr3_pci);
999 if (retval < 0)
1000 return retval;
1001
1002 driver_jr3_pci_pci_driver.name = (char *)driver_jr3_pci.driver_name;
1003 return pci_register_driver(&driver_jr3_pci_pci_driver);
1004 }
1005
driver_jr3_pci_cleanup_module(void)1006 static void __exit driver_jr3_pci_cleanup_module(void)
1007 {
1008 pci_unregister_driver(&driver_jr3_pci_pci_driver);
1009 comedi_driver_unregister(&driver_jr3_pci);
1010 }
1011
1012 module_init(driver_jr3_pci_init_module);
1013 module_exit(driver_jr3_pci_cleanup_module);
1014
1015 MODULE_AUTHOR("Comedi http://www.comedi.org");
1016 MODULE_DESCRIPTION("Comedi low-level driver");
1017 MODULE_LICENSE("GPL");
1018