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.
20 * Description: JR3/PCI force sensor board
21 * Author: Anders Blomdell <anders.blomdell@control.lth.se>
22 * Updated: Thu, 01 Nov 2012 17:34:55 +0000
24 * Devices: [JR3] PCI force sensor board (jr3_pci)
26 * Configuration options:
29 * Manual configuration of comedi devices is not supported by this
30 * driver; supported PCI devices are configured as comedi devices
33 * The DSP on the board requires initialization code, which can be
34 * loaded by placing it in /lib/firmware/comedi. The initialization
35 * code should be somewhere on the media you got with your card. One
36 * version is available from http://www.comedi.org in the
37 * comedi_nonfree_firmware tarball. The file is called "jr3pci.idm".
40 #include <linux/kernel.h>
41 #include <linux/module.h>
42 #include <linux/delay.h>
43 #include <linux/ctype.h>
44 #include <linux/jiffies.h>
45 #include <linux/slab.h>
46 #include <linux/timer.h>
48 #include "../comedi_pci.h"
52 #define PCI_VENDOR_ID_JR3 0x1762
54 enum jr3_pci_boardid {
61 struct jr3_pci_board {
66 static const struct jr3_pci_board jr3_pci_boards[] = {
85 struct jr3_pci_transform {
92 struct jr3_pci_poll_delay {
97 struct jr3_pci_dev_private {
98 struct timer_list timer;
101 union jr3_pci_single_range {
102 struct comedi_lrange l;
103 char _reserved[offsetof(struct comedi_lrange, range[1])];
106 enum jr3_pci_poll_state {
108 state_jr3_init_wait_for_offset,
109 state_jr3_init_transform_complete,
110 state_jr3_init_set_full_scale_complete,
111 state_jr3_init_use_offset_complete,
115 struct jr3_pci_subdev_private {
116 struct jr3_sensor __iomem *sensor;
117 unsigned long next_time_min;
118 enum jr3_pci_poll_state state;
121 union jr3_pci_single_range range[9];
122 const struct comedi_lrange *range_table_list[8 * 7 + 2];
123 unsigned int maxdata_list[8 * 7 + 2];
128 static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max)
130 struct jr3_pci_poll_delay result;
137 static int is_complete(struct jr3_sensor __iomem *sensor)
139 return get_s16(&sensor->command_word0) == 0;
142 static void set_transforms(struct jr3_sensor __iomem *sensor,
143 const struct jr3_pci_transform *transf, short num)
147 num &= 0x000f; /* Make sure that 0 <= num <= 15 */
148 for (i = 0; i < 8; i++) {
149 set_u16(&sensor->transforms[num].link[i].link_type,
150 transf->link[i].link_type);
152 set_s16(&sensor->transforms[num].link[i].link_amount,
153 transf->link[i].link_amount);
155 if (transf->link[i].link_type == end_x_form)
160 static void use_transform(struct jr3_sensor __iomem *sensor,
163 set_s16(&sensor->command_word0, 0x0500 + (transf_num & 0x000f));
166 static void use_offset(struct jr3_sensor __iomem *sensor, short offset_num)
168 set_s16(&sensor->command_word0, 0x0600 + (offset_num & 0x000f));
171 static void set_offset(struct jr3_sensor __iomem *sensor)
173 set_s16(&sensor->command_word0, 0x0700);
185 static void set_full_scales(struct jr3_sensor __iomem *sensor,
186 struct six_axis_t full_scale)
188 set_s16(&sensor->full_scale.fx, full_scale.fx);
189 set_s16(&sensor->full_scale.fy, full_scale.fy);
190 set_s16(&sensor->full_scale.fz, full_scale.fz);
191 set_s16(&sensor->full_scale.mx, full_scale.mx);
192 set_s16(&sensor->full_scale.my, full_scale.my);
193 set_s16(&sensor->full_scale.mz, full_scale.mz);
194 set_s16(&sensor->command_word0, 0x0a00);
197 static struct six_axis_t get_min_full_scales(struct jr3_sensor __iomem *sensor)
199 struct six_axis_t result;
201 result.fx = get_s16(&sensor->min_full_scale.fx);
202 result.fy = get_s16(&sensor->min_full_scale.fy);
203 result.fz = get_s16(&sensor->min_full_scale.fz);
204 result.mx = get_s16(&sensor->min_full_scale.mx);
205 result.my = get_s16(&sensor->min_full_scale.my);
206 result.mz = get_s16(&sensor->min_full_scale.mz);
210 static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)
212 struct six_axis_t result;
214 result.fx = get_s16(&sensor->max_full_scale.fx);
215 result.fy = get_s16(&sensor->max_full_scale.fy);
216 result.fz = get_s16(&sensor->max_full_scale.fz);
217 result.mx = get_s16(&sensor->max_full_scale.mx);
218 result.my = get_s16(&sensor->max_full_scale.my);
219 result.mz = get_s16(&sensor->max_full_scale.mz);
223 static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
224 struct comedi_subdevice *s,
227 struct jr3_pci_subdev_private *spriv = s->private;
228 unsigned int val = 0;
230 if (spriv->state != state_jr3_done)
234 unsigned int axis = chan % 8;
235 unsigned int filter = chan / 8;
239 val = get_s16(&spriv->sensor->filter[filter].fx);
242 val = get_s16(&spriv->sensor->filter[filter].fy);
245 val = get_s16(&spriv->sensor->filter[filter].fz);
248 val = get_s16(&spriv->sensor->filter[filter].mx);
251 val = get_s16(&spriv->sensor->filter[filter].my);
254 val = get_s16(&spriv->sensor->filter[filter].mz);
257 val = get_s16(&spriv->sensor->filter[filter].v1);
260 val = get_s16(&spriv->sensor->filter[filter].v2);
264 } else if (chan == 56) {
265 val = get_u16(&spriv->sensor->model_no);
266 } else if (chan == 57) {
267 val = get_u16(&spriv->sensor->serial_no);
273 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
274 struct comedi_subdevice *s,
275 struct comedi_insn *insn,
278 struct jr3_pci_subdev_private *spriv = s->private;
279 unsigned int chan = CR_CHAN(insn->chanspec);
283 errors = get_u16(&spriv->sensor->errors);
284 if (spriv->state != state_jr3_done ||
285 (errors & (watch_dog | watch_dog2 | sensor_change))) {
286 /* No sensor or sensor changed */
287 if (spriv->state == state_jr3_done) {
288 /* Restart polling */
289 spriv->state = state_jr3_poll;
294 for (i = 0; i < insn->n; i++)
295 data[i] = jr3_pci_ai_read_chan(dev, s, chan);
300 static int jr3_pci_open(struct comedi_device *dev)
302 struct jr3_pci_subdev_private *spriv;
303 struct comedi_subdevice *s;
306 dev_dbg(dev->class_dev, "jr3_pci_open\n");
307 for (i = 0; i < dev->n_subdevices; i++) {
308 s = &dev->subdevices[i];
310 dev_dbg(dev->class_dev, "serial[%d]: %d\n", s->index,
316 static int read_idm_word(const u8 *data, size_t size, int *pos,
323 /* Skip over non hex */
324 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++)
328 for (; *pos < size; (*pos)++) {
329 value = hex_to_bin(data[*pos]);
332 *val = (*val << 4) + value;
341 static int jr3_check_firmware(struct comedi_device *dev,
342 const u8 *data, size_t size)
348 * IDM file format is:
349 * { count, address, data <count> } *
353 unsigned int count = 0;
354 unsigned int addr = 0;
356 more = more && read_idm_word(data, size, &pos, &count);
357 if (more && count == 0xffff)
360 more = more && read_idm_word(data, size, &pos, &addr);
361 while (more && count > 0) {
362 unsigned int dummy = 0;
364 more = more && read_idm_word(data, size, &pos, &dummy);
372 static void jr3_write_firmware(struct comedi_device *dev,
373 int subdev, const u8 *data, size_t size)
375 struct jr3_block __iomem *block = dev->mmio;
382 unsigned int count = 0;
383 unsigned int addr = 0;
385 more = more && read_idm_word(data, size, &pos, &count);
386 if (more && count == 0xffff)
389 more = more && read_idm_word(data, size, &pos, &addr);
391 dev_dbg(dev->class_dev, "Loading#%d %4.4x bytes at %4.4x\n",
392 subdev, count, addr);
394 while (more && count > 0) {
396 /* 16 bit data, never seen in real life!! */
397 unsigned int data1 = 0;
400 read_idm_word(data, size, &pos, &data1);
402 /* jr3[addr + 0x20000 * pnum] = data1; */
404 /* Download 24 bit program */
405 unsigned int data1 = 0;
406 unsigned int data2 = 0;
408 lo = &block[subdev].program_lo[addr];
409 hi = &block[subdev].program_hi[addr];
412 read_idm_word(data, size, &pos, &data1);
414 read_idm_word(data, size, &pos, &data2);
428 static int jr3_download_firmware(struct comedi_device *dev,
429 const u8 *data, size_t size,
430 unsigned long context)
435 /* verify IDM file format */
436 ret = jr3_check_firmware(dev, data, size);
440 /* write firmware to each subdevice */
441 for (subdev = 0; subdev < dev->n_subdevices; subdev++)
442 jr3_write_firmware(dev, subdev, data, size);
447 static struct jr3_pci_poll_delay
448 jr3_pci_poll_subdevice(struct comedi_subdevice *s)
450 struct jr3_pci_subdev_private *spriv = s->private;
451 struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);
452 struct jr3_sensor __iomem *sensor;
458 sensor = spriv->sensor;
459 errors = get_u16(&sensor->errors);
461 if (errors != spriv->errors)
462 spriv->errors = errors;
464 /* Sensor communication lost? force poll mode */
465 if (errors & (watch_dog | watch_dog2 | sensor_change))
466 spriv->state = state_jr3_poll;
468 switch (spriv->state) {
470 model_no = get_u16(&sensor->model_no);
471 serial_no = get_u16(&sensor->serial_no);
473 if ((errors & (watch_dog | watch_dog2)) ||
474 model_no == 0 || serial_no == 0) {
476 * Still no sensor, keep on polling.
477 * Since it takes up to 10 seconds for offsets to
478 * stabilize, polling each second should suffice.
482 spriv->state = state_jr3_init_wait_for_offset;
485 case state_jr3_init_wait_for_offset:
487 if (spriv->retries < 10) {
489 * Wait for offeset to stabilize
490 * (< 10 s according to manual)
493 struct jr3_pci_transform transf;
495 spriv->model_no = get_u16(&sensor->model_no);
496 spriv->serial_no = get_u16(&sensor->serial_no);
498 /* Transformation all zeros */
499 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
500 transf.link[i].link_type = (enum link_types)0;
501 transf.link[i].link_amount = 0;
504 set_transforms(sensor, &transf, 0);
505 use_transform(sensor, 0);
506 spriv->state = state_jr3_init_transform_complete;
507 /* Allow 20 ms for completion */
508 result = poll_delay_min_max(20, 100);
511 case state_jr3_init_transform_complete:
512 if (!is_complete(sensor)) {
513 result = poll_delay_min_max(20, 100);
516 struct six_axis_t min_full_scale;
517 struct six_axis_t max_full_scale;
519 min_full_scale = get_min_full_scales(sensor);
520 max_full_scale = get_max_full_scales(sensor);
521 set_full_scales(sensor, max_full_scale);
523 spriv->state = state_jr3_init_set_full_scale_complete;
524 /* Allow 20 ms for completion */
525 result = poll_delay_min_max(20, 100);
528 case state_jr3_init_set_full_scale_complete:
529 if (!is_complete(sensor)) {
530 result = poll_delay_min_max(20, 100);
532 struct force_array __iomem *fs = &sensor->full_scale;
533 union jr3_pci_single_range *r = spriv->range;
535 /* Use ranges in kN or we will overflow around 2000N! */
536 r[0].l.range[0].min = -get_s16(&fs->fx) * 1000;
537 r[0].l.range[0].max = get_s16(&fs->fx) * 1000;
538 r[1].l.range[0].min = -get_s16(&fs->fy) * 1000;
539 r[1].l.range[0].max = get_s16(&fs->fy) * 1000;
540 r[2].l.range[0].min = -get_s16(&fs->fz) * 1000;
541 r[2].l.range[0].max = get_s16(&fs->fz) * 1000;
542 r[3].l.range[0].min = -get_s16(&fs->mx) * 100;
543 r[3].l.range[0].max = get_s16(&fs->mx) * 100;
544 r[4].l.range[0].min = -get_s16(&fs->my) * 100;
545 r[4].l.range[0].max = get_s16(&fs->my) * 100;
546 r[5].l.range[0].min = -get_s16(&fs->mz) * 100;
547 /* the next five are questionable */
548 r[5].l.range[0].max = get_s16(&fs->mz) * 100;
549 r[6].l.range[0].min = -get_s16(&fs->v1) * 100;
550 r[6].l.range[0].max = get_s16(&fs->v1) * 100;
551 r[7].l.range[0].min = -get_s16(&fs->v2) * 100;
552 r[7].l.range[0].max = get_s16(&fs->v2) * 100;
553 r[8].l.range[0].min = 0;
554 r[8].l.range[0].max = 65535;
556 use_offset(sensor, 0);
557 spriv->state = state_jr3_init_use_offset_complete;
558 /* Allow 40 ms for completion */
559 result = poll_delay_min_max(40, 100);
562 case state_jr3_init_use_offset_complete:
563 if (!is_complete(sensor)) {
564 result = poll_delay_min_max(20, 100);
566 set_s16(&sensor->offsets.fx, 0);
567 set_s16(&sensor->offsets.fy, 0);
568 set_s16(&sensor->offsets.fz, 0);
569 set_s16(&sensor->offsets.mx, 0);
570 set_s16(&sensor->offsets.my, 0);
571 set_s16(&sensor->offsets.mz, 0);
575 spriv->state = state_jr3_done;
579 result = poll_delay_min_max(10000, 20000);
588 static void jr3_pci_poll_dev(unsigned long data)
590 struct comedi_device *dev = (struct comedi_device *)data;
591 struct jr3_pci_dev_private *devpriv = dev->private;
592 struct jr3_pci_subdev_private *spriv;
593 struct comedi_subdevice *s;
599 spin_lock_irqsave(&dev->spinlock, flags);
603 /* Poll all sensors that are ready to be polled */
604 for (i = 0; i < dev->n_subdevices; i++) {
605 s = &dev->subdevices[i];
608 if (time_after_eq(now, spriv->next_time_min)) {
609 struct jr3_pci_poll_delay sub_delay;
611 sub_delay = jr3_pci_poll_subdevice(s);
613 spriv->next_time_min = jiffies +
614 msecs_to_jiffies(sub_delay.min);
616 if (sub_delay.max && sub_delay.max < delay)
618 * Wake up as late as possible ->
619 * poll as many sensors as possible at once.
621 delay = sub_delay.max;
624 spin_unlock_irqrestore(&dev->spinlock, flags);
626 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
627 add_timer(&devpriv->timer);
630 static struct jr3_pci_subdev_private *
631 jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s)
633 struct jr3_block __iomem *block = dev->mmio;
634 struct jr3_pci_subdev_private *spriv;
638 spriv = comedi_alloc_spriv(s, sizeof(*spriv));
642 spriv->sensor = &block[s->index].sensor;
644 for (j = 0; j < 8; j++) {
645 spriv->range[j].l.length = 1;
646 spriv->range[j].l.range[0].min = -1000000;
647 spriv->range[j].l.range[0].max = 1000000;
649 for (k = 0; k < 7; k++) {
650 spriv->range_table_list[j + k * 8] = &spriv->range[j].l;
651 spriv->maxdata_list[j + k * 8] = 0x7fff;
654 spriv->range[8].l.length = 1;
655 spriv->range[8].l.range[0].min = 0;
656 spriv->range[8].l.range[0].max = 65535;
658 spriv->range_table_list[56] = &spriv->range[8].l;
659 spriv->range_table_list[57] = &spriv->range[8].l;
660 spriv->maxdata_list[56] = 0xffff;
661 spriv->maxdata_list[57] = 0xffff;
666 static void jr3_pci_show_copyright(struct comedi_device *dev)
668 struct jr3_block __iomem *block = dev->mmio;
669 struct jr3_sensor __iomem *sensor0 = &block[0].sensor;
670 char copy[ARRAY_SIZE(sensor0->copyright) + 1];
673 for (i = 0; i < ARRAY_SIZE(sensor0->copyright); i++)
674 copy[i] = (char)(get_u16(&sensor0->copyright[i]) >> 8);
676 dev_dbg(dev->class_dev, "Firmware copyright: %s\n", copy);
679 static int jr3_pci_auto_attach(struct comedi_device *dev,
680 unsigned long context)
682 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
683 static const struct jr3_pci_board *board;
684 struct jr3_pci_dev_private *devpriv;
685 struct jr3_pci_subdev_private *spriv;
686 struct jr3_block __iomem *block;
687 struct comedi_subdevice *s;
691 BUILD_BUG_ON(sizeof(struct jr3_block) != 0x80000);
693 if (context < ARRAY_SIZE(jr3_pci_boards))
694 board = &jr3_pci_boards[context];
697 dev->board_ptr = board;
698 dev->board_name = board->name;
700 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
704 ret = comedi_pci_enable(dev);
708 if (pci_resource_len(pcidev, 0) < board->n_subdevs * sizeof(*block))
711 dev->mmio = pci_ioremap_bar(pcidev, 0);
717 ret = comedi_alloc_subdevices(dev, board->n_subdevs);
721 dev->open = jr3_pci_open;
722 for (i = 0; i < dev->n_subdevices; i++) {
723 s = &dev->subdevices[i];
724 s->type = COMEDI_SUBD_AI;
725 s->subdev_flags = SDF_READABLE | SDF_GROUND;
726 s->n_chan = 8 * 7 + 2;
727 s->insn_read = jr3_pci_ai_insn_read;
729 spriv = jr3_pci_alloc_spriv(dev, s);
733 /* Channel specific range and maxdata */
734 s->range_table_list = spriv->range_table_list;
735 s->maxdata_list = spriv->maxdata_list;
739 for (i = 0; i < dev->n_subdevices; i++)
740 writel(0, &block[i].reset);
742 ret = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
744 jr3_download_firmware, 0);
745 dev_dbg(dev->class_dev, "Firmware load %d\n", ret);
749 * TODO: use firmware to load preferred offset tables. Suggested
751 * model serial Fx Fy Fz Mx My Mz\n
753 * comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
754 * "comedi/jr3_offsets_table",
755 * jr3_download_firmware, 1);
759 * It takes a few milliseconds for software to settle as much as we
760 * can read firmware version
762 msleep_interruptible(25);
763 jr3_pci_show_copyright(dev);
765 /* Start card timer */
766 for (i = 0; i < dev->n_subdevices; i++) {
767 s = &dev->subdevices[i];
770 spriv->next_time_min = jiffies + msecs_to_jiffies(500);
773 setup_timer(&devpriv->timer, jr3_pci_poll_dev, (unsigned long)dev);
774 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
775 add_timer(&devpriv->timer);
780 static void jr3_pci_detach(struct comedi_device *dev)
782 struct jr3_pci_dev_private *devpriv = dev->private;
785 del_timer_sync(&devpriv->timer);
787 comedi_pci_detach(dev);
790 static struct comedi_driver jr3_pci_driver = {
791 .driver_name = "jr3_pci",
792 .module = THIS_MODULE,
793 .auto_attach = jr3_pci_auto_attach,
794 .detach = jr3_pci_detach,
797 static int jr3_pci_pci_probe(struct pci_dev *dev,
798 const struct pci_device_id *id)
800 return comedi_pci_auto_config(dev, &jr3_pci_driver, id->driver_data);
803 static const struct pci_device_id jr3_pci_pci_table[] = {
804 { PCI_VDEVICE(JR3, 0x1111), BOARD_JR3_1 },
805 { PCI_VDEVICE(JR3, 0x3111), BOARD_JR3_1 },
806 { PCI_VDEVICE(JR3, 0x3112), BOARD_JR3_2 },
807 { PCI_VDEVICE(JR3, 0x3113), BOARD_JR3_3 },
808 { PCI_VDEVICE(JR3, 0x3114), BOARD_JR3_4 },
811 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
813 static struct pci_driver jr3_pci_pci_driver = {
815 .id_table = jr3_pci_pci_table,
816 .probe = jr3_pci_pci_probe,
817 .remove = comedi_pci_auto_unconfig,
819 module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
821 MODULE_AUTHOR("Comedi http://www.comedi.org");
822 MODULE_DESCRIPTION("Comedi driver for JR3/PCI force sensor board");
823 MODULE_LICENSE("GPL");
824 MODULE_FIRMWARE("comedi/jr3pci.idm");