drivers/staging/comedi/drivers/jr3_pci.c

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