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/pci.h>
43 #include <linux/delay.h>
44 #include <linux/ctype.h>
45 #include <linux/jiffies.h>
46 #include <linux/slab.h>
47 #include <linux/timer.h>
49 #include "../comedidev.h"
53 #define PCI_VENDOR_ID_JR3 0x1762
55 enum jr3_pci_boardid {
62 struct jr3_pci_board {
67 static const struct jr3_pci_board jr3_pci_boards[] = {
86 struct jr3_pci_transform {
93 struct jr3_pci_poll_delay {
98 struct jr3_pci_dev_private {
99 struct jr3_t __iomem *iobase;
100 struct timer_list timer;
103 struct jr3_pci_subdev_private {
104 struct jr3_channel __iomem *channel;
105 unsigned long next_time_min;
106 unsigned long next_time_max;
107 enum { state_jr3_poll,
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,
118 struct comedi_krange range;
120 const struct comedi_lrange *range_table_list[8 * 7 + 2];
121 unsigned int maxdata_list[8 * 7 + 2];
126 static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max)
128 struct jr3_pci_poll_delay result;
135 static int is_complete(struct jr3_channel __iomem *channel)
137 return get_s16(&channel->command_word0) == 0;
140 static void set_transforms(struct jr3_channel __iomem *channel,
141 struct jr3_pci_transform transf, short num)
145 num &= 0x000f; /* Make sure that 0 <= num <= 15 */
146 for (i = 0; i < 8; i++) {
147 set_u16(&channel->transforms[num].link[i].link_type,
148 transf.link[i].link_type);
150 set_s16(&channel->transforms[num].link[i].link_amount,
151 transf.link[i].link_amount);
153 if (transf.link[i].link_type == end_x_form)
158 static void use_transform(struct jr3_channel __iomem *channel,
161 set_s16(&channel->command_word0, 0x0500 + (transf_num & 0x000f));
164 static void use_offset(struct jr3_channel __iomem *channel, short offset_num)
166 set_s16(&channel->command_word0, 0x0600 + (offset_num & 0x000f));
169 static void set_offset(struct jr3_channel __iomem *channel)
171 set_s16(&channel->command_word0, 0x0700);
183 static void set_full_scales(struct jr3_channel __iomem *channel,
184 struct six_axis_t full_scale)
186 set_s16(&channel->full_scale.fx, full_scale.fx);
187 set_s16(&channel->full_scale.fy, full_scale.fy);
188 set_s16(&channel->full_scale.fz, full_scale.fz);
189 set_s16(&channel->full_scale.mx, full_scale.mx);
190 set_s16(&channel->full_scale.my, full_scale.my);
191 set_s16(&channel->full_scale.mz, full_scale.mz);
192 set_s16(&channel->command_word0, 0x0a00);
195 static struct six_axis_t get_min_full_scales(struct jr3_channel __iomem
198 struct six_axis_t result;
199 result.fx = get_s16(&channel->min_full_scale.fx);
200 result.fy = get_s16(&channel->min_full_scale.fy);
201 result.fz = get_s16(&channel->min_full_scale.fz);
202 result.mx = get_s16(&channel->min_full_scale.mx);
203 result.my = get_s16(&channel->min_full_scale.my);
204 result.mz = get_s16(&channel->min_full_scale.mz);
208 static struct six_axis_t get_max_full_scales(struct jr3_channel __iomem
211 struct six_axis_t result;
212 result.fx = get_s16(&channel->max_full_scale.fx);
213 result.fy = get_s16(&channel->max_full_scale.fy);
214 result.fz = get_s16(&channel->max_full_scale.fz);
215 result.mx = get_s16(&channel->max_full_scale.mx);
216 result.my = get_s16(&channel->max_full_scale.my);
217 result.mz = get_s16(&channel->max_full_scale.mz);
221 static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
222 struct comedi_subdevice *s,
225 struct jr3_pci_subdev_private *spriv = s->private;
226 unsigned int val = 0;
228 if (spriv->state != state_jr3_done)
232 unsigned int axis = chan % 8;
233 unsigned filter = chan / 8;
237 val = get_s16(&spriv->channel->filter[filter].fx);
240 val = get_s16(&spriv->channel->filter[filter].fy);
243 val = get_s16(&spriv->channel->filter[filter].fz);
246 val = get_s16(&spriv->channel->filter[filter].mx);
249 val = get_s16(&spriv->channel->filter[filter].my);
252 val = get_s16(&spriv->channel->filter[filter].mz);
255 val = get_s16(&spriv->channel->filter[filter].v1);
258 val = get_s16(&spriv->channel->filter[filter].v2);
262 } else if (chan == 56) {
263 val = get_u16(&spriv->channel->model_no);
264 } else if (chan == 57) {
265 val = get_u16(&spriv->channel->serial_no);
271 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
272 struct comedi_subdevice *s,
273 struct comedi_insn *insn,
276 struct jr3_pci_subdev_private *spriv = s->private;
277 unsigned int chan = CR_CHAN(insn->chanspec);
284 errors = get_u16(&spriv->channel->errors);
285 if (spriv->state != state_jr3_done ||
286 (errors & (watch_dog | watch_dog2 | sensor_change))) {
287 /* No sensor or sensor changed */
288 if (spriv->state == state_jr3_done) {
289 /* Restart polling */
290 spriv->state = state_jr3_poll;
295 for (i = 0; i < insn->n; i++)
296 data[i] = jr3_pci_ai_read_chan(dev, s, chan);
301 static int jr3_pci_open(struct comedi_device *dev)
303 struct jr3_pci_subdev_private *spriv;
304 struct comedi_subdevice *s;
307 dev_dbg(dev->class_dev, "jr3_pci_open\n");
308 for (i = 0; i < dev->n_subdevices; i++) {
309 s = &dev->subdevices[i];
312 dev_dbg(dev->class_dev, "serial: %p %d (%d)\n",
313 spriv, spriv->serial_no, s->index);
318 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)++) {
330 value = hex_to_bin(data[*pos]);
333 *val = (*val << 4) + value;
342 static int jr3_check_firmware(struct comedi_device *dev,
343 const u8 *data, size_t size)
349 * IDM file format is:
350 * { count, address, data <count> } *
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);
362 while (more && count > 0) {
363 unsigned int dummy = 0;
365 more = more && read_idm_word(data, size, &pos, &dummy);
373 static void jr3_write_firmware(struct comedi_device *dev,
374 int subdev, const u8 *data, size_t size)
376 struct jr3_pci_dev_private *devpriv = dev->private;
377 struct jr3_t __iomem *iobase = devpriv->iobase;
384 unsigned int count = 0;
385 unsigned int addr = 0;
387 more = more && read_idm_word(data, size, &pos, &count);
388 if (more && count == 0xffff)
391 more = more && read_idm_word(data, size, &pos, &addr);
393 dev_dbg(dev->class_dev, "Loading#%d %4.4x bytes at %4.4x\n",
394 subdev, count, addr);
396 while (more && count > 0) {
398 /* 16 bit data, never seen in real life!! */
399 unsigned int data1 = 0;
402 read_idm_word(data, size, &pos, &data1);
404 /* jr3[addr + 0x20000 * pnum] = data1; */
406 /* Download 24 bit program */
407 unsigned int data1 = 0;
408 unsigned int data2 = 0;
410 lo = &iobase->channel[subdev].program_lo[addr];
411 hi = &iobase->channel[subdev].program_hi[addr];
414 read_idm_word(data, size, &pos, &data1);
416 read_idm_word(data, size, &pos, &data2);
430 static int jr3_download_firmware(struct comedi_device *dev,
431 const u8 *data, size_t size,
432 unsigned long context)
437 /* verify IDM file format */
438 ret = jr3_check_firmware(dev, data, size);
442 /* write firmware to each subdevice */
443 for (subdev = 0; subdev < dev->n_subdevices; subdev++)
444 jr3_write_firmware(dev, subdev, data, size);
449 static struct jr3_pci_poll_delay jr3_pci_poll_subdevice(struct comedi_subdevice *s)
451 struct jr3_pci_subdev_private *spriv = s->private;
452 struct jr3_pci_poll_delay result = poll_delay_min_max(1000, 2000);
453 struct jr3_channel __iomem *channel;
462 channel = spriv->channel;
463 errors = get_u16(&channel->errors);
465 if (errors != spriv->errors)
466 spriv->errors = errors;
468 /* Sensor communication lost? force poll mode */
469 if (errors & (watch_dog | watch_dog2 | sensor_change))
470 spriv->state = state_jr3_poll;
472 switch (spriv->state) {
474 model_no = get_u16(&channel->model_no);
475 serial_no = get_u16(&channel->serial_no);
477 if ((errors & (watch_dog | watch_dog2)) ||
478 model_no == 0 || serial_no == 0) {
480 * Still no sensor, keep on polling.
481 * Since it takes up to 10 seconds for offsets to
482 * stabilize, polling each second should suffice.
486 spriv->state = state_jr3_init_wait_for_offset;
489 case state_jr3_init_wait_for_offset:
491 if (spriv->retries < 10) {
493 * Wait for offeset to stabilize
494 * (< 10 s according to manual)
497 struct jr3_pci_transform transf;
499 spriv->model_no = get_u16(&channel->model_no);
500 spriv->serial_no = get_u16(&channel->serial_no);
502 /* Transformation all zeros */
503 for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
504 transf.link[i].link_type = (enum link_types)0;
505 transf.link[i].link_amount = 0;
508 set_transforms(channel, transf, 0);
509 use_transform(channel, 0);
510 spriv->state = state_jr3_init_transform_complete;
511 /* Allow 20 ms for completion */
512 result = poll_delay_min_max(20, 100);
515 case state_jr3_init_transform_complete:
516 if (!is_complete(channel)) {
517 result = poll_delay_min_max(20, 100);
520 struct six_axis_t min_full_scale;
521 struct six_axis_t max_full_scale;
523 min_full_scale = get_min_full_scales(channel);
524 max_full_scale = get_max_full_scales(channel);
525 set_full_scales(channel, max_full_scale);
527 spriv->state = state_jr3_init_set_full_scale_complete;
528 /* Allow 20 ms for completion */
529 result = poll_delay_min_max(20, 100);
532 case state_jr3_init_set_full_scale_complete:
533 if (!is_complete(channel)) {
534 result = poll_delay_min_max(20, 100);
536 struct force_array __iomem *fs = &channel->full_scale;
538 /* Use ranges in kN or we will overflow around 2000N! */
539 spriv->range[0].range.min = -get_s16(&fs->fx) * 1000;
540 spriv->range[0].range.max = get_s16(&fs->fx) * 1000;
541 spriv->range[1].range.min = -get_s16(&fs->fy) * 1000;
542 spriv->range[1].range.max = get_s16(&fs->fy) * 1000;
543 spriv->range[2].range.min = -get_s16(&fs->fz) * 1000;
544 spriv->range[2].range.max = get_s16(&fs->fz) * 1000;
545 spriv->range[3].range.min = -get_s16(&fs->mx) * 100;
546 spriv->range[3].range.max = get_s16(&fs->mx) * 100;
547 spriv->range[4].range.min = -get_s16(&fs->my) * 100;
548 spriv->range[4].range.max = get_s16(&fs->my) * 100;
549 spriv->range[5].range.min = -get_s16(&fs->mz) * 100;
550 /* the next five are questionable */
551 spriv->range[5].range.max = get_s16(&fs->mz) * 100;
552 spriv->range[6].range.min = -get_s16(&fs->v1) * 100;
553 spriv->range[6].range.max = get_s16(&fs->v1) * 100;
554 spriv->range[7].range.min = -get_s16(&fs->v2) * 100;
555 spriv->range[7].range.max = get_s16(&fs->v2) * 100;
556 spriv->range[8].range.min = 0;
557 spriv->range[8].range.max = 65535;
559 use_offset(channel, 0);
560 spriv->state = state_jr3_init_use_offset_complete;
561 /* Allow 40 ms for completion */
562 result = poll_delay_min_max(40, 100);
565 case state_jr3_init_use_offset_complete:
566 if (!is_complete(channel)) {
567 result = poll_delay_min_max(20, 100);
569 set_s16(&channel->offsets.fx, 0);
570 set_s16(&channel->offsets.fy, 0);
571 set_s16(&channel->offsets.fz, 0);
572 set_s16(&channel->offsets.mx, 0);
573 set_s16(&channel->offsets.my, 0);
574 set_s16(&channel->offsets.mz, 0);
578 spriv->state = state_jr3_done;
582 result = poll_delay_min_max(10000, 20000);
591 static void jr3_pci_poll_dev(unsigned long data)
593 struct comedi_device *dev = (struct comedi_device *)data;
594 struct jr3_pci_dev_private *devpriv = dev->private;
595 struct jr3_pci_subdev_private *spriv;
596 struct comedi_subdevice *s;
602 spin_lock_irqsave(&dev->spinlock, flags);
606 /* Poll all channels that are ready to be polled */
607 for (i = 0; i < dev->n_subdevices; i++) {
608 s = &dev->subdevices[i];
611 if (now > spriv->next_time_min) {
612 struct jr3_pci_poll_delay sub_delay;
614 sub_delay = jr3_pci_poll_subdevice(s);
616 spriv->next_time_min = jiffies +
617 msecs_to_jiffies(sub_delay.min);
618 spriv->next_time_max = jiffies +
619 msecs_to_jiffies(sub_delay.max);
621 if (sub_delay.max && sub_delay.max < delay)
623 * Wake up as late as possible ->
624 * poll as many channels as possible at once.
626 delay = sub_delay.max;
629 spin_unlock_irqrestore(&dev->spinlock, flags);
631 devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
632 add_timer(&devpriv->timer);
635 static struct jr3_pci_subdev_private *
636 jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s)
638 struct jr3_pci_dev_private *devpriv = dev->private;
639 struct jr3_pci_subdev_private *spriv;
643 spriv = comedi_alloc_spriv(s, sizeof(*spriv));
647 spriv->channel = &devpriv->iobase->channel[s->index].data;
649 for (j = 0; j < 8; j++) {
650 spriv->range[j].length = 1;
651 spriv->range[j].range.min = -1000000;
652 spriv->range[j].range.max = 1000000;
654 for (k = 0; k < 7; k++) {
655 spriv->range_table_list[j + k * 8] =
656 (struct comedi_lrange *)&spriv->range[j];
657 spriv->maxdata_list[j + k * 8] = 0x7fff;
660 spriv->range[8].length = 1;
661 spriv->range[8].range.min = 0;
662 spriv->range[8].range.max = 65536;
664 spriv->range_table_list[56] = (struct comedi_lrange *)&spriv->range[8];
665 spriv->range_table_list[57] = (struct comedi_lrange *)&spriv->range[8];
666 spriv->maxdata_list[56] = 0xffff;
667 spriv->maxdata_list[57] = 0xffff;
669 dev_dbg(dev->class_dev, "p->channel %p %p (%tx)\n",
670 spriv->channel, devpriv->iobase,
671 ((char __iomem *)spriv->channel -
672 (char __iomem *)devpriv->iobase));
677 static int jr3_pci_auto_attach(struct comedi_device *dev,
678 unsigned long context)
680 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
681 static const struct jr3_pci_board *board = NULL;
682 struct jr3_pci_dev_private *devpriv;
683 struct jr3_pci_subdev_private *spriv;
684 struct comedi_subdevice *s;
688 if (sizeof(struct jr3_channel) != 0xc00) {
689 dev_err(dev->class_dev,
690 "sizeof(struct jr3_channel) = %x [expected %x]\n",
691 (unsigned)sizeof(struct jr3_channel), 0xc00);
695 if (context < ARRAY_SIZE(jr3_pci_boards))
696 board = &jr3_pci_boards[context];
699 dev->board_ptr = board;
700 dev->board_name = board->name;
702 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
706 init_timer(&devpriv->timer);
708 ret = comedi_pci_enable(dev);
712 devpriv->iobase = pci_ioremap_bar(pcidev, 0);
713 if (!devpriv->iobase)
716 ret = comedi_alloc_subdevices(dev, board->n_subdevs);
720 dev->open = jr3_pci_open;
721 for (i = 0; i < dev->n_subdevices; i++) {
722 s = &dev->subdevices[i];
723 s->type = COMEDI_SUBD_AI;
724 s->subdev_flags = SDF_READABLE | SDF_GROUND;
725 s->n_chan = 8 * 7 + 2;
726 s->insn_read = jr3_pci_ai_insn_read;
728 spriv = jr3_pci_alloc_spriv(dev, s);
730 /* Channel specific range and maxdata */
731 s->range_table_list = spriv->range_table_list;
732 s->maxdata_list = spriv->maxdata_list;
737 writel(0, &devpriv->iobase->channel[0].reset);
739 ret = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
741 jr3_download_firmware, 0);
742 dev_dbg(dev->class_dev, "Firmare load %d\n", ret);
746 * TODO: use firmware to load preferred offset tables. Suggested
748 * model serial Fx Fy Fz Mx My Mz\n
750 * comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
751 * "comedi/jr3_offsets_table",
752 * jr3_download_firmware, 1);
756 * It takes a few milliseconds for software to settle as much as we
757 * can read firmware version
759 msleep_interruptible(25);
760 for (i = 0; i < 0x18; i++) {
761 dev_dbg(dev->class_dev, "%c\n",
762 get_u16(&devpriv->iobase->channel[0].
763 data.copyright[i]) >> 8);
766 /* Start card timer */
767 for (i = 0; i < dev->n_subdevices; i++) {
768 s = &dev->subdevices[i];
771 spriv->next_time_min = jiffies + msecs_to_jiffies(500);
772 spriv->next_time_max = jiffies + msecs_to_jiffies(2000);
775 devpriv->timer.data = (unsigned long)dev;
776 devpriv->timer.function = jr3_pci_poll_dev;
777 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
778 add_timer(&devpriv->timer);
783 static void jr3_pci_detach(struct comedi_device *dev)
785 struct jr3_pci_dev_private *devpriv = dev->private;
788 del_timer_sync(&devpriv->timer);
791 iounmap(devpriv->iobase);
793 comedi_pci_disable(dev);
796 static struct comedi_driver jr3_pci_driver = {
797 .driver_name = "jr3_pci",
798 .module = THIS_MODULE,
799 .auto_attach = jr3_pci_auto_attach,
800 .detach = jr3_pci_detach,
803 static int jr3_pci_pci_probe(struct pci_dev *dev,
804 const struct pci_device_id *id)
806 return comedi_pci_auto_config(dev, &jr3_pci_driver, id->driver_data);
809 static const struct pci_device_id jr3_pci_pci_table[] = {
810 { PCI_VDEVICE(JR3, 0x1111), BOARD_JR3_1 },
811 { PCI_VDEVICE(JR3, 0x3111), BOARD_JR3_1 },
812 { PCI_VDEVICE(JR3, 0x3112), BOARD_JR3_2 },
813 { PCI_VDEVICE(JR3, 0x3113), BOARD_JR3_3 },
814 { PCI_VDEVICE(JR3, 0x3114), BOARD_JR3_4 },
817 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
819 static struct pci_driver jr3_pci_pci_driver = {
821 .id_table = jr3_pci_pci_table,
822 .probe = jr3_pci_pci_probe,
823 .remove = comedi_pci_auto_unconfig,
825 module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
827 MODULE_AUTHOR("Comedi http://www.comedi.org");
828 MODULE_DESCRIPTION("Comedi low-level driver");
829 MODULE_LICENSE("GPL");
830 MODULE_FIRMWARE("comedi/jr3pci.idm");