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