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>
33 #include <linux/comedi/comedi_pci.h>
37 #define PCI_VENDOR_ID_JR3 0x1762
39 enum jr3_pci_boardid {
46 struct jr3_pci_board {
51 static const struct jr3_pci_board jr3_pci_boards[] = {
70 struct jr3_pci_transform {
77 struct jr3_pci_poll_delay {
82 struct jr3_pci_dev_private {
83 struct timer_list timer;
84 struct comedi_device *dev;
87 union jr3_pci_single_range {
88 struct comedi_lrange l;
89 char _reserved[offsetof(struct comedi_lrange, range[1])];
92 enum jr3_pci_poll_state {
94 state_jr3_init_wait_for_offset,
95 state_jr3_init_transform_complete,
96 state_jr3_init_set_full_scale_complete,
97 state_jr3_init_use_offset_complete,
101 struct jr3_pci_subdev_private {
102 struct jr3_sensor __iomem *sensor;
103 unsigned long next_time_min;
104 enum jr3_pci_poll_state state;
107 union jr3_pci_single_range range[9];
108 const struct comedi_lrange *range_table_list[8 * 7 + 2];
109 unsigned int maxdata_list[8 * 7 + 2];
114 static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max)
116 struct jr3_pci_poll_delay result;
123 static int is_complete(struct jr3_sensor __iomem *sensor)
125 return get_s16(&sensor->command_word0) == 0;
128 static void set_transforms(struct jr3_sensor __iomem *sensor,
129 const struct jr3_pci_transform *transf, short num)
133 num &= 0x000f; /* Make sure that 0 <= num <= 15 */
134 for (i = 0; i < 8; i++) {
135 set_u16(&sensor->transforms[num].link[i].link_type,
136 transf->link[i].link_type);
138 set_s16(&sensor->transforms[num].link[i].link_amount,
139 transf->link[i].link_amount);
141 if (transf->link[i].link_type == end_x_form)
146 static void use_transform(struct jr3_sensor __iomem *sensor,
149 set_s16(&sensor->command_word0, 0x0500 + (transf_num & 0x000f));
152 static void use_offset(struct jr3_sensor __iomem *sensor, short offset_num)
154 set_s16(&sensor->command_word0, 0x0600 + (offset_num & 0x000f));
157 static void set_offset(struct jr3_sensor __iomem *sensor)
159 set_s16(&sensor->command_word0, 0x0700);
171 static void set_full_scales(struct jr3_sensor __iomem *sensor,
172 struct six_axis_t full_scale)
174 set_s16(&sensor->full_scale.fx, full_scale.fx);
175 set_s16(&sensor->full_scale.fy, full_scale.fy);
176 set_s16(&sensor->full_scale.fz, full_scale.fz);
177 set_s16(&sensor->full_scale.mx, full_scale.mx);
178 set_s16(&sensor->full_scale.my, full_scale.my);
179 set_s16(&sensor->full_scale.mz, full_scale.mz);
180 set_s16(&sensor->command_word0, 0x0a00);
183 static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)
185 struct six_axis_t result;
187 result.fx = get_s16(&sensor->max_full_scale.fx);
188 result.fy = get_s16(&sensor->max_full_scale.fy);
189 result.fz = get_s16(&sensor->max_full_scale.fz);
190 result.mx = get_s16(&sensor->max_full_scale.mx);
191 result.my = get_s16(&sensor->max_full_scale.my);
192 result.mz = get_s16(&sensor->max_full_scale.mz);
196 static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
197 struct comedi_subdevice *s,
200 struct jr3_pci_subdev_private *spriv = s->private;
201 unsigned int val = 0;
203 if (spriv->state != state_jr3_done)
207 unsigned int axis = chan % 8;
208 unsigned int filter = chan / 8;
212 val = get_s16(&spriv->sensor->filter[filter].fx);
215 val = get_s16(&spriv->sensor->filter[filter].fy);
218 val = get_s16(&spriv->sensor->filter[filter].fz);
221 val = get_s16(&spriv->sensor->filter[filter].mx);
224 val = get_s16(&spriv->sensor->filter[filter].my);
227 val = get_s16(&spriv->sensor->filter[filter].mz);
230 val = get_s16(&spriv->sensor->filter[filter].v1);
233 val = get_s16(&spriv->sensor->filter[filter].v2);
237 } else if (chan == 56) {
238 val = get_u16(&spriv->sensor->model_no);
239 } else if (chan == 57) {
240 val = get_u16(&spriv->sensor->serial_no);
246 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
247 struct comedi_subdevice *s,
248 struct comedi_insn *insn,
251 struct jr3_pci_subdev_private *spriv = s->private;
252 unsigned int chan = CR_CHAN(insn->chanspec);
256 errors = get_u16(&spriv->sensor->errors);
257 if (spriv->state != state_jr3_done ||
258 (errors & (watch_dog | watch_dog2 | sensor_change))) {
259 /* No sensor or sensor changed */
260 if (spriv->state == state_jr3_done) {
261 /* Restart polling */
262 spriv->state = state_jr3_poll;
267 for (i = 0; i < insn->n; i++)
268 data[i] = jr3_pci_ai_read_chan(dev, s, chan);
273 static int jr3_pci_open(struct comedi_device *dev)
275 struct jr3_pci_subdev_private *spriv;
276 struct comedi_subdevice *s;
279 for (i = 0; i < dev->n_subdevices; i++) {
280 s = &dev->subdevices[i];
282 dev_dbg(dev->class_dev, "serial[%d]: %d\n", s->index,
288 static int read_idm_word(const u8 *data, size_t size, int *pos,
295 /* Skip over non hex */
296 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++)
300 for (; *pos < size; (*pos)++) {
301 value = hex_to_bin(data[*pos]);
304 *val = (*val << 4) + value;
313 static int jr3_check_firmware(struct comedi_device *dev,
314 const u8 *data, size_t size)
320 * IDM file format is:
321 * { count, address, data <count> } *
325 unsigned int count = 0;
326 unsigned int addr = 0;
328 more = more && read_idm_word(data, size, &pos, &count);
329 if (more && count == 0xffff)
332 more = more && read_idm_word(data, size, &pos, &addr);
333 while (more && count > 0) {
334 unsigned int dummy = 0;
336 more = more && read_idm_word(data, size, &pos, &dummy);
344 static void jr3_write_firmware(struct comedi_device *dev,
345 int subdev, const u8 *data, size_t size)
347 struct jr3_block __iomem *block = dev->mmio;
354 unsigned int count = 0;
355 unsigned int addr = 0;
357 more = more && read_idm_word(data, size, &pos, &count);
358 if (more && count == 0xffff)
361 more = more && read_idm_word(data, size, &pos, &addr);
363 dev_dbg(dev->class_dev, "Loading#%d %4.4x bytes at %4.4x\n",
364 subdev, count, addr);
366 while (more && count > 0) {
368 /* 16 bit data, never seen in real life!! */
369 unsigned int data1 = 0;
372 read_idm_word(data, size, &pos, &data1);
374 /* jr3[addr + 0x20000 * pnum] = data1; */
376 /* Download 24 bit program */
377 unsigned int data1 = 0;
378 unsigned int data2 = 0;
380 lo = &block[subdev].program_lo[addr];
381 hi = &block[subdev].program_hi[addr];
384 read_idm_word(data, size, &pos, &data1);
386 read_idm_word(data, size, &pos, &data2);
400 static int jr3_download_firmware(struct comedi_device *dev,
401 const u8 *data, size_t size,
402 unsigned long context)
407 /* verify IDM file format */
408 ret = jr3_check_firmware(dev, data, size);
412 /* write firmware to each subdevice */
413 for (subdev = 0; subdev < dev->n_subdevices; subdev++)
414 jr3_write_firmware(dev, subdev, data, size);
419 static struct jr3_pci_poll_delay
420 jr3_pci_poll_subdevice(struct comedi_subdevice *s)
422 struct jr3_pci_subdev_private *spriv = s->private;
423 struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);
424 struct jr3_sensor __iomem *sensor;
430 sensor = spriv->sensor;
431 errors = get_u16(&sensor->errors);
433 if (errors != spriv->errors)
434 spriv->errors = errors;
436 /* Sensor communication lost? force poll mode */
437 if (errors & (watch_dog | watch_dog2 | sensor_change))
438 spriv->state = state_jr3_poll;
440 switch (spriv->state) {
442 model_no = get_u16(&sensor->model_no);
443 serial_no = get_u16(&sensor->serial_no);
445 if ((errors & (watch_dog | watch_dog2)) ||
446 model_no == 0 || serial_no == 0) {
448 * Still no sensor, keep on polling.
449 * Since it takes up to 10 seconds for offsets to
450 * stabilize, polling each second should suffice.
454 spriv->state = state_jr3_init_wait_for_offset;
457 case state_jr3_init_wait_for_offset:
459 if (spriv->retries < 10) {
461 * Wait for offeset to stabilize
462 * (< 10 s according to manual)
465 struct jr3_pci_transform transf;
467 spriv->model_no = get_u16(&sensor->model_no);
468 spriv->serial_no = get_u16(&sensor->serial_no);
470 /* Transformation all zeros */
471 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
472 transf.link[i].link_type = (enum link_types)0;
473 transf.link[i].link_amount = 0;
476 set_transforms(sensor, &transf, 0);
477 use_transform(sensor, 0);
478 spriv->state = state_jr3_init_transform_complete;
479 /* Allow 20 ms for completion */
480 result = poll_delay_min_max(20, 100);
483 case state_jr3_init_transform_complete:
484 if (!is_complete(sensor)) {
485 result = poll_delay_min_max(20, 100);
488 struct six_axis_t max_full_scale;
490 max_full_scale = get_max_full_scales(sensor);
491 set_full_scales(sensor, max_full_scale);
493 spriv->state = state_jr3_init_set_full_scale_complete;
494 /* Allow 20 ms for completion */
495 result = poll_delay_min_max(20, 100);
498 case state_jr3_init_set_full_scale_complete:
499 if (!is_complete(sensor)) {
500 result = poll_delay_min_max(20, 100);
502 struct force_array __iomem *fs = &sensor->full_scale;
503 union jr3_pci_single_range *r = spriv->range;
505 /* Use ranges in kN or we will overflow around 2000N! */
506 r[0].l.range[0].min = -get_s16(&fs->fx) * 1000;
507 r[0].l.range[0].max = get_s16(&fs->fx) * 1000;
508 r[1].l.range[0].min = -get_s16(&fs->fy) * 1000;
509 r[1].l.range[0].max = get_s16(&fs->fy) * 1000;
510 r[2].l.range[0].min = -get_s16(&fs->fz) * 1000;
511 r[2].l.range[0].max = get_s16(&fs->fz) * 1000;
512 r[3].l.range[0].min = -get_s16(&fs->mx) * 100;
513 r[3].l.range[0].max = get_s16(&fs->mx) * 100;
514 r[4].l.range[0].min = -get_s16(&fs->my) * 100;
515 r[4].l.range[0].max = get_s16(&fs->my) * 100;
516 r[5].l.range[0].min = -get_s16(&fs->mz) * 100;
517 /* the next five are questionable */
518 r[5].l.range[0].max = get_s16(&fs->mz) * 100;
519 r[6].l.range[0].min = -get_s16(&fs->v1) * 100;
520 r[6].l.range[0].max = get_s16(&fs->v1) * 100;
521 r[7].l.range[0].min = -get_s16(&fs->v2) * 100;
522 r[7].l.range[0].max = get_s16(&fs->v2) * 100;
523 r[8].l.range[0].min = 0;
524 r[8].l.range[0].max = 65535;
526 use_offset(sensor, 0);
527 spriv->state = state_jr3_init_use_offset_complete;
528 /* Allow 40 ms for completion */
529 result = poll_delay_min_max(40, 100);
532 case state_jr3_init_use_offset_complete:
533 if (!is_complete(sensor)) {
534 result = poll_delay_min_max(20, 100);
536 set_s16(&sensor->offsets.fx, 0);
537 set_s16(&sensor->offsets.fy, 0);
538 set_s16(&sensor->offsets.fz, 0);
539 set_s16(&sensor->offsets.mx, 0);
540 set_s16(&sensor->offsets.my, 0);
541 set_s16(&sensor->offsets.mz, 0);
545 spriv->state = state_jr3_done;
549 result = poll_delay_min_max(10000, 20000);
558 static void jr3_pci_poll_dev(struct timer_list *t)
560 struct jr3_pci_dev_private *devpriv = from_timer(devpriv, t, timer);
561 struct comedi_device *dev = devpriv->dev;
562 struct jr3_pci_subdev_private *spriv;
563 struct comedi_subdevice *s;
569 spin_lock_irqsave(&dev->spinlock, flags);
573 /* Poll all sensors that are ready to be polled */
574 for (i = 0; i < dev->n_subdevices; i++) {
575 s = &dev->subdevices[i];
578 if (time_after_eq(now, spriv->next_time_min)) {
579 struct jr3_pci_poll_delay sub_delay;
581 sub_delay = jr3_pci_poll_subdevice(s);
583 spriv->next_time_min = jiffies +
584 msecs_to_jiffies(sub_delay.min);
586 if (sub_delay.max && sub_delay.max < delay)
588 * Wake up as late as possible ->
589 * poll as many sensors as possible at once.
591 delay = sub_delay.max;
594 spin_unlock_irqrestore(&dev->spinlock, flags);
596 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
597 add_timer(&devpriv->timer);
600 static struct jr3_pci_subdev_private *
601 jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s)
603 struct jr3_block __iomem *block = dev->mmio;
604 struct jr3_pci_subdev_private *spriv;
608 spriv = comedi_alloc_spriv(s, sizeof(*spriv));
612 spriv->sensor = &block[s->index].sensor;
614 for (j = 0; j < 8; j++) {
615 spriv->range[j].l.length = 1;
616 spriv->range[j].l.range[0].min = -1000000;
617 spriv->range[j].l.range[0].max = 1000000;
619 for (k = 0; k < 7; k++) {
620 spriv->range_table_list[j + k * 8] = &spriv->range[j].l;
621 spriv->maxdata_list[j + k * 8] = 0x7fff;
624 spriv->range[8].l.length = 1;
625 spriv->range[8].l.range[0].min = 0;
626 spriv->range[8].l.range[0].max = 65535;
628 spriv->range_table_list[56] = &spriv->range[8].l;
629 spriv->range_table_list[57] = &spriv->range[8].l;
630 spriv->maxdata_list[56] = 0xffff;
631 spriv->maxdata_list[57] = 0xffff;
636 static void jr3_pci_show_copyright(struct comedi_device *dev)
638 struct jr3_block __iomem *block = dev->mmio;
639 struct jr3_sensor __iomem *sensor0 = &block[0].sensor;
640 char copy[ARRAY_SIZE(sensor0->copyright) + 1];
643 for (i = 0; i < ARRAY_SIZE(sensor0->copyright); i++)
644 copy[i] = (char)(get_u16(&sensor0->copyright[i]) >> 8);
646 dev_dbg(dev->class_dev, "Firmware copyright: %s\n", copy);
649 static int jr3_pci_auto_attach(struct comedi_device *dev,
650 unsigned long context)
652 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
653 static const struct jr3_pci_board *board;
654 struct jr3_pci_dev_private *devpriv;
655 struct jr3_pci_subdev_private *spriv;
656 struct jr3_block __iomem *block;
657 struct comedi_subdevice *s;
661 BUILD_BUG_ON(sizeof(struct jr3_block) != 0x80000);
663 if (context < ARRAY_SIZE(jr3_pci_boards))
664 board = &jr3_pci_boards[context];
667 dev->board_ptr = board;
668 dev->board_name = board->name;
670 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
674 ret = comedi_pci_enable(dev);
678 if (pci_resource_len(pcidev, 0) < board->n_subdevs * sizeof(*block))
681 dev->mmio = pci_ioremap_bar(pcidev, 0);
687 ret = comedi_alloc_subdevices(dev, board->n_subdevs);
691 dev->open = jr3_pci_open;
692 for (i = 0; i < dev->n_subdevices; i++) {
693 s = &dev->subdevices[i];
694 s->type = COMEDI_SUBD_AI;
695 s->subdev_flags = SDF_READABLE | SDF_GROUND;
696 s->n_chan = 8 * 7 + 2;
697 s->insn_read = jr3_pci_ai_insn_read;
699 spriv = jr3_pci_alloc_spriv(dev, s);
703 /* Channel specific range and maxdata */
704 s->range_table_list = spriv->range_table_list;
705 s->maxdata_list = spriv->maxdata_list;
709 for (i = 0; i < dev->n_subdevices; i++)
710 writel(0, &block[i].reset);
712 ret = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
714 jr3_download_firmware, 0);
715 dev_dbg(dev->class_dev, "Firmware load %d\n", ret);
719 * TODO: use firmware to load preferred offset tables. Suggested
721 * model serial Fx Fy Fz Mx My Mz\n
723 * comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
724 * "comedi/jr3_offsets_table",
725 * jr3_download_firmware, 1);
729 * It takes a few milliseconds for software to settle as much as we
730 * can read firmware version
732 msleep_interruptible(25);
733 jr3_pci_show_copyright(dev);
735 /* Start card timer */
736 for (i = 0; i < dev->n_subdevices; i++) {
737 s = &dev->subdevices[i];
740 spriv->next_time_min = jiffies + msecs_to_jiffies(500);
744 timer_setup(&devpriv->timer, jr3_pci_poll_dev, 0);
745 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
746 add_timer(&devpriv->timer);
751 static void jr3_pci_detach(struct comedi_device *dev)
753 struct jr3_pci_dev_private *devpriv = dev->private;
756 del_timer_sync(&devpriv->timer);
758 comedi_pci_detach(dev);
761 static struct comedi_driver jr3_pci_driver = {
762 .driver_name = "jr3_pci",
763 .module = THIS_MODULE,
764 .auto_attach = jr3_pci_auto_attach,
765 .detach = jr3_pci_detach,
768 static int jr3_pci_pci_probe(struct pci_dev *dev,
769 const struct pci_device_id *id)
771 return comedi_pci_auto_config(dev, &jr3_pci_driver, id->driver_data);
774 static const struct pci_device_id jr3_pci_pci_table[] = {
775 { PCI_VDEVICE(JR3, 0x1111), BOARD_JR3_1 },
776 { PCI_VDEVICE(JR3, 0x3111), BOARD_JR3_1 },
777 { PCI_VDEVICE(JR3, 0x3112), BOARD_JR3_2 },
778 { PCI_VDEVICE(JR3, 0x3113), BOARD_JR3_3 },
779 { PCI_VDEVICE(JR3, 0x3114), BOARD_JR3_4 },
782 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
784 static struct pci_driver jr3_pci_pci_driver = {
786 .id_table = jr3_pci_pci_table,
787 .probe = jr3_pci_pci_probe,
788 .remove = comedi_pci_auto_unconfig,
790 module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
792 MODULE_AUTHOR("Comedi https://www.comedi.org");
793 MODULE_DESCRIPTION("Comedi driver for JR3/PCI force sensor board");
794 MODULE_LICENSE("GPL");