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 /*(DEBLOBBED)*/
  25
  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>
  34
  35 #include "jr3_pci.h"
  36
  37 #define PCI_VENDOR_ID_JR3 0x1762
  38
  39 enum jr3_pci_boardid {
  40         BOARD_JR3_1,
  41         BOARD_JR3_2,
  42         BOARD_JR3_3,
  43         BOARD_JR3_4,
  44 };
  45
  46 struct jr3_pci_board {
  47         const char *name;
  48         int n_subdevs;
  49 };
  50
  51 static const struct jr3_pci_board jr3_pci_boards[] = {
  52         [BOARD_JR3_1] = {
  53                 .name           = "jr3_pci_1",
  54                 .n_subdevs      = 1,
  55         },
  56         [BOARD_JR3_2] = {
  57                 .name           = "jr3_pci_2",
  58                 .n_subdevs      = 2,
  59         },
  60         [BOARD_JR3_3] = {
  61                 .name           = "jr3_pci_3",
  62                 .n_subdevs      = 3,
  63         },
  64         [BOARD_JR3_4] = {
  65                 .name           = "jr3_pci_4",
  66                 .n_subdevs      = 4,
  67         },
  68 };
  69
  70 struct jr3_pci_transform {
  71         struct {
  72                 u16 link_type;
  73                 s16 link_amount;
  74         } link[8];
  75 };
  76
  77 struct jr3_pci_poll_delay {
  78         int min;
  79         int max;
  80 };
  81
  82 struct jr3_pci_dev_private {
  83         struct timer_list timer;
  84         struct comedi_device *dev;
  85 };
  86
  87 union jr3_pci_single_range {
  88         struct comedi_lrange l;
  89         char _reserved[offsetof(struct comedi_lrange, range[1])];
  90 };
  91
  92 enum jr3_pci_poll_state {
  93         state_jr3_poll,
  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,
  98         state_jr3_done
  99 };
 100
 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;
 105         int serial_no;
 106         int model_no;
 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];
 110         u16 errors;
 111         int retries;
 112 };
 113
 114 static struct jr3_pci_poll_delay poll_delay_min_max(int min, int max)
 115 {
 116         struct jr3_pci_poll_delay result;
 117
 118         result.min = min;
 119         result.max = max;
 120         return result;
 121 }
 122
 123 static int is_complete(struct jr3_sensor __iomem *sensor)
 124 {
 125         return get_s16(&sensor->command_word0) == 0;
 126 }
 127
 128 static void set_transforms(struct jr3_sensor __iomem *sensor,
 129                            const struct jr3_pci_transform *transf, short num)
 130 {
 131         int i;
 132
 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);
 137                 udelay(1);
 138                 set_s16(&sensor->transforms[num].link[i].link_amount,
 139                         transf->link[i].link_amount);
 140                 udelay(1);
 141                 if (transf->link[i].link_type == end_x_form)
 142                         break;
 143         }
 144 }
 145
 146 static void use_transform(struct jr3_sensor __iomem *sensor,
 147                           short transf_num)
 148 {
 149         set_s16(&sensor->command_word0, 0x0500 + (transf_num & 0x000f));
 150 }
 151
 152 static void use_offset(struct jr3_sensor __iomem *sensor, short offset_num)
 153 {
 154         set_s16(&sensor->command_word0, 0x0600 + (offset_num & 0x000f));
 155 }
 156
 157 static void set_offset(struct jr3_sensor __iomem *sensor)
 158 {
 159         set_s16(&sensor->command_word0, 0x0700);
 160 }
 161
 162 struct six_axis_t {
 163         s16 fx;
 164         s16 fy;
 165         s16 fz;
 166         s16 mx;
 167         s16 my;
 168         s16 mz;
 169 };
 170
 171 static void set_full_scales(struct jr3_sensor __iomem *sensor,
 172                             struct six_axis_t full_scale)
 173 {
 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);
 181 }
 182
 183 static struct six_axis_t get_max_full_scales(struct jr3_sensor __iomem *sensor)
 184 {
 185         struct six_axis_t result;
 186
 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);
 193         return result;
 194 }
 195
 196 static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
 197                                          struct comedi_subdevice *s,
 198                                          unsigned int chan)
 199 {
 200         struct jr3_pci_subdev_private *spriv = s->private;
 201         unsigned int val = 0;
 202
 203         if (spriv->state != state_jr3_done)
 204                 return 0;
 205
 206         if (chan < 56) {
 207                 unsigned int axis = chan % 8;
 208                 unsigned int filter = chan / 8;
 209
 210                 switch (axis) {
 211                 case 0:
 212                         val = get_s16(&spriv->sensor->filter[filter].fx);
 213                         break;
 214                 case 1:
 215                         val = get_s16(&spriv->sensor->filter[filter].fy);
 216                         break;
 217                 case 2:
 218                         val = get_s16(&spriv->sensor->filter[filter].fz);
 219                         break;
 220                 case 3:
 221                         val = get_s16(&spriv->sensor->filter[filter].mx);
 222                         break;
 223                 case 4:
 224                         val = get_s16(&spriv->sensor->filter[filter].my);
 225                         break;
 226                 case 5:
 227                         val = get_s16(&spriv->sensor->filter[filter].mz);
 228                         break;
 229                 case 6:
 230                         val = get_s16(&spriv->sensor->filter[filter].v1);
 231                         break;
 232                 case 7:
 233                         val = get_s16(&spriv->sensor->filter[filter].v2);
 234                         break;
 235                 }
 236                 val += 0x4000;
 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);
 241         }
 242
 243         return val;
 244 }
 245
 246 static int jr3_pci_ai_insn_read(struct comedi_device *dev,
 247                                 struct comedi_subdevice *s,
 248                                 struct comedi_insn *insn,
 249                                 unsigned int *data)
 250 {
 251         struct jr3_pci_subdev_private *spriv = s->private;
 252         unsigned int chan = CR_CHAN(insn->chanspec);
 253         u16 errors;
 254         int i;
 255
 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;
 263                 }
 264                 return -EAGAIN;
 265         }
 266
 267         for (i = 0; i < insn->n; i++)
 268                 data[i] = jr3_pci_ai_read_chan(dev, s, chan);
 269
 270         return insn->n;
 271 }
 272
 273 static int jr3_pci_open(struct comedi_device *dev)
 274 {
 275         struct jr3_pci_subdev_private *spriv;
 276         struct comedi_subdevice *s;
 277         int i;
 278
 279         for (i = 0; i < dev->n_subdevices; i++) {
 280                 s = &dev->subdevices[i];
 281                 spriv = s->private;
 282                 dev_dbg(dev->class_dev, "serial[%d]: %d\n", s->index,
 283                         spriv->serial_no);
 284         }
 285         return 0;
 286 }
 287
 288 static int read_idm_word(const u8 *data, size_t size, int *pos,
 289                          unsigned int *val)
 290 {
 291         int result = 0;
 292         int value;
 293
 294         if (pos && val) {
 295                 /* Skip over non hex */
 296                 for (; *pos < size && !isxdigit(data[*pos]); (*pos)++)
 297                         ;
 298                 /* Collect value */
 299                 *val = 0;
 300                 for (; *pos < size; (*pos)++) {
 301                         value = hex_to_bin(data[*pos]);
 302                         if (value >= 0) {
 303                                 result = 1;
 304                                 *val = (*val << 4) + value;
 305                         } else {
 306                                 break;
 307                         }
 308                 }
 309         }
 310         return result;
 311 }
 312
 313 static int jr3_check_firmware(struct comedi_device *dev,
 314                               const u8 *data, size_t size)
 315 {
 316         int more = 1;
 317         int pos = 0;
 318
 319         /*
 320          * IDM file format is:
 321          *   { count, address, data <count> } *
 322          *   ffff
 323          */
 324         while (more) {
 325                 unsigned int count = 0;
 326                 unsigned int addr = 0;
 327
 328                 more = more && read_idm_word(data, size, &pos, &count);
 329                 if (more && count == 0xffff)
 330                         return 0;
 331
 332                 more = more && read_idm_word(data, size, &pos, &addr);
 333                 while (more && count > 0) {
 334                         unsigned int dummy = 0;
 335
 336                         more = more && read_idm_word(data, size, &pos, &dummy);
 337                         count--;
 338                 }
 339         }
 340
 341         return -ENODATA;
 342 }
 343
 344 static void jr3_write_firmware(struct comedi_device *dev,
 345                                int subdev, const u8 *data, size_t size)
 346 {
 347         struct jr3_block __iomem *block = dev->mmio;
 348         u32 __iomem *lo;
 349         u32 __iomem *hi;
 350         int more = 1;
 351         int pos = 0;
 352
 353         while (more) {
 354                 unsigned int count = 0;
 355                 unsigned int addr = 0;
 356
 357                 more = more && read_idm_word(data, size, &pos, &count);
 358                 if (more && count == 0xffff)
 359                         return;
 360
 361                 more = more && read_idm_word(data, size, &pos, &addr);
 362
 363                 dev_dbg(dev->class_dev, "Loading#%d %4.4x bytes at %4.4x\n",
 364                         subdev, count, addr);
 365
 366                 while (more && count > 0) {
 367                         if (addr & 0x4000) {
 368                                 /* 16 bit data, never seen in real life!! */
 369                                 unsigned int data1 = 0;
 370
 371                                 more = more &&
 372                                        read_idm_word(data, size, &pos, &data1);
 373                                 count--;
 374                                 /* jr3[addr + 0x20000 * pnum] = data1; */
 375                         } else {
 376                                 /* Download 24 bit program */
 377                                 unsigned int data1 = 0;
 378                                 unsigned int data2 = 0;
 379
 380                                 lo = &block[subdev].program_lo[addr];
 381                                 hi = &block[subdev].program_hi[addr];
 382
 383                                 more = more &&
 384                                        read_idm_word(data, size, &pos, &data1);
 385                                 more = more &&
 386                                        read_idm_word(data, size, &pos, &data2);
 387                                 count -= 2;
 388                                 if (more) {
 389                                         set_u16(lo, data1);
 390                                         udelay(1);
 391                                         set_u16(hi, data2);
 392                                         udelay(1);
 393                                 }
 394                         }
 395                         addr++;
 396                 }
 397         }
 398 }
 399
 400 static int jr3_download_firmware(struct comedi_device *dev,
 401                                  const u8 *data, size_t size,
 402                                  unsigned long context)
 403 {
 404         int subdev;
 405         int ret;
 406
 407         /* verify IDM file format */
 408         ret = jr3_check_firmware(dev, data, size);
 409         if (ret)
 410                 return ret;
 411
 412         /* write firmware to each subdevice */
 413         for (subdev = 0; subdev < dev->n_subdevices; subdev++)
 414                 jr3_write_firmware(dev, subdev, data, size);
 415
 416         return 0;
 417 }
 418
 419 static struct jr3_pci_poll_delay
 420 jr3_pci_poll_subdevice(struct comedi_subdevice *s)
 421 {
 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;
 425         u16 model_no;
 426         u16 serial_no;
 427         int errors;
 428         int i;
 429
 430         sensor = spriv->sensor;
 431         errors = get_u16(&sensor->errors);
 432
 433         if (errors != spriv->errors)
 434                 spriv->errors = errors;
 435
 436         /* Sensor communication lost? force poll mode */
 437         if (errors & (watch_dog | watch_dog2 | sensor_change))
 438                 spriv->state = state_jr3_poll;
 439
 440         switch (spriv->state) {
 441         case state_jr3_poll:
 442                 model_no = get_u16(&sensor->model_no);
 443                 serial_no = get_u16(&sensor->serial_no);
 444
 445                 if ((errors & (watch_dog | watch_dog2)) ||
 446                     model_no == 0 || serial_no == 0) {
 447                         /*
 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.
 451                          */
 452                 } else {
 453                         spriv->retries = 0;
 454                         spriv->state = state_jr3_init_wait_for_offset;
 455                 }
 456                 break;
 457         case state_jr3_init_wait_for_offset:
 458                 spriv->retries++;
 459                 if (spriv->retries < 10) {
 460                         /*
 461                          * Wait for offeset to stabilize
 462                          * (< 10 s according to manual)
 463                          */
 464                 } else {
 465                         struct jr3_pci_transform transf;
 466
 467                         spriv->model_no = get_u16(&sensor->model_no);
 468                         spriv->serial_no = get_u16(&sensor->serial_no);
 469
 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;
 474                         }
 475
 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);
 481                 }
 482                 break;
 483         case state_jr3_init_transform_complete:
 484                 if (!is_complete(sensor)) {
 485                         result = poll_delay_min_max(20, 100);
 486                 } else {
 487                         /* Set full scale */
 488                         struct six_axis_t max_full_scale;
 489
 490                         max_full_scale = get_max_full_scales(sensor);
 491                         set_full_scales(sensor, max_full_scale);
 492
 493                         spriv->state = state_jr3_init_set_full_scale_complete;
 494                         /* Allow 20 ms for completion */
 495                         result = poll_delay_min_max(20, 100);
 496                 }
 497                 break;
 498         case state_jr3_init_set_full_scale_complete:
 499                 if (!is_complete(sensor)) {
 500                         result = poll_delay_min_max(20, 100);
 501                 } else {
 502                         struct force_array __iomem *fs = &sensor->full_scale;
 503                         union jr3_pci_single_range *r = spriv->range;
 504
 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;
 525
 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);
 530                 }
 531                 break;
 532         case state_jr3_init_use_offset_complete:
 533                 if (!is_complete(sensor)) {
 534                         result = poll_delay_min_max(20, 100);
 535                 } else {
 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);
 542
 543                         set_offset(sensor);
 544
 545                         spriv->state = state_jr3_done;
 546                 }
 547                 break;
 548         case state_jr3_done:
 549                 result = poll_delay_min_max(10000, 20000);
 550                 break;
 551         default:
 552                 break;
 553         }
 554
 555         return result;
 556 }
 557
 558 static void jr3_pci_poll_dev(struct timer_list *t)
 559 {
 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;
 564         unsigned long flags;
 565         unsigned long now;
 566         int delay;
 567         int i;
 568
 569         spin_lock_irqsave(&dev->spinlock, flags);
 570         delay = 1000;
 571         now = jiffies;
 572
 573         /* Poll all sensors that are ready to be polled */
 574         for (i = 0; i < dev->n_subdevices; i++) {
 575                 s = &dev->subdevices[i];
 576                 spriv = s->private;
 577
 578                 if (time_after_eq(now, spriv->next_time_min)) {
 579                         struct jr3_pci_poll_delay sub_delay;
 580
 581                         sub_delay = jr3_pci_poll_subdevice(s);
 582
 583                         spriv->next_time_min = jiffies +
 584                                                msecs_to_jiffies(sub_delay.min);
 585
 586                         if (sub_delay.max && sub_delay.max < delay)
 587                                 /*
 588                                  * Wake up as late as possible ->
 589                                  * poll as many sensors as possible at once.
 590                                  */
 591                                 delay = sub_delay.max;
 592                 }
 593         }
 594         spin_unlock_irqrestore(&dev->spinlock, flags);
 595
 596         devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
 597         add_timer(&devpriv->timer);
 598 }
 599
 600 static struct jr3_pci_subdev_private *
 601 jr3_pci_alloc_spriv(struct comedi_device *dev, struct comedi_subdevice *s)
 602 {
 603         struct jr3_block __iomem *block = dev->mmio;
 604         struct jr3_pci_subdev_private *spriv;
 605         int j;
 606         int k;
 607
 608         spriv = comedi_alloc_spriv(s, sizeof(*spriv));
 609         if (!spriv)
 610                 return NULL;
 611
 612         spriv->sensor = &block[s->index].sensor;
 613
 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;
 618
 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;
 622                 }
 623         }
 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;
 627
 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;
 632
 633         return spriv;
 634 }
 635
 636 static void jr3_pci_show_copyright(struct comedi_device *dev)
 637 {
 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];
 641         int i;
 642
 643         for (i = 0; i < ARRAY_SIZE(sensor0->copyright); i++)
 644                 copy[i] = (char)(get_u16(&sensor0->copyright[i]) >> 8);
 645         copy[i] = '\0';
 646         dev_dbg(dev->class_dev, "Firmware copyright: %s\n", copy);
 647 }
 648
 649 static int jr3_pci_auto_attach(struct comedi_device *dev,
 650                                unsigned long context)
 651 {
 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;
 658         int ret;
 659         int i;
 660
 661         BUILD_BUG_ON(sizeof(struct jr3_block) != 0x80000);
 662
 663         if (context < ARRAY_SIZE(jr3_pci_boards))
 664                 board = &jr3_pci_boards[context];
 665         if (!board)
 666                 return -ENODEV;
 667         dev->board_ptr = board;
 668         dev->board_name = board->name;
 669
 670         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
 671         if (!devpriv)
 672                 return -ENOMEM;
 673
 674         ret = comedi_pci_enable(dev);
 675         if (ret)
 676                 return ret;
 677
 678         if (pci_resource_len(pcidev, 0) < board->n_subdevs * sizeof(*block))
 679                 return -ENXIO;
 680
 681         dev->mmio = pci_ioremap_bar(pcidev, 0);
 682         if (!dev->mmio)
 683                 return -ENOMEM;
 684
 685         block = dev->mmio;
 686
 687         ret = comedi_alloc_subdevices(dev, board->n_subdevs);
 688         if (ret)
 689                 return ret;
 690
 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;
 698
 699                 spriv = jr3_pci_alloc_spriv(dev, s);
 700                 if (!spriv)
 701                         return -ENOMEM;
 702
 703                 /* Channel specific range and maxdata */
 704                 s->range_table_list     = spriv->range_table_list;
 705                 s->maxdata_list         = spriv->maxdata_list;
 706         }
 707
 708         /* Reset DSP card */
 709         for (i = 0; i < dev->n_subdevices; i++)
 710                 writel(0, &block[i].reset);
 711
 712         ret = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
 713                                    "/*(DEBLOBBED)*/",
 714                                    jr3_download_firmware, 0);
 715         dev_dbg(dev->class_dev, "Firmware load %d\n", ret);
 716         if (ret < 0)
 717                 return ret;
 718         /*
 719          * TODO: use firmware to load preferred offset tables. Suggested
 720          * format:
 721          *     model serial Fx Fy Fz Mx My Mz\n
 722          *
 723          *     comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
 724          *                          "comedi/jr3_offsets_table",
 725          *                          jr3_download_firmware, 1);
 726          */
 727
 728         /*
 729          * It takes a few milliseconds for software to settle as much as we
 730          * can read firmware version
 731          */
 732         msleep_interruptible(25);
 733         jr3_pci_show_copyright(dev);
 734
 735         /* Start card timer */
 736         for (i = 0; i < dev->n_subdevices; i++) {
 737                 s = &dev->subdevices[i];
 738                 spriv = s->private;
 739
 740                 spriv->next_time_min = jiffies + msecs_to_jiffies(500);
 741         }
 742
 743         devpriv->dev = dev;
 744         timer_setup(&devpriv->timer, jr3_pci_poll_dev, 0);
 745         devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
 746         add_timer(&devpriv->timer);
 747
 748         return 0;
 749 }
 750
 751 static void jr3_pci_detach(struct comedi_device *dev)
 752 {
 753         struct jr3_pci_dev_private *devpriv = dev->private;
 754
 755         if (devpriv)
 756                 del_timer_sync(&devpriv->timer);
 757
 758         comedi_pci_detach(dev);
 759 }
 760
 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,
 766 };
 767
 768 static int jr3_pci_pci_probe(struct pci_dev *dev,
 769                              const struct pci_device_id *id)
 770 {
 771         return comedi_pci_auto_config(dev, &jr3_pci_driver, id->driver_data);
 772 }
 773
 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 },
 780         { 0 }
 781 };
 782 MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
 783
 784 static struct pci_driver jr3_pci_pci_driver = {
 785         .name           = "jr3_pci",
 786         .id_table       = jr3_pci_pci_table,
 787         .probe          = jr3_pci_pci_probe,
 788         .remove         = comedi_pci_auto_unconfig,
 789 };
 790 module_comedi_pci_driver(jr3_pci_driver, jr3_pci_pci_driver);
 791
 792 MODULE_AUTHOR("Comedi https://www.comedi.org");
 793 MODULE_DESCRIPTION("Comedi driver for JR3/PCI force sensor board");
 794 MODULE_LICENSE("GPL");
 795 /*(DEBLOBBED)*/