drivers/comedi/drivers/jr3_pci.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * comedi/drivers/jr3_pci.c
   4  * hardware driver for JR3/PCI force sensor board
   5  *
   6  * COMEDI - Linux Control and Measurement Device Interface
   7  * Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
   8  */
   9 /*
  10  * Driver: jr3_pci
  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
  14  * Status: works
  15  * Devices: [JR3] PCI force sensor board (jr3_pci)
  16  *
  17  * Configuration options:
  18  *   None
  19  *
  20  * Manual configuration of comedi devices is not supported by this
  21  * driver; supported PCI devices are configured as comedi devices
  22  * automatically.
  23  *
  24  * The DSP on the board requires initialization code, which can be
  25  * loaded by placing it in /lib/firmware/comedi.  The initialization
  26  * code should be somewhere on the media you got with your card.  One
  27  * version is available from https://www.comedi.org in the
  28  * comedi_nonfree_firmware tarball.  The file is called "jr3pci.idm".
  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
  45 enum jr3_pci_boardid {
  46         BOARD_JR3_1,
  47         BOARD_JR3_2,
  48         BOARD_JR3_3,
  49         BOARD_JR3_4,
  50 };
  51
  52 struct jr3_pci_board {
  53         const char *name;
  54         int n_subdevs;
  55 };
  56
  57 static 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
  76 struct jr3_pci_transform {
  77         struct {
  78                 u16 link_type;
  79                 s16 link_amount;
  80         } link[8];
  81 };
  82
  83 struct jr3_pci_poll_delay {
  84         int min;
  85         int max;
  86 };
  87
  88 struct jr3_pci_dev_private {
  89         struct timer_list timer;
  90         struct comedi_device *dev;
  91 };
  92
  93 union jr3_pci_single_range {
  94         struct comedi_lrange l;
  95         char _reserved[offsetof(struct comedi_lrange, range[1])];
  96 };
  97
  98 enum 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
 107 struct 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
 120 static 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
 129 static int is_complete(struct jr3_sensor __iomem *sensor)
 130 {
 131         return get_s16(&sensor->command_word0) == 0;
 132 }
 133
 134 static 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;          /* Make sure that 0 <= num <= 15 */
 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
 152 static 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
 158 static void use_offset(struct jr3_sensor __iomem *sensor, short offset_num)
 159 {
 160         set_s16(&sensor->command_word0, 0x0600 + (offset_num & 0x000f));
 161 }
 162
 163 static void set_offset(struct jr3_sensor __iomem *sensor)
 164 {
 165         set_s16(&sensor->command_word0, 0x0700);
 166 }
 167
 168 struct six_axis_t {
 169         s16 fx;
 170         s16 fy;
 171         s16 fz;
 172         s16 mx;
 173         s16 my;
 174         s16 mz;
 175 };
 176
 177 static 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
 189 static 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
 202 static 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
 252 static 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                 /* No sensor or sensor changed */
 266                 if (spriv->state == state_jr3_done) {
 267                         /* Restart polling */
 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
 279 static 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
 294 static 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                 /* Skip over non hex */
 302                 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++)
 303                         ;
 304                 /* Collect value */
 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
 319 static 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          * IDM file format is:
 327          *   { count, address, data <count> } *
 328          *   ffff
 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
 350 static 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                                 /* 16 bit data, never seen in real life!! */
 375                                 unsigned int data1 = 0;
 376
 377                                 more = more &&
 378                                        read_idm_word(data, size, &pos, &data1);
 379                                 count--;
 380                                 /* jr3[addr + 0x20000 * pnum] = data1; */
 381                         } else {
 382                                 /* Download 24 bit program */
 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
 406 static 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         /* verify IDM file format */
 414         ret = jr3_check_firmware(dev, data, size);
 415         if (ret)
 416                 return ret;
 417
 418         /* write firmware to each subdevice */
 419         for (subdev = 0; subdev < dev->n_subdevices; subdev++)
 420                 jr3_write_firmware(dev, subdev, data, size);
 421
 422         return 0;
 423 }
 424
 425 static struct jr3_pci_poll_delay
 426 jr3_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         /* Sensor communication lost? force poll mode */
 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                          * Still no sensor, keep on polling.
 455                          * Since it takes up to 10 seconds for offsets to
 456                          * stabilize, polling each second should suffice.
 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                          * Wait for offeset to stabilize
 468                          * (< 10 s according to manual)
 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                         /* Transformation all zeros */
 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                         /* Allow 20 ms for completion */
 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                         /* Set full scale */
 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                         /* Allow 20 ms for completion */
 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                         /* Use ranges in kN or we will overflow around 2000N! */
 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                         /* the next five are questionable */
 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                         /* Allow 40 ms for completion */
 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
 564 static 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         /* Poll all sensors that are ready to be polled */
 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                                  * Wake up as late as possible ->
 595                                  * poll as many sensors as possible at once.
 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
 606 static struct jr3_pci_subdev_private *
 607 jr3_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
 642 static 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
 655 static 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                 /* Channel specific range and maxdata */
 710                 s->range_table_list     = spriv->range_table_list;
 711                 s->maxdata_list         = spriv->maxdata_list;
 712         }
 713
 714         /* Reset DSP card */
 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          * TODO: use firmware to load preferred offset tables. Suggested
 726          * format:
 727          *     model serial Fx Fy Fz Mx My Mz\n
 728          *
 729          *     comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
 730          *                          "comedi/jr3_offsets_table",
 731          *                          jr3_download_firmware, 1);
 732          */
 733
 734         /*
 735          * It takes a few milliseconds for software to settle as much as we
 736          * can read firmware version
 737          */
 738         msleep_interruptible(25);
 739         jr3_pci_show_copyright(dev);
 740
 741         /* Start card timer */
 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
 757 static 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
 767 static 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
 774 static 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
 780 static 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 };
 788 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
 789
 790 static 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 };
 796 module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
 797
 798 MODULE_AUTHOR("Comedi https://www.comedi.org");
 799 MODULE_DESCRIPTION("Comedi driver for JR3/PCI force sensor board");
 800 MODULE_LICENSE("GPL");
 801 MODULE_FIRMWARE("comedi/jr3pci.idm");