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