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