1 // SPDX-License-Identifier: GPL-2.0+
3 * comedi/drivers/jr3_pci.c
4 * hardware driver for JR3/PCI force sensor board
6 * COMEDI - Linux Control and Measurement Device Interface
7 * Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
11 * Description: JR3/PCI force sensor board
12 * Author: Anders Blomdell <anders.blomdell@control.lth.se>
13 * Updated: Thu, 01 Nov 2012 17:34:55 +0000
15 * Devices: [JR3] PCI force sensor board (jr3_pci)
17 * Configuration options:
20 * Manual configuration of comedi devices is not supported by this
21 * driver; supported PCI devices are configured as comedi devices
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/delay.h>
29 #include <linux/ctype.h>
30 #include <linux/jiffies.h>
31 #include <linux/slab.h>
32 #include <linux/timer.h>
34 #include "../comedi_pci.h"
38 #define PCI_VENDOR_ID_JR3 0x1762
40 enum jr3_pci_boardid {
47 struct jr3_pci_board {
52 static const struct jr3_pci_board jr3_pci_boards[] = {
71 struct jr3_pci_transform {
78 struct jr3_pci_poll_delay {
83 struct jr3_pci_dev_private {
84 struct timer_list timer;
85 struct comedi_device *dev;
88 union jr3_pci_single_range {
89 struct comedi_lrange l;
90 char _reserved[offsetof(struct comedi_lrange, range[1])];
93 enum jr3_pci_poll_state {
95 state_jr3_init_wait_for_offset,
96 state_jr3_init_transform_complete,
97 state_jr3_init_set_full_scale_complete,
98 state_jr3_init_use_offset_complete,
102 struct jr3_pci_subdev_private {
103 struct jr3_sensor __iomem *sensor;
104 unsigned long next_time_min;
105 enum jr3_pci_poll_state state;
108 union jr3_pci_single_range range[9];
109 const struct comedi_lrange *range_table_list[8 * 7 + 2];
110 unsigned int maxdata_list[8 * 7 + 2];
115 static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max)
117 struct jr3_pci_poll_delay result;
124 static int is_complete(struct jr3_sensor __iomem *sensor)
126 return get_s16(&sensor->command_word0) == 0;
129 static void set_transforms(struct jr3_sensor __iomem *sensor,
130 const struct jr3_pci_transform *transf, short num)
134 num &= 0x000f; /* Make sure that 0 <= num <= 15 */
135 for (i = 0; i < 8; i++) {
136 set_u16(&sensor->transforms[num].link[i].link_type,
137 transf->link[i].link_type);
139 set_s16(&sensor->transforms[num].link[i].link_amount,
140 transf->link[i].link_amount);
142 if (transf->link[i].link_type == end_x_form)
147 static void use_transform(struct jr3_sensor __iomem *sensor,
150 set_s16(&sensor->command_word0, 0x0500 + (transf_num & 0x000f));
153 static void use_offset(struct jr3_sensor __iomem *sensor, short offset_num)
155 set_s16(&sensor->command_word0, 0x0600 + (offset_num & 0x000f));
158 static void set_offset(struct jr3_sensor __iomem *sensor)
160 set_s16(&sensor->command_word0, 0x0700);
172 static void set_full_scales(struct jr3_sensor __iomem *sensor,
173 struct six_axis_t full_scale)
175 set_s16(&sensor->full_scale.fx, full_scale.fx);
176 set_s16(&sensor->full_scale.fy, full_scale.fy);
177 set_s16(&sensor->full_scale.fz, full_scale.fz);
178 set_s16(&sensor->full_scale.mx, full_scale.mx);
179 set_s16(&sensor->full_scale.my, full_scale.my);
180 set_s16(&sensor->full_scale.mz, full_scale.mz);
181 set_s16(&sensor->command_word0, 0x0a00);
184 static struct six_axis_t get_min_full_scales(struct jr3_sensor __iomem *sensor)
186 struct six_axis_t result;
188 result.fx = get_s16(&sensor->min_full_scale.fx);
189 result.fy = get_s16(&sensor->min_full_scale.fy);
190 result.fz = get_s16(&sensor->min_full_scale.fz);
191 result.mx = get_s16(&sensor->min_full_scale.mx);
192 result.my = get_s16(&sensor->min_full_scale.my);
193 result.mz = get_s16(&sensor->min_full_scale.mz);
197 static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)
199 struct six_axis_t result;
201 result.fx = get_s16(&sensor->max_full_scale.fx);
202 result.fy = get_s16(&sensor->max_full_scale.fy);
203 result.fz = get_s16(&sensor->max_full_scale.fz);
204 result.mx = get_s16(&sensor->max_full_scale.mx);
205 result.my = get_s16(&sensor->max_full_scale.my);
206 result.mz = get_s16(&sensor->max_full_scale.mz);
210 static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
211 struct comedi_subdevice *s,
214 struct jr3_pci_subdev_private *spriv = s->private;
215 unsigned int val = 0;
217 if (spriv->state != state_jr3_done)
221 unsigned int axis = chan % 8;
222 unsigned int filter = chan / 8;
226 val = get_s16(&spriv->sensor->filter[filter].fx);
229 val = get_s16(&spriv->sensor->filter[filter].fy);
232 val = get_s16(&spriv->sensor->filter[filter].fz);
235 val = get_s16(&spriv->sensor->filter[filter].mx);
238 val = get_s16(&spriv->sensor->filter[filter].my);
241 val = get_s16(&spriv->sensor->filter[filter].mz);
244 val = get_s16(&spriv->sensor->filter[filter].v1);
247 val = get_s16(&spriv->sensor->filter[filter].v2);
251 } else if (chan == 56) {
252 val = get_u16(&spriv->sensor->model_no);
253 } else if (chan == 57) {
254 val = get_u16(&spriv->sensor->serial_no);
260 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
261 struct comedi_subdevice *s,
262 struct comedi_insn *insn,
265 struct jr3_pci_subdev_private *spriv = s->private;
266 unsigned int chan = CR_CHAN(insn->chanspec);
270 errors = get_u16(&spriv->sensor->errors);
271 if (spriv->state != state_jr3_done ||
272 (errors & (watch_dog | watch_dog2 | sensor_change))) {
273 /* No sensor or sensor changed */
274 if (spriv->state == state_jr3_done) {
275 /* Restart polling */
276 spriv->state = state_jr3_poll;
281 for (i = 0; i < insn->n; i++)
282 data[i] = jr3_pci_ai_read_chan(dev, s, chan);
287 static int jr3_pci_open(struct comedi_device *dev)
289 struct jr3_pci_subdev_private *spriv;
290 struct comedi_subdevice *s;
293 for (i = 0; i < dev->n_subdevices; i++) {
294 s = &dev->subdevices[i];
296 dev_dbg(dev->class_dev, "serial[%d]: %d\n", s->index,
302 static int read_idm_word(const u8 *data, size_t size, int *pos,
309 /* Skip over non hex */
310 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++)
314 for (; *pos < size; (*pos)++) {
315 value = hex_to_bin(data[*pos]);
318 *val = (*val << 4) + value;
327 static int jr3_check_firmware(struct comedi_device *dev,
328 const u8 *data, size_t size)
334 * IDM file format is:
335 * { count, address, data <count> } *
339 unsigned int count = 0;
340 unsigned int addr = 0;
342 more = more && read_idm_word(data, size, &pos, &count);
343 if (more && count == 0xffff)
346 more = more && read_idm_word(data, size, &pos, &addr);
347 while (more && count > 0) {
348 unsigned int dummy = 0;
350 more = more && read_idm_word(data, size, &pos, &dummy);
358 static void jr3_write_firmware(struct comedi_device *dev,
359 int subdev, const u8 *data, size_t size)
361 struct jr3_block __iomem *block = dev->mmio;
368 unsigned int count = 0;
369 unsigned int addr = 0;
371 more = more && read_idm_word(data, size, &pos, &count);
372 if (more && count == 0xffff)
375 more = more && read_idm_word(data, size, &pos, &addr);
377 dev_dbg(dev->class_dev, "Loading#%d %4.4x bytes at %4.4x\n",
378 subdev, count, addr);
380 while (more && count > 0) {
382 /* 16 bit data, never seen in real life!! */
383 unsigned int data1 = 0;
386 read_idm_word(data, size, &pos, &data1);
388 /* jr3[addr + 0x20000 * pnum] = data1; */
390 /* Download 24 bit program */
391 unsigned int data1 = 0;
392 unsigned int data2 = 0;
394 lo = &block[subdev].program_lo[addr];
395 hi = &block[subdev].program_hi[addr];
398 read_idm_word(data, size, &pos, &data1);
400 read_idm_word(data, size, &pos, &data2);
414 static int jr3_download_firmware(struct comedi_device *dev,
415 const u8 *data, size_t size,
416 unsigned long context)
421 /* verify IDM file format */
422 ret = jr3_check_firmware(dev, data, size);
426 /* write firmware to each subdevice */
427 for (subdev = 0; subdev < dev->n_subdevices; subdev++)
428 jr3_write_firmware(dev, subdev, data, size);
433 static struct jr3_pci_poll_delay
434 jr3_pci_poll_subdevice(struct comedi_subdevice *s)
436 struct jr3_pci_subdev_private *spriv = s->private;
437 struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);
438 struct jr3_sensor __iomem *sensor;
444 sensor = spriv->sensor;
445 errors = get_u16(&sensor->errors);
447 if (errors != spriv->errors)
448 spriv->errors = errors;
450 /* Sensor communication lost? force poll mode */
451 if (errors & (watch_dog | watch_dog2 | sensor_change))
452 spriv->state = state_jr3_poll;
454 switch (spriv->state) {
456 model_no = get_u16(&sensor->model_no);
457 serial_no = get_u16(&sensor->serial_no);
459 if ((errors & (watch_dog | watch_dog2)) ||
460 model_no == 0 || serial_no == 0) {
462 * Still no sensor, keep on polling.
463 * Since it takes up to 10 seconds for offsets to
464 * stabilize, polling each second should suffice.
468 spriv->state = state_jr3_init_wait_for_offset;
471 case state_jr3_init_wait_for_offset:
473 if (spriv->retries < 10) {
475 * Wait for offeset to stabilize
476 * (< 10 s according to manual)
479 struct jr3_pci_transform transf;
481 spriv->model_no = get_u16(&sensor->model_no);
482 spriv->serial_no = get_u16(&sensor->serial_no);
484 /* Transformation all zeros */
485 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
486 transf.link[i].link_type = (enum link_types)0;
487 transf.link[i].link_amount = 0;
490 set_transforms(sensor, &transf, 0);
491 use_transform(sensor, 0);
492 spriv->state = state_jr3_init_transform_complete;
493 /* Allow 20 ms for completion */
494 result = poll_delay_min_max(20, 100);
497 case state_jr3_init_transform_complete:
498 if (!is_complete(sensor)) {
499 result = poll_delay_min_max(20, 100);
502 struct six_axis_t min_full_scale;
503 struct six_axis_t max_full_scale;
505 min_full_scale = get_min_full_scales(sensor);
506 max_full_scale = get_max_full_scales(sensor);
507 set_full_scales(sensor, max_full_scale);
509 spriv->state = state_jr3_init_set_full_scale_complete;
510 /* Allow 20 ms for completion */
511 result = poll_delay_min_max(20, 100);
514 case state_jr3_init_set_full_scale_complete:
515 if (!is_complete(sensor)) {
516 result = poll_delay_min_max(20, 100);
518 struct force_array __iomem *fs = &sensor->full_scale;
519 union jr3_pci_single_range *r = spriv->range;
521 /* Use ranges in kN or we will overflow around 2000N! */
522 r[0].l.range[0].min = -get_s16(&fs->fx) * 1000;
523 r[0].l.range[0].max = get_s16(&fs->fx) * 1000;
524 r[1].l.range[0].min = -get_s16(&fs->fy) * 1000;
525 r[1].l.range[0].max = get_s16(&fs->fy) * 1000;
526 r[2].l.range[0].min = -get_s16(&fs->fz) * 1000;
527 r[2].l.range[0].max = get_s16(&fs->fz) * 1000;
528 r[3].l.range[0].min = -get_s16(&fs->mx) * 100;
529 r[3].l.range[0].max = get_s16(&fs->mx) * 100;
530 r[4].l.range[0].min = -get_s16(&fs->my) * 100;
531 r[4].l.range[0].max = get_s16(&fs->my) * 100;
532 r[5].l.range[0].min = -get_s16(&fs->mz) * 100;
533 /* the next five are questionable */
534 r[5].l.range[0].max = get_s16(&fs->mz) * 100;
535 r[6].l.range[0].min = -get_s16(&fs->v1) * 100;
536 r[6].l.range[0].max = get_s16(&fs->v1) * 100;
537 r[7].l.range[0].min = -get_s16(&fs->v2) * 100;
538 r[7].l.range[0].max = get_s16(&fs->v2) * 100;
539 r[8].l.range[0].min = 0;
540 r[8].l.range[0].max = 65535;
542 use_offset(sensor, 0);
543 spriv->state = state_jr3_init_use_offset_complete;
544 /* Allow 40 ms for completion */
545 result = poll_delay_min_max(40, 100);
548 case state_jr3_init_use_offset_complete:
549 if (!is_complete(sensor)) {
550 result = poll_delay_min_max(20, 100);
552 set_s16(&sensor->offsets.fx, 0);
553 set_s16(&sensor->offsets.fy, 0);
554 set_s16(&sensor->offsets.fz, 0);
555 set_s16(&sensor->offsets.mx, 0);
556 set_s16(&sensor->offsets.my, 0);
557 set_s16(&sensor->offsets.mz, 0);
561 spriv->state = state_jr3_done;
565 result = poll_delay_min_max(10000, 20000);
574 static void jr3_pci_poll_dev(struct timer_list *t)
576 struct jr3_pci_dev_private *devpriv = from_timer(devpriv, t, timer);
577 struct comedi_device *dev = devpriv->dev;
578 struct jr3_pci_subdev_private *spriv;
579 struct comedi_subdevice *s;
585 spin_lock_irqsave(&dev->spinlock, flags);
589 /* Poll all sensors that are ready to be polled */
590 for (i = 0; i < dev->n_subdevices; i++) {
591 s = &dev->subdevices[i];
594 if (time_after_eq(now, spriv->next_time_min)) {
595 struct jr3_pci_poll_delay sub_delay;
597 sub_delay = jr3_pci_poll_subdevice(s);
599 spriv->next_time_min = jiffies +
600 msecs_to_jiffies(sub_delay.min);
602 if (sub_delay.max && sub_delay.max < delay)
604 * Wake up as late as possible ->
605 * poll as many sensors as possible at once.
607 delay = sub_delay.max;
610 spin_unlock_irqrestore(&dev->spinlock, flags);
612 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
613 add_timer(&devpriv->timer);
616 static struct jr3_pci_subdev_private *
617 jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s)
619 struct jr3_block __iomem *block = dev->mmio;
620 struct jr3_pci_subdev_private *spriv;
624 spriv = comedi_alloc_spriv(s, sizeof(*spriv));
628 spriv->sensor = &block[s->index].sensor;
630 for (j = 0; j < 8; j++) {
631 spriv->range[j].l.length = 1;
632 spriv->range[j].l.range[0].min = -1000000;
633 spriv->range[j].l.range[0].max = 1000000;
635 for (k = 0; k < 7; k++) {
636 spriv->range_table_list[j + k * 8] = &spriv->range[j].l;
637 spriv->maxdata_list[j + k * 8] = 0x7fff;
640 spriv->range[8].l.length = 1;
641 spriv->range[8].l.range[0].min = 0;
642 spriv->range[8].l.range[0].max = 65535;
644 spriv->range_table_list[56] = &spriv->range[8].l;
645 spriv->range_table_list[57] = &spriv->range[8].l;
646 spriv->maxdata_list[56] = 0xffff;
647 spriv->maxdata_list[57] = 0xffff;
652 static void jr3_pci_show_copyright(struct comedi_device *dev)
654 struct jr3_block __iomem *block = dev->mmio;
655 struct jr3_sensor __iomem *sensor0 = &block[0].sensor;
656 char copy[ARRAY_SIZE(sensor0->copyright) + 1];
659 for (i = 0; i < ARRAY_SIZE(sensor0->copyright); i++)
660 copy[i] = (char)(get_u16(&sensor0->copyright[i]) >> 8);
662 dev_dbg(dev->class_dev, "Firmware copyright: %s\n", copy);
665 static int jr3_pci_auto_attach(struct comedi_device *dev,
666 unsigned long context)
668 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
669 static const struct jr3_pci_board *board;
670 struct jr3_pci_dev_private *devpriv;
671 struct jr3_pci_subdev_private *spriv;
672 struct jr3_block __iomem *block;
673 struct comedi_subdevice *s;
677 BUILD_BUG_ON(sizeof(struct jr3_block) != 0x80000);
679 if (context < ARRAY_SIZE(jr3_pci_boards))
680 board = &jr3_pci_boards[context];
683 dev->board_ptr = board;
684 dev->board_name = board->name;
686 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
690 ret = comedi_pci_enable(dev);
694 if (pci_resource_len(pcidev, 0) < board->n_subdevs * sizeof(*block))
697 dev->mmio = pci_ioremap_bar(pcidev, 0);
703 ret = comedi_alloc_subdevices(dev, board->n_subdevs);
707 dev->open = jr3_pci_open;
708 for (i = 0; i < dev->n_subdevices; i++) {
709 s = &dev->subdevices[i];
710 s->type = COMEDI_SUBD_AI;
711 s->subdev_flags = SDF_READABLE | SDF_GROUND;
712 s->n_chan = 8 * 7 + 2;
713 s->insn_read = jr3_pci_ai_insn_read;
715 spriv = jr3_pci_alloc_spriv(dev, s);
719 /* Channel specific range and maxdata */
720 s->range_table_list = spriv->range_table_list;
721 s->maxdata_list = spriv->maxdata_list;
725 for (i = 0; i < dev->n_subdevices; i++)
726 writel(0, &block[i].reset);
728 ret = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
730 jr3_download_firmware, 0);
731 dev_dbg(dev->class_dev, "Firmware load %d\n", ret);
735 * TODO: use firmware to load preferred offset tables. Suggested
737 * model serial Fx Fy Fz Mx My Mz\n
739 * comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
740 * "comedi/jr3_offsets_table",
741 * jr3_download_firmware, 1);
745 * It takes a few milliseconds for software to settle as much as we
746 * can read firmware version
748 msleep_interruptible(25);
749 jr3_pci_show_copyright(dev);
751 /* Start card timer */
752 for (i = 0; i < dev->n_subdevices; i++) {
753 s = &dev->subdevices[i];
756 spriv->next_time_min = jiffies + msecs_to_jiffies(500);
760 timer_setup(&devpriv->timer, jr3_pci_poll_dev, 0);
761 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
762 add_timer(&devpriv->timer);
767 static void jr3_pci_detach(struct comedi_device *dev)
769 struct jr3_pci_dev_private *devpriv = dev->private;
772 del_timer_sync(&devpriv->timer);
774 comedi_pci_detach(dev);
777 static struct comedi_driver jr3_pci_driver = {
778 .driver_name = "jr3_pci",
779 .module = THIS_MODULE,
780 .auto_attach = jr3_pci_auto_attach,
781 .detach = jr3_pci_detach,
784 static int jr3_pci_pci_probe(struct pci_dev *dev,
785 const struct pci_device_id *id)
787 return comedi_pci_auto_config(dev, &jr3_pci_driver, id->driver_data);
790 static const struct pci_device_id jr3_pci_pci_table[] = {
791 { PCI_VDEVICE(JR3, 0x1111), BOARD_JR3_1 },
792 { PCI_VDEVICE(JR3, 0x3111), BOARD_JR3_1 },
793 { PCI_VDEVICE(JR3, 0x3112), BOARD_JR3_2 },
794 { PCI_VDEVICE(JR3, 0x3113), BOARD_JR3_3 },
795 { PCI_VDEVICE(JR3, 0x3114), BOARD_JR3_4 },
798 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
800 static struct pci_driver jr3_pci_pci_driver = {
802 .id_table = jr3_pci_pci_table,
803 .probe = jr3_pci_pci_probe,
804 .remove = comedi_pci_auto_unconfig,
806 module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
808 MODULE_AUTHOR("Comedi http://www.comedi.org");
809 MODULE_DESCRIPTION("Comedi driver for JR3/PCI force sensor board");
810 MODULE_LICENSE("GPL");