drivers/comedi/drivers/pcl711.c

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