drivers/staging/comedi/drivers/pcl711.c

   1 /*
   2  * pcl711.c
   3  * Comedi driver for PC-LabCard PCL-711 and AdSys ACL-8112 and compatibles
   4  * Copyright (C) 1998 David A. Schleef <ds@schleef.org>
   5  *                    Janne Jalkanen <jalkanen@cs.hut.fi>
   6  *                    Eric Bunn <ebu@cs.hut.fi>
   7  *
   8  * COMEDI - Linux Control and Measurement Device Interface
   9  * Copyright (C) 1998 David A. Schleef <ds@schleef.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  */
  21
  22 /*
  23  * Driver: pcl711
  24  * Description: Advantech PCL-711 and 711b, ADLink ACL-8112
  25  * Devices: (Advantech) PCL-711 [pcl711]
  26  *          (Advantech) PCL-711B [pcl711b]
  27  *          (AdLink) ACL-8112HG [acl8112hg]
  28  *          (AdLink) ACL-8112DG [acl8112dg]
  29  * Author: David A. Schleef <ds@schleef.org>
  30  *         Janne Jalkanen <jalkanen@cs.hut.fi>
  31  *         Eric Bunn <ebu@cs.hut.fi>
  32  * Updated:
  33  * Status: mostly complete
  34  *
  35  * Configuration Options:
  36  *   [0] - I/O port base
  37  *   [1] - IRQ, optional
  38  */
  39
  40 #include <linux/module.h>
  41 #include <linux/delay.h>
  42 #include <linux/interrupt.h>
  43
  44 #include "../comedidev.h"
  45
  46 #include "comedi_fc.h"
  47 #include "8253.h"
  48
  49 /*
  50  * I/O port register map
  51  */
  52 #define PCL711_TIMER_BASE       0x00
  53 #define PCL711_AI_LSB_REG       0x04
  54 #define PCL711_AI_MSB_REG       0x05
  55 #define PCL711_AI_MSB_DRDY      (1 << 4)
  56 #define PCL711_AO_LSB_REG(x)    (0x04 + ((x) * 2))
  57 #define PCL711_AO_MSB_REG(x)    (0x05 + ((x) * 2))
  58 #define PCL711_DI_LSB_REG       0x06
  59 #define PCL711_DI_MSB_REG       0x07
  60 #define PCL711_INT_STAT_REG     0x08
  61 #define PCL711_INT_STAT_CLR     (0 << 0)  /* any value will work */
  62 #define PCL711_AI_GAIN_REG      0x09
  63 #define PCL711_AI_GAIN(x)       (((x) & 0xf) << 0)
  64 #define PCL711_MUX_REG          0x0a
  65 #define PCL711_MUX_CHAN(x)      (((x) & 0xf) << 0)
  66 #define PCL711_MUX_CS0          (1 << 4)
  67 #define PCL711_MUX_CS1          (1 << 5)
  68 #define PCL711_MUX_DIFF         (PCL711_MUX_CS0 | PCL711_MUX_CS1)
  69 #define PCL711_MODE_REG         0x0b
  70 #define PCL711_MODE_DEFAULT     (0 << 0)
  71 #define PCL711_MODE_SOFTTRIG    (1 << 0)
  72 #define PCL711_MODE_EXT         (2 << 0)
  73 #define PCL711_MODE_EXT_IRQ     (3 << 0)
  74 #define PCL711_MODE_PACER       (4 << 0)
  75 #define PCL711_MODE_PACER_IRQ   (6 << 0)
  76 #define PCL711_MODE_IRQ(x)      (((x) & 0x7) << 4)
  77 #define PCL711_SOFTTRIG_REG     0x0c
  78 #define PCL711_SOFTTRIG         (0 << 0)  /* any value will work */
  79 #define PCL711_DO_LSB_REG       0x0d
  80 #define PCL711_DO_MSB_REG       0x0e
  81
  82 static const struct comedi_lrange range_pcl711b_ai = {
  83         5, {
  84                 BIP_RANGE(5),
  85                 BIP_RANGE(2.5),
  86                 BIP_RANGE(1.25),
  87                 BIP_RANGE(0.625),
  88                 BIP_RANGE(0.3125)
  89         }
  90 };
  91
  92 static const struct comedi_lrange range_acl8112hg_ai = {
  93         12, {
  94                 BIP_RANGE(5),
  95                 BIP_RANGE(0.5),
  96                 BIP_RANGE(0.05),
  97                 BIP_RANGE(0.005),
  98                 UNI_RANGE(10),
  99                 UNI_RANGE(1),
 100                 UNI_RANGE(0.1),
 101                 UNI_RANGE(0.01),
 102                 BIP_RANGE(10),
 103                 BIP_RANGE(1),
 104                 BIP_RANGE(0.1),
 105                 BIP_RANGE(0.01)
 106         }
 107 };
 108
 109 static const struct comedi_lrange range_acl8112dg_ai = {
 110         9, {
 111                 BIP_RANGE(5),
 112                 BIP_RANGE(2.5),
 113                 BIP_RANGE(1.25),
 114                 BIP_RANGE(0.625),
 115                 UNI_RANGE(10),
 116                 UNI_RANGE(5),
 117                 UNI_RANGE(2.5),
 118                 UNI_RANGE(1.25),
 119                 BIP_RANGE(10)
 120         }
 121 };
 122
 123 struct pcl711_board {
 124         const char *name;
 125         int n_aichan;
 126         int n_aochan;
 127         int maxirq;
 128         const struct comedi_lrange *ai_range_type;
 129 };
 130
 131 static const struct pcl711_board boardtypes[] = {
 132         {
 133                 .name           = "pcl711",
 134                 .n_aichan       = 8,
 135                 .n_aochan       = 1,
 136                 .ai_range_type  = &range_bipolar5,
 137         }, {
 138                 .name           = "pcl711b",
 139                 .n_aichan       = 8,
 140                 .n_aochan       = 1,
 141                 .maxirq         = 7,
 142                 .ai_range_type  = &range_pcl711b_ai,
 143         }, {
 144                 .name           = "acl8112hg",
 145                 .n_aichan       = 16,
 146                 .n_aochan       = 2,
 147                 .maxirq         = 15,
 148                 .ai_range_type  = &range_acl8112hg_ai,
 149         }, {
 150                 .name           = "acl8112dg",
 151                 .n_aichan       = 16,
 152                 .n_aochan       = 2,
 153                 .maxirq         = 15,
 154                 .ai_range_type  = &range_acl8112dg_ai,
 155         },
 156 };
 157
 158 struct pcl711_private {
 159         unsigned int ntrig;
 160         unsigned int divisor1;
 161         unsigned int divisor2;
 162 };
 163
 164 static void pcl711_ai_set_mode(struct comedi_device *dev, unsigned int mode)
 165 {
 166         /*
 167          * The pcl711b board uses bits in the mode register to select the
 168          * interrupt. The other boards supported by this driver all use
 169          * jumpers on the board.
 170          *
 171          * Enables the interrupt when needed on the pcl711b board. These
 172          * bits do nothing on the other boards.
 173          */
 174         if (mode == PCL711_MODE_EXT_IRQ || mode == PCL711_MODE_PACER_IRQ)
 175                 mode |= PCL711_MODE_IRQ(dev->irq);
 176
 177         outb(mode, dev->iobase + PCL711_MODE_REG);
 178 }
 179
 180 static unsigned int pcl711_ai_get_sample(struct comedi_device *dev,
 181                                          struct comedi_subdevice *s)
 182 {
 183         unsigned int val;
 184
 185         val = inb(dev->iobase + PCL711_AI_MSB_REG) << 8;
 186         val |= inb(dev->iobase + PCL711_AI_LSB_REG);
 187
 188         return val & s->maxdata;
 189 }
 190
 191 static int pcl711_ai_cancel(struct comedi_device *dev,
 192                             struct comedi_subdevice *s)
 193 {
 194         outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
 195         pcl711_ai_set_mode(dev, PCL711_MODE_SOFTTRIG);
 196         return 0;
 197 }
 198
 199 static irqreturn_t pcl711_interrupt(int irq, void *d)
 200 {
 201         struct comedi_device *dev = d;
 202         struct pcl711_private *devpriv = dev->private;
 203         struct comedi_subdevice *s = dev->read_subdev;
 204         struct comedi_cmd *cmd = &s->async->cmd;
 205         unsigned int data;
 206
 207         if (!dev->attached) {
 208                 dev_err(dev->class_dev, "spurious interrupt\n");
 209                 return IRQ_HANDLED;
 210         }
 211
 212         data = pcl711_ai_get_sample(dev, s);
 213
 214         outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
 215
 216         if (comedi_buf_write_samples(s, &data, 1)) {
 217                 if (cmd->stop_src == TRIG_COUNT && !(--devpriv->ntrig))
 218                         s->async->events |= COMEDI_CB_EOA;
 219         }
 220         comedi_handle_events(dev, s);
 221
 222         return IRQ_HANDLED;
 223 }
 224
 225 static void pcl711_set_changain(struct comedi_device *dev,
 226                                 struct comedi_subdevice *s,
 227                                 unsigned int chanspec)
 228 {
 229         unsigned int chan = CR_CHAN(chanspec);
 230         unsigned int range = CR_RANGE(chanspec);
 231         unsigned int aref = CR_AREF(chanspec);
 232         unsigned int mux = 0;
 233
 234         outb(PCL711_AI_GAIN(range), dev->iobase + PCL711_AI_GAIN_REG);
 235
 236         if (s->n_chan > 8) {
 237                 /* Select the correct MPC508A chip */
 238                 if (aref == AREF_DIFF) {
 239                         chan &= 0x7;
 240                         mux |= PCL711_MUX_DIFF;
 241                 } else {
 242                         if (chan < 8)
 243                                 mux |= PCL711_MUX_CS0;
 244                         else
 245                                 mux |= PCL711_MUX_CS1;
 246                 }
 247         }
 248         outb(mux | PCL711_MUX_CHAN(chan), dev->iobase + PCL711_MUX_REG);
 249 }
 250
 251 static int pcl711_ai_eoc(struct comedi_device *dev,
 252                          struct comedi_subdevice *s,
 253                          struct comedi_insn *insn,
 254                          unsigned long context)
 255 {
 256         unsigned int status;
 257
 258         status = inb(dev->iobase + PCL711_AI_MSB_REG);
 259         if ((status & PCL711_AI_MSB_DRDY) == 0)
 260                 return 0;
 261         return -EBUSY;
 262 }
 263
 264 static int pcl711_ai_insn_read(struct comedi_device *dev,
 265                                struct comedi_subdevice *s,
 266                                struct comedi_insn *insn,
 267                                unsigned int *data)
 268 {
 269         int ret;
 270         int i;
 271
 272         pcl711_set_changain(dev, s, insn->chanspec);
 273
 274         pcl711_ai_set_mode(dev, PCL711_MODE_SOFTTRIG);
 275
 276         for (i = 0; i < insn->n; i++) {
 277                 outb(PCL711_SOFTTRIG, dev->iobase + PCL711_SOFTTRIG_REG);
 278
 279                 ret = comedi_timeout(dev, s, insn, pcl711_ai_eoc, 0);
 280                 if (ret)
 281                         return ret;
 282
 283                 data[i] = pcl711_ai_get_sample(dev, s);
 284         }
 285
 286         return insn->n;
 287 }
 288
 289 static int pcl711_ai_cmdtest(struct comedi_device *dev,
 290                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
 291 {
 292         struct pcl711_private *devpriv = dev->private;
 293         int err = 0;
 294         unsigned int arg;
 295
 296         /* Step 1 : check if triggers are trivially valid */
 297
 298         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 299         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
 300                                         TRIG_TIMER | TRIG_EXT);
 301         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 302         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 303         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 304
 305         if (err)
 306                 return 1;
 307
 308         /* Step 2a : make sure trigger sources are unique */
 309
 310         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
 311         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 312
 313         /* Step 2b : and mutually compatible */
 314
 315         if (err)
 316                 return 2;
 317
 318         /* Step 3: check if arguments are trivially valid */
 319
 320         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 321
 322         if (cmd->scan_begin_src == TRIG_EXT) {
 323                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 324         } else {
 325 #define MAX_SPEED 1000
 326                 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 327                                                  MAX_SPEED);
 328         }
 329
 330         err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
 331         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 332
 333         if (cmd->stop_src == TRIG_COUNT)
 334                 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
 335         else    /* TRIG_NONE */
 336                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 337
 338         if (err)
 339                 return 3;
 340
 341         /* step 4 */
 342
 343         if (cmd->scan_begin_src == TRIG_TIMER) {
 344                 arg = cmd->scan_begin_arg;
 345                 i8253_cascade_ns_to_timer(I8254_OSC_BASE_2MHZ,
 346                                           &devpriv->divisor1,
 347                                           &devpriv->divisor2,
 348                                           &arg, cmd->flags);
 349                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
 350         }
 351
 352         if (err)
 353                 return 4;
 354
 355         return 0;
 356 }
 357
 358 static void pcl711_ai_load_counters(struct comedi_device *dev)
 359 {
 360         struct pcl711_private *devpriv = dev->private;
 361         unsigned long timer_base = dev->iobase + PCL711_TIMER_BASE;
 362
 363         i8254_set_mode(timer_base, 0, 1, I8254_MODE2 | I8254_BINARY);
 364         i8254_set_mode(timer_base, 0, 2, I8254_MODE2 | I8254_BINARY);
 365
 366         i8254_write(timer_base, 0, 1, devpriv->divisor1);
 367         i8254_write(timer_base, 0, 2, devpriv->divisor2);
 368 }
 369
 370 static int pcl711_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 371 {
 372         struct pcl711_private *devpriv = dev->private;
 373         struct comedi_cmd *cmd = &s->async->cmd;
 374
 375         pcl711_set_changain(dev, s, cmd->chanlist[0]);
 376
 377         if (cmd->stop_src == TRIG_COUNT)
 378                 devpriv->ntrig = cmd->stop_arg;
 379
 380         if (cmd->scan_begin_src == TRIG_TIMER) {
 381                 pcl711_ai_load_counters(dev);
 382                 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
 383                 pcl711_ai_set_mode(dev, PCL711_MODE_PACER_IRQ);
 384         } else {
 385                 pcl711_ai_set_mode(dev, PCL711_MODE_EXT_IRQ);
 386         }
 387
 388         return 0;
 389 }
 390
 391 static void pcl711_ao_write(struct comedi_device *dev,
 392                             unsigned int chan, unsigned int val)
 393 {
 394         outb(val & 0xff, dev->iobase + PCL711_AO_LSB_REG(chan));
 395         outb((val >> 8) & 0xff, dev->iobase + PCL711_AO_MSB_REG(chan));
 396 }
 397
 398 static int pcl711_ao_insn_write(struct comedi_device *dev,
 399                                 struct comedi_subdevice *s,
 400                                 struct comedi_insn *insn,
 401                                 unsigned int *data)
 402 {
 403         unsigned int chan = CR_CHAN(insn->chanspec);
 404         unsigned int val = s->readback[chan];
 405         int i;
 406
 407         for (i = 0; i < insn->n; i++) {
 408                 val = data[i];
 409                 pcl711_ao_write(dev, chan, val);
 410         }
 411         s->readback[chan] = val;
 412
 413         return insn->n;
 414 }
 415
 416 static int pcl711_di_insn_bits(struct comedi_device *dev,
 417                                struct comedi_subdevice *s,
 418                                struct comedi_insn *insn,
 419                                unsigned int *data)
 420 {
 421         unsigned int val;
 422
 423         val = inb(dev->iobase + PCL711_DI_LSB_REG);
 424         val |= (inb(dev->iobase + PCL711_DI_MSB_REG) << 8);
 425
 426         data[1] = val;
 427
 428         return insn->n;
 429 }
 430
 431 static int pcl711_do_insn_bits(struct comedi_device *dev,
 432                                struct comedi_subdevice *s,
 433                                struct comedi_insn *insn,
 434                                unsigned int *data)
 435 {
 436         unsigned int mask;
 437
 438         mask = comedi_dio_update_state(s, data);
 439         if (mask) {
 440                 if (mask & 0x00ff)
 441                         outb(s->state & 0xff, dev->iobase + PCL711_DO_LSB_REG);
 442                 if (mask & 0xff00)
 443                         outb((s->state >> 8), dev->iobase + PCL711_DO_MSB_REG);
 444         }
 445
 446         data[1] = s->state;
 447
 448         return insn->n;
 449 }
 450
 451 static int pcl711_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 452 {
 453         const struct pcl711_board *board = dev->board_ptr;
 454         struct pcl711_private *devpriv;
 455         struct comedi_subdevice *s;
 456         int ret;
 457
 458         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
 459         if (!devpriv)
 460                 return -ENOMEM;
 461
 462         ret = comedi_request_region(dev, it->options[0], 0x10);
 463         if (ret)
 464                 return ret;
 465
 466         if (it->options[1] && it->options[1] <= board->maxirq) {
 467                 ret = request_irq(it->options[1], pcl711_interrupt, 0,
 468                                   dev->board_name, dev);
 469                 if (ret == 0)
 470                         dev->irq = it->options[1];
 471         }
 472
 473         ret = comedi_alloc_subdevices(dev, 4);
 474         if (ret)
 475                 return ret;
 476
 477         /* Analog Input subdevice */
 478         s = &dev->subdevices[0];
 479         s->type         = COMEDI_SUBD_AI;
 480         s->subdev_flags = SDF_READABLE | SDF_GROUND;
 481         if (board->n_aichan > 8)
 482                 s->subdev_flags |= SDF_DIFF;
 483         s->n_chan       = board->n_aichan;
 484         s->maxdata      = 0xfff;
 485         s->range_table  = board->ai_range_type;
 486         s->insn_read    = pcl711_ai_insn_read;
 487         if (dev->irq) {
 488                 dev->read_subdev = s;
 489                 s->subdev_flags |= SDF_CMD_READ;
 490                 s->len_chanlist = 1;
 491                 s->do_cmdtest   = pcl711_ai_cmdtest;
 492                 s->do_cmd       = pcl711_ai_cmd;
 493                 s->cancel       = pcl711_ai_cancel;
 494         }
 495
 496         /* Analog Output subdevice */
 497         s = &dev->subdevices[1];
 498         s->type         = COMEDI_SUBD_AO;
 499         s->subdev_flags = SDF_WRITABLE;
 500         s->n_chan       = board->n_aochan;
 501         s->maxdata      = 0xfff;
 502         s->range_table  = &range_bipolar5;
 503         s->insn_write   = pcl711_ao_insn_write;
 504         s->insn_read    = comedi_readback_insn_read;
 505
 506         ret = comedi_alloc_subdev_readback(s);
 507         if (ret)
 508                 return ret;
 509
 510         /* Digital Input subdevice */
 511         s = &dev->subdevices[2];
 512         s->type         = COMEDI_SUBD_DI;
 513         s->subdev_flags = SDF_READABLE;
 514         s->n_chan       = 16;
 515         s->maxdata      = 1;
 516         s->range_table  = &range_digital;
 517         s->insn_bits    = pcl711_di_insn_bits;
 518
 519         /* Digital Output subdevice */
 520         s = &dev->subdevices[3];
 521         s->type         = COMEDI_SUBD_DO;
 522         s->subdev_flags = SDF_WRITABLE;
 523         s->n_chan       = 16;
 524         s->maxdata      = 1;
 525         s->range_table  = &range_digital;
 526         s->insn_bits    = pcl711_do_insn_bits;
 527
 528         /* clear DAC */
 529         pcl711_ao_write(dev, 0, 0x0);
 530         pcl711_ao_write(dev, 1, 0x0);
 531
 532         return 0;
 533 }
 534
 535 static struct comedi_driver pcl711_driver = {
 536         .driver_name    = "pcl711",
 537         .module         = THIS_MODULE,
 538         .attach         = pcl711_attach,
 539         .detach         = comedi_legacy_detach,
 540         .board_name     = &boardtypes[0].name,
 541         .num_names      = ARRAY_SIZE(boardtypes),
 542         .offset         = sizeof(struct pcl711_board),
 543 };
 544 module_comedi_driver(pcl711_driver);
 545
 546 MODULE_AUTHOR("Comedi http://www.comedi.org");
 547 MODULE_DESCRIPTION("Comedi driver for PCL-711 compatible boards");
 548 MODULE_LICENSE("GPL");