drivers/staging/comedi/drivers/dt2801.c

   1 /*
   2  * comedi/drivers/dt2801.c
   3  * Device Driver for DataTranslation DT2801
   4  *
   5  */
   6 /*
   7 Driver: dt2801
   8 Description: Data Translation DT2801 series and DT01-EZ
   9 Author: ds
  10 Status: works
  11 Devices: [Data Translation] DT2801 (dt2801), DT2801-A, DT2801/5716A,
  12   DT2805, DT2805/5716A, DT2808, DT2818, DT2809, DT01-EZ
  13
  14 This driver can autoprobe the type of board.
  15
  16 Configuration options:
  17   [0] - I/O port base address
  18   [1] - unused
  19   [2] - A/D reference 0=differential, 1=single-ended
  20   [3] - A/D range
  21           0 = [-10, 10]
  22           1 = [0,10]
  23   [4] - D/A 0 range
  24           0 = [-10, 10]
  25           1 = [-5,5]
  26           2 = [-2.5,2.5]
  27           3 = [0,10]
  28           4 = [0,5]
  29   [5] - D/A 1 range (same choices)
  30 */
  31
  32 #include <linux/module.h>
  33 #include "../comedidev.h"
  34 #include <linux/delay.h>
  35
  36 #define DT2801_TIMEOUT 1000
  37
  38 /* Hardware Configuration */
  39 /* ====================== */
  40
  41 #define DT2801_MAX_DMA_SIZE (64 * 1024)
  42
  43 /* define's */
  44 /* ====================== */
  45
  46 /* Commands */
  47 #define DT_C_RESET       0x0
  48 #define DT_C_CLEAR_ERR   0x1
  49 #define DT_C_READ_ERRREG 0x2
  50 #define DT_C_SET_CLOCK   0x3
  51
  52 #define DT_C_TEST        0xb
  53 #define DT_C_STOP        0xf
  54
  55 #define DT_C_SET_DIGIN   0x4
  56 #define DT_C_SET_DIGOUT  0x5
  57 #define DT_C_READ_DIG    0x6
  58 #define DT_C_WRITE_DIG   0x7
  59
  60 #define DT_C_WRITE_DAIM  0x8
  61 #define DT_C_SET_DA      0x9
  62 #define DT_C_WRITE_DA    0xa
  63
  64 #define DT_C_READ_ADIM   0xc
  65 #define DT_C_SET_AD      0xd
  66 #define DT_C_READ_AD     0xe
  67
  68 /* Command modifiers (only used with read/write), EXTTRIG can be
  69    used with some other commands.
  70 */
  71 #define DT_MOD_DMA     (1<<4)
  72 #define DT_MOD_CONT    (1<<5)
  73 #define DT_MOD_EXTCLK  (1<<6)
  74 #define DT_MOD_EXTTRIG (1<<7)
  75
  76 /* Bits in status register */
  77 #define DT_S_DATA_OUT_READY   (1<<0)
  78 #define DT_S_DATA_IN_FULL     (1<<1)
  79 #define DT_S_READY            (1<<2)
  80 #define DT_S_COMMAND          (1<<3)
  81 #define DT_S_COMPOSITE_ERROR  (1<<7)
  82
  83 /* registers */
  84 #define DT2801_DATA             0
  85 #define DT2801_STATUS           1
  86 #define DT2801_CMD              1
  87
  88 #if 0
  89 /* ignore 'defined but not used' warning */
  90 static const struct comedi_lrange range_dt2801_ai_pgh_bipolar = {
  91         4, {
  92                 BIP_RANGE(10),
  93                 BIP_RANGE(5),
  94                 BIP_RANGE(2.5),
  95                 BIP_RANGE(1.25)
  96         }
  97 };
  98 #endif
  99 static const struct comedi_lrange range_dt2801_ai_pgl_bipolar = {
 100         4, {
 101                 BIP_RANGE(10),
 102                 BIP_RANGE(1),
 103                 BIP_RANGE(0.1),
 104                 BIP_RANGE(0.02)
 105         }
 106 };
 107
 108 #if 0
 109 /* ignore 'defined but not used' warning */
 110 static const struct comedi_lrange range_dt2801_ai_pgh_unipolar = {
 111         4, {
 112                 UNI_RANGE(10),
 113                 UNI_RANGE(5),
 114                 UNI_RANGE(2.5),
 115                 UNI_RANGE(1.25)
 116         }
 117 };
 118 #endif
 119 static const struct comedi_lrange range_dt2801_ai_pgl_unipolar = {
 120         4, {
 121                 UNI_RANGE(10),
 122                 UNI_RANGE(1),
 123                 UNI_RANGE(0.1),
 124                 UNI_RANGE(0.02)
 125         }
 126 };
 127
 128 struct dt2801_board {
 129
 130         const char *name;
 131         int boardcode;
 132         int ad_diff;
 133         int ad_chan;
 134         int adbits;
 135         int adrangetype;
 136         int dabits;
 137 };
 138
 139 /* Typeid's for the different boards of the DT2801-series
 140    (taken from the test-software, that comes with the board)
 141    */
 142 static const struct dt2801_board boardtypes[] = {
 143         {
 144          .name = "dt2801",
 145          .boardcode = 0x09,
 146          .ad_diff = 2,
 147          .ad_chan = 16,
 148          .adbits = 12,
 149          .adrangetype = 0,
 150          .dabits = 12},
 151         {
 152          .name = "dt2801-a",
 153          .boardcode = 0x52,
 154          .ad_diff = 2,
 155          .ad_chan = 16,
 156          .adbits = 12,
 157          .adrangetype = 0,
 158          .dabits = 12},
 159         {
 160          .name = "dt2801/5716a",
 161          .boardcode = 0x82,
 162          .ad_diff = 1,
 163          .ad_chan = 16,
 164          .adbits = 16,
 165          .adrangetype = 1,
 166          .dabits = 12},
 167         {
 168          .name = "dt2805",
 169          .boardcode = 0x12,
 170          .ad_diff = 1,
 171          .ad_chan = 16,
 172          .adbits = 12,
 173          .adrangetype = 0,
 174          .dabits = 12},
 175         {
 176          .name = "dt2805/5716a",
 177          .boardcode = 0x92,
 178          .ad_diff = 1,
 179          .ad_chan = 16,
 180          .adbits = 16,
 181          .adrangetype = 1,
 182          .dabits = 12},
 183         {
 184          .name = "dt2808",
 185          .boardcode = 0x20,
 186          .ad_diff = 0,
 187          .ad_chan = 16,
 188          .adbits = 12,
 189          .adrangetype = 2,
 190          .dabits = 8},
 191         {
 192          .name = "dt2818",
 193          .boardcode = 0xa2,
 194          .ad_diff = 0,
 195          .ad_chan = 4,
 196          .adbits = 12,
 197          .adrangetype = 0,
 198          .dabits = 12},
 199         {
 200          .name = "dt2809",
 201          .boardcode = 0xb0,
 202          .ad_diff = 0,
 203          .ad_chan = 8,
 204          .adbits = 12,
 205          .adrangetype = 1,
 206          .dabits = 12},
 207 };
 208
 209 struct dt2801_private {
 210         const struct comedi_lrange *dac_range_types[2];
 211 };
 212
 213 /* These are the low-level routines:
 214    writecommand: write a command to the board
 215    writedata: write data byte
 216    readdata: read data byte
 217  */
 218
 219 /* Only checks DataOutReady-flag, not the Ready-flag as it is done
 220    in the examples of the manual. I don't see why this should be
 221    necessary. */
 222 static int dt2801_readdata(struct comedi_device *dev, int *data)
 223 {
 224         int stat = 0;
 225         int timeout = DT2801_TIMEOUT;
 226
 227         do {
 228                 stat = inb_p(dev->iobase + DT2801_STATUS);
 229                 if (stat & (DT_S_COMPOSITE_ERROR | DT_S_READY))
 230                         return stat;
 231                 if (stat & DT_S_DATA_OUT_READY) {
 232                         *data = inb_p(dev->iobase + DT2801_DATA);
 233                         return 0;
 234                 }
 235         } while (--timeout > 0);
 236
 237         return -ETIME;
 238 }
 239
 240 static int dt2801_readdata2(struct comedi_device *dev, int *data)
 241 {
 242         int lb = 0;
 243         int hb = 0;
 244         int ret;
 245
 246         ret = dt2801_readdata(dev, &lb);
 247         if (ret)
 248                 return ret;
 249         ret = dt2801_readdata(dev, &hb);
 250         if (ret)
 251                 return ret;
 252
 253         *data = (hb << 8) + lb;
 254         return 0;
 255 }
 256
 257 static int dt2801_writedata(struct comedi_device *dev, unsigned int data)
 258 {
 259         int stat = 0;
 260         int timeout = DT2801_TIMEOUT;
 261
 262         do {
 263                 stat = inb_p(dev->iobase + DT2801_STATUS);
 264
 265                 if (stat & DT_S_COMPOSITE_ERROR)
 266                         return stat;
 267                 if (!(stat & DT_S_DATA_IN_FULL)) {
 268                         outb_p(data & 0xff, dev->iobase + DT2801_DATA);
 269                         return 0;
 270                 }
 271         } while (--timeout > 0);
 272
 273         return -ETIME;
 274 }
 275
 276 static int dt2801_writedata2(struct comedi_device *dev, unsigned int data)
 277 {
 278         int ret;
 279
 280         ret = dt2801_writedata(dev, data & 0xff);
 281         if (ret < 0)
 282                 return ret;
 283         ret = dt2801_writedata(dev, (data >> 8));
 284         if (ret < 0)
 285                 return ret;
 286
 287         return 0;
 288 }
 289
 290 static int dt2801_wait_for_ready(struct comedi_device *dev)
 291 {
 292         int timeout = DT2801_TIMEOUT;
 293         int stat;
 294
 295         stat = inb_p(dev->iobase + DT2801_STATUS);
 296         if (stat & DT_S_READY)
 297                 return 0;
 298         do {
 299                 stat = inb_p(dev->iobase + DT2801_STATUS);
 300
 301                 if (stat & DT_S_COMPOSITE_ERROR)
 302                         return stat;
 303                 if (stat & DT_S_READY)
 304                         return 0;
 305         } while (--timeout > 0);
 306
 307         return -ETIME;
 308 }
 309
 310 static void dt2801_writecmd(struct comedi_device *dev, int command)
 311 {
 312         int stat;
 313
 314         dt2801_wait_for_ready(dev);
 315
 316         stat = inb_p(dev->iobase + DT2801_STATUS);
 317         if (stat & DT_S_COMPOSITE_ERROR) {
 318                 dev_dbg(dev->class_dev,
 319                         "composite-error in %s, ignoring\n", __func__);
 320         }
 321         if (!(stat & DT_S_READY))
 322                 dev_dbg(dev->class_dev, "!ready in %s, ignoring\n", __func__);
 323         outb_p(command, dev->iobase + DT2801_CMD);
 324 }
 325
 326 static int dt2801_reset(struct comedi_device *dev)
 327 {
 328         int board_code = 0;
 329         unsigned int stat;
 330         int timeout;
 331
 332         /* pull random data from data port */
 333         inb_p(dev->iobase + DT2801_DATA);
 334         inb_p(dev->iobase + DT2801_DATA);
 335         inb_p(dev->iobase + DT2801_DATA);
 336         inb_p(dev->iobase + DT2801_DATA);
 337
 338         /* dt2801_writecmd(dev,DT_C_STOP); */
 339         outb_p(DT_C_STOP, dev->iobase + DT2801_CMD);
 340
 341         /* dt2801_wait_for_ready(dev); */
 342         udelay(100);
 343         timeout = 10000;
 344         do {
 345                 stat = inb_p(dev->iobase + DT2801_STATUS);
 346                 if (stat & DT_S_READY)
 347                         break;
 348         } while (timeout--);
 349         if (!timeout)
 350                 dev_dbg(dev->class_dev, "timeout 1 status=0x%02x\n", stat);
 351
 352         /* dt2801_readdata(dev,&board_code); */
 353
 354         outb_p(DT_C_RESET, dev->iobase + DT2801_CMD);
 355         /* dt2801_writecmd(dev,DT_C_RESET); */
 356
 357         udelay(100);
 358         timeout = 10000;
 359         do {
 360                 stat = inb_p(dev->iobase + DT2801_STATUS);
 361                 if (stat & DT_S_READY)
 362                         break;
 363         } while (timeout--);
 364         if (!timeout)
 365                 dev_dbg(dev->class_dev, "timeout 2 status=0x%02x\n", stat);
 366
 367         dt2801_readdata(dev, &board_code);
 368
 369         return board_code;
 370 }
 371
 372 static int probe_number_of_ai_chans(struct comedi_device *dev)
 373 {
 374         int n_chans;
 375         int stat;
 376         int data;
 377
 378         for (n_chans = 0; n_chans < 16; n_chans++) {
 379                 dt2801_writecmd(dev, DT_C_READ_ADIM);
 380                 dt2801_writedata(dev, 0);
 381                 dt2801_writedata(dev, n_chans);
 382                 stat = dt2801_readdata2(dev, &data);
 383
 384                 if (stat)
 385                         break;
 386         }
 387
 388         dt2801_reset(dev);
 389         dt2801_reset(dev);
 390
 391         return n_chans;
 392 }
 393
 394 static const struct comedi_lrange *dac_range_table[] = {
 395         &range_bipolar10,
 396         &range_bipolar5,
 397         &range_bipolar2_5,
 398         &range_unipolar10,
 399         &range_unipolar5
 400 };
 401
 402 static const struct comedi_lrange *dac_range_lkup(int opt)
 403 {
 404         if (opt < 0 || opt >= 5)
 405                 return &range_unknown;
 406         return dac_range_table[opt];
 407 }
 408
 409 static const struct comedi_lrange *ai_range_lkup(int type, int opt)
 410 {
 411         switch (type) {
 412         case 0:
 413                 return (opt) ?
 414                     &range_dt2801_ai_pgl_unipolar :
 415                     &range_dt2801_ai_pgl_bipolar;
 416         case 1:
 417                 return (opt) ? &range_unipolar10 : &range_bipolar10;
 418         case 2:
 419                 return &range_unipolar5;
 420         }
 421         return &range_unknown;
 422 }
 423
 424 static int dt2801_error(struct comedi_device *dev, int stat)
 425 {
 426         if (stat < 0) {
 427                 if (stat == -ETIME)
 428                         dev_dbg(dev->class_dev, "timeout\n");
 429                 else
 430                         dev_dbg(dev->class_dev, "error %d\n", stat);
 431                 return stat;
 432         }
 433         dev_dbg(dev->class_dev, "error status 0x%02x, resetting...\n", stat);
 434
 435         dt2801_reset(dev);
 436         dt2801_reset(dev);
 437
 438         return -EIO;
 439 }
 440
 441 static int dt2801_ai_insn_read(struct comedi_device *dev,
 442                                struct comedi_subdevice *s,
 443                                struct comedi_insn *insn, unsigned int *data)
 444 {
 445         int d;
 446         int stat;
 447         int i;
 448
 449         for (i = 0; i < insn->n; i++) {
 450                 dt2801_writecmd(dev, DT_C_READ_ADIM);
 451                 dt2801_writedata(dev, CR_RANGE(insn->chanspec));
 452                 dt2801_writedata(dev, CR_CHAN(insn->chanspec));
 453                 stat = dt2801_readdata2(dev, &d);
 454
 455                 if (stat != 0)
 456                         return dt2801_error(dev, stat);
 457
 458                 data[i] = d;
 459         }
 460
 461         return i;
 462 }
 463
 464 static int dt2801_ao_insn_write(struct comedi_device *dev,
 465                                 struct comedi_subdevice *s,
 466                                 struct comedi_insn *insn,
 467                                 unsigned int *data)
 468 {
 469         unsigned int chan = CR_CHAN(insn->chanspec);
 470
 471         dt2801_writecmd(dev, DT_C_WRITE_DAIM);
 472         dt2801_writedata(dev, chan);
 473         dt2801_writedata2(dev, data[0]);
 474
 475         s->readback[chan] = data[0];
 476
 477         return 1;
 478 }
 479
 480 static int dt2801_dio_insn_bits(struct comedi_device *dev,
 481                                 struct comedi_subdevice *s,
 482                                 struct comedi_insn *insn,
 483                                 unsigned int *data)
 484 {
 485         int which = (s == &dev->subdevices[3]) ? 1 : 0;
 486         unsigned int val = 0;
 487
 488         if (comedi_dio_update_state(s, data)) {
 489                 dt2801_writecmd(dev, DT_C_WRITE_DIG);
 490                 dt2801_writedata(dev, which);
 491                 dt2801_writedata(dev, s->state);
 492         }
 493
 494         dt2801_writecmd(dev, DT_C_READ_DIG);
 495         dt2801_writedata(dev, which);
 496         dt2801_readdata(dev, &val);
 497
 498         data[1] = val;
 499
 500         return insn->n;
 501 }
 502
 503 static int dt2801_dio_insn_config(struct comedi_device *dev,
 504                                   struct comedi_subdevice *s,
 505                                   struct comedi_insn *insn,
 506                                   unsigned int *data)
 507 {
 508         int ret;
 509
 510         ret = comedi_dio_insn_config(dev, s, insn, data, 0xff);
 511         if (ret)
 512                 return ret;
 513
 514         dt2801_writecmd(dev, s->io_bits ? DT_C_SET_DIGOUT : DT_C_SET_DIGIN);
 515         dt2801_writedata(dev, (s == &dev->subdevices[3]) ? 1 : 0);
 516
 517         return insn->n;
 518 }
 519
 520 /*
 521    options:
 522         [0] - i/o base
 523         [1] - unused
 524         [2] - a/d 0=differential, 1=single-ended
 525         [3] - a/d range 0=[-10,10], 1=[0,10]
 526         [4] - dac0 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
 527         [5] - dac1 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
 528 */
 529 static int dt2801_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 530 {
 531         const struct dt2801_board *board;
 532         struct dt2801_private *devpriv;
 533         struct comedi_subdevice *s;
 534         int board_code, type;
 535         int ret = 0;
 536         int n_ai_chans;
 537
 538         ret = comedi_request_region(dev, it->options[0], 0x2);
 539         if (ret)
 540                 return ret;
 541
 542         /* do some checking */
 543
 544         board_code = dt2801_reset(dev);
 545
 546         /* heh.  if it didn't work, try it again. */
 547         if (!board_code)
 548                 board_code = dt2801_reset(dev);
 549
 550         for (type = 0; type < ARRAY_SIZE(boardtypes); type++) {
 551                 if (boardtypes[type].boardcode == board_code)
 552                         goto havetype;
 553         }
 554         dev_dbg(dev->class_dev,
 555                 "unrecognized board code=0x%02x, contact author\n", board_code);
 556         type = 0;
 557
 558 havetype:
 559         dev->board_ptr = boardtypes + type;
 560         board = dev->board_ptr;
 561
 562         n_ai_chans = probe_number_of_ai_chans(dev);
 563
 564         ret = comedi_alloc_subdevices(dev, 4);
 565         if (ret)
 566                 goto out;
 567
 568         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
 569         if (!devpriv)
 570                 return -ENOMEM;
 571
 572         dev->board_name = board->name;
 573
 574         s = &dev->subdevices[0];
 575         /* ai subdevice */
 576         s->type = COMEDI_SUBD_AI;
 577         s->subdev_flags = SDF_READABLE | SDF_GROUND;
 578 #if 1
 579         s->n_chan = n_ai_chans;
 580 #else
 581         if (it->options[2])
 582                 s->n_chan = board->ad_chan;
 583         else
 584                 s->n_chan = board->ad_chan / 2;
 585 #endif
 586         s->maxdata = (1 << board->adbits) - 1;
 587         s->range_table = ai_range_lkup(board->adrangetype, it->options[3]);
 588         s->insn_read = dt2801_ai_insn_read;
 589
 590         s = &dev->subdevices[1];
 591         /* ao subdevice */
 592         s->type = COMEDI_SUBD_AO;
 593         s->subdev_flags = SDF_WRITABLE;
 594         s->n_chan = 2;
 595         s->maxdata = (1 << board->dabits) - 1;
 596         s->range_table_list = devpriv->dac_range_types;
 597         devpriv->dac_range_types[0] = dac_range_lkup(it->options[4]);
 598         devpriv->dac_range_types[1] = dac_range_lkup(it->options[5]);
 599         s->insn_write = dt2801_ao_insn_write;
 600         s->insn_read = comedi_readback_insn_read;
 601
 602         ret = comedi_alloc_subdev_readback(s);
 603         if (ret)
 604                 return ret;
 605
 606         s = &dev->subdevices[2];
 607         /* 1st digital subdevice */
 608         s->type = COMEDI_SUBD_DIO;
 609         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 610         s->n_chan = 8;
 611         s->maxdata = 1;
 612         s->range_table = &range_digital;
 613         s->insn_bits = dt2801_dio_insn_bits;
 614         s->insn_config = dt2801_dio_insn_config;
 615
 616         s = &dev->subdevices[3];
 617         /* 2nd digital subdevice */
 618         s->type = COMEDI_SUBD_DIO;
 619         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 620         s->n_chan = 8;
 621         s->maxdata = 1;
 622         s->range_table = &range_digital;
 623         s->insn_bits = dt2801_dio_insn_bits;
 624         s->insn_config = dt2801_dio_insn_config;
 625
 626         ret = 0;
 627 out:
 628         return ret;
 629 }
 630
 631 static struct comedi_driver dt2801_driver = {
 632         .driver_name    = "dt2801",
 633         .module         = THIS_MODULE,
 634         .attach         = dt2801_attach,
 635         .detach         = comedi_legacy_detach,
 636 };
 637 module_comedi_driver(dt2801_driver);
 638
 639 MODULE_AUTHOR("Comedi http://www.comedi.org");
 640 MODULE_DESCRIPTION("Comedi low-level driver");
 641 MODULE_LICENSE("GPL");