1/* 2 comedi/drivers/das16m1.c 3 CIO-DAS16/M1 driver 4 Author: Frank Mori Hess, based on code from the das16 5 driver. 6 Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net> 7 8 COMEDI - Linux Control and Measurement Device Interface 9 Copyright (C) 2000 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/* 22Driver: das16m1 23Description: CIO-DAS16/M1 24Author: Frank Mori Hess <fmhess@users.sourceforge.net> 25Devices: [Measurement Computing] CIO-DAS16/M1 (das16m1) 26Status: works 27 28This driver supports a single board - the CIO-DAS16/M1. 29As far as I know, there are no other boards that have 30the same register layout. Even the CIO-DAS16/M1/16 is 31significantly different. 32 33I was _barely_ able to reach the full 1 MHz capability 34of this board, using a hard real-time interrupt 35(set the TRIG_RT flag in your struct comedi_cmd and use 36rtlinux or RTAI). The board can't do dma, so the bottleneck is 37pulling the data across the ISA bus. I timed the interrupt 38handler, and it took my computer ~470 microseconds to pull 512 39samples from the board. So at 1 Mhz sampling rate, 40expect your CPU to be spending almost all of its 41time in the interrupt handler. 42 43This board has some unusual restrictions for its channel/gain list. If the 44list has 2 or more channels in it, then two conditions must be satisfied: 45(1) - even/odd channels must appear at even/odd indices in the list 46(2) - the list must have an even number of entries. 47 48Options: 49 [0] - base io address 50 [1] - irq (optional, but you probably want it) 51 52irq can be omitted, although the cmd interface will not work without it. 53*/ 54 55#include <linux/module.h> 56#include <linux/slab.h> 57#include <linux/interrupt.h> 58#include "../comedidev.h" 59 60#include "8255.h" 61#include "comedi_8254.h" 62 63#define DAS16M1_SIZE2 8 64 65#define FIFO_SIZE 1024 /* 1024 sample fifo */ 66 67/* 68 CIO-DAS16_M1.pdf 69 70 "cio-das16/m1" 71 72 0 a/d bits 0-3, mux start 12 bit 73 1 a/d bits 4-11 unused 74 2 status control 75 3 di 4 bit do 4 bit 76 4 unused clear interrupt 77 5 interrupt, pacer 78 6 channel/gain queue address 79 7 channel/gain queue data 80 89ab 8254 81 cdef 8254 82 400 8255 83 404-407 8254 84 85*/ 86 87#define DAS16M1_AI 0 /* 16-bit wide register */ 88#define AI_CHAN(x) ((x) & 0xf) 89#define DAS16M1_CS 2 90#define EXT_TRIG_BIT 0x1 91#define OVRUN 0x20 92#define IRQDATA 0x80 93#define DAS16M1_DIO 3 94#define DAS16M1_CLEAR_INTR 4 95#define DAS16M1_INTR_CONTROL 5 96#define EXT_PACER 0x2 97#define INT_PACER 0x3 98#define PACER_MASK 0x3 99#define INTE 0x80 100#define DAS16M1_QUEUE_ADDR 6 101#define DAS16M1_QUEUE_DATA 7 102#define Q_CHAN(x) ((x) & 0x7) 103#define Q_RANGE(x) (((x) & 0xf) << 4) 104#define UNIPOLAR 0x40 105#define DAS16M1_8254_FIRST 0x8 106#define DAS16M1_8254_SECOND 0xc 107#define DAS16M1_82C55 0x400 108#define DAS16M1_8254_THIRD 0x404 109 110static const struct comedi_lrange range_das16m1 = { 111 9, { 112 BIP_RANGE(5), 113 BIP_RANGE(2.5), 114 BIP_RANGE(1.25), 115 BIP_RANGE(0.625), 116 UNI_RANGE(10), 117 UNI_RANGE(5), 118 UNI_RANGE(2.5), 119 UNI_RANGE(1.25), 120 BIP_RANGE(10) 121 } 122}; 123 124struct das16m1_private_struct { 125 struct comedi_8254 *counter; 126 unsigned int control_state; 127 unsigned int adc_count; /* number of samples completed */ 128 /* initial value in lower half of hardware conversion counter, 129 * needed to keep track of whether new count has been loaded into 130 * counter yet (loaded by first sample conversion) */ 131 u16 initial_hw_count; 132 unsigned short ai_buffer[FIFO_SIZE]; 133 unsigned long extra_iobase; 134}; 135 136static inline unsigned short munge_sample(unsigned short data) 137{ 138 return (data >> 4) & 0xfff; 139} 140 141static void munge_sample_array(unsigned short *array, unsigned int num_elements) 142{ 143 unsigned int i; 144 145 for (i = 0; i < num_elements; i++) 146 array[i] = munge_sample(array[i]); 147} 148 149static int das16m1_ai_check_chanlist(struct comedi_device *dev, 150 struct comedi_subdevice *s, 151 struct comedi_cmd *cmd) 152{ 153 int i; 154 155 if (cmd->chanlist_len == 1) 156 return 0; 157 158 if ((cmd->chanlist_len % 2) != 0) { 159 dev_dbg(dev->class_dev, 160 "chanlist must be of even length or length 1\n"); 161 return -EINVAL; 162 } 163 164 for (i = 0; i < cmd->chanlist_len; i++) { 165 unsigned int chan = CR_CHAN(cmd->chanlist[i]); 166 167 if ((i % 2) != (chan % 2)) { 168 dev_dbg(dev->class_dev, 169 "even/odd channels must go have even/odd chanlist indices\n"); 170 return -EINVAL; 171 } 172 } 173 174 return 0; 175} 176 177static int das16m1_cmd_test(struct comedi_device *dev, 178 struct comedi_subdevice *s, struct comedi_cmd *cmd) 179{ 180 int err = 0; 181 182 /* Step 1 : check if triggers are trivially valid */ 183 184 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT); 185 err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW); 186 err |= comedi_check_trigger_src(&cmd->convert_src, 187 TRIG_TIMER | TRIG_EXT); 188 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT); 189 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE); 190 191 if (err) 192 return 1; 193 194 /* Step 2a : make sure trigger sources are unique */ 195 196 err |= comedi_check_trigger_is_unique(cmd->start_src); 197 err |= comedi_check_trigger_is_unique(cmd->convert_src); 198 err |= comedi_check_trigger_is_unique(cmd->stop_src); 199 200 /* Step 2b : and mutually compatible */ 201 202 if (err) 203 return 2; 204 205 /* Step 3: check if arguments are trivially valid */ 206 207 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0); 208 209 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */ 210 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0); 211 212 if (cmd->convert_src == TRIG_TIMER) 213 err |= comedi_check_trigger_arg_min(&cmd->convert_arg, 1000); 214 215 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg, 216 cmd->chanlist_len); 217 218 if (cmd->stop_src == TRIG_COUNT) 219 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1); 220 else /* TRIG_NONE */ 221 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0); 222 223 if (err) 224 return 3; 225 226 /* step 4: fix up arguments */ 227 228 if (cmd->convert_src == TRIG_TIMER) { 229 unsigned int arg = cmd->convert_arg; 230 231 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags); 232 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg); 233 } 234 235 if (err) 236 return 4; 237 238 /* Step 5: check channel list if it exists */ 239 if (cmd->chanlist && cmd->chanlist_len > 0) 240 err |= das16m1_ai_check_chanlist(dev, s, cmd); 241 242 if (err) 243 return 5; 244 245 return 0; 246} 247 248static int das16m1_cmd_exec(struct comedi_device *dev, 249 struct comedi_subdevice *s) 250{ 251 struct das16m1_private_struct *devpriv = dev->private; 252 struct comedi_async *async = s->async; 253 struct comedi_cmd *cmd = &async->cmd; 254 unsigned int byte, i; 255 256 /* disable interrupts and internal pacer */ 257 devpriv->control_state &= ~INTE & ~PACER_MASK; 258 outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL); 259 260 /* set software count */ 261 devpriv->adc_count = 0; 262 263 /* 264 * Initialize lower half of hardware counter, used to determine how 265 * many samples are in fifo. Value doesn't actually load into counter 266 * until counter's next clock (the next a/d conversion). 267 */ 268 comedi_8254_set_mode(devpriv->counter, 1, I8254_MODE2 | I8254_BINARY); 269 comedi_8254_write(devpriv->counter, 1, 0); 270 271 /* 272 * Remember current reading of counter so we know when counter has 273 * actually been loaded. 274 */ 275 devpriv->initial_hw_count = comedi_8254_read(devpriv->counter, 1); 276 277 /* setup channel/gain queue */ 278 for (i = 0; i < cmd->chanlist_len; i++) { 279 outb(i, dev->iobase + DAS16M1_QUEUE_ADDR); 280 byte = 281 Q_CHAN(CR_CHAN(cmd->chanlist[i])) | 282 Q_RANGE(CR_RANGE(cmd->chanlist[i])); 283 outb(byte, dev->iobase + DAS16M1_QUEUE_DATA); 284 } 285 286 /* enable interrupts and set internal pacer counter mode and counts */ 287 devpriv->control_state &= ~PACER_MASK; 288 if (cmd->convert_src == TRIG_TIMER) { 289 comedi_8254_update_divisors(dev->pacer); 290 comedi_8254_pacer_enable(dev->pacer, 1, 2, true); 291 devpriv->control_state |= INT_PACER; 292 } else { /* TRIG_EXT */ 293 devpriv->control_state |= EXT_PACER; 294 } 295 296 /* set control & status register */ 297 byte = 0; 298 /* if we are using external start trigger (also board dislikes having 299 * both start and conversion triggers external simultaneously) */ 300 if (cmd->start_src == TRIG_EXT && cmd->convert_src != TRIG_EXT) 301 byte |= EXT_TRIG_BIT; 302 303 outb(byte, dev->iobase + DAS16M1_CS); 304 /* clear interrupt bit */ 305 outb(0, dev->iobase + DAS16M1_CLEAR_INTR); 306 307 devpriv->control_state |= INTE; 308 outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL); 309 310 return 0; 311} 312 313static int das16m1_cancel(struct comedi_device *dev, struct comedi_subdevice *s) 314{ 315 struct das16m1_private_struct *devpriv = dev->private; 316 317 devpriv->control_state &= ~INTE & ~PACER_MASK; 318 outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL); 319 320 return 0; 321} 322 323static int das16m1_ai_eoc(struct comedi_device *dev, 324 struct comedi_subdevice *s, 325 struct comedi_insn *insn, 326 unsigned long context) 327{ 328 unsigned int status; 329 330 status = inb(dev->iobase + DAS16M1_CS); 331 if (status & IRQDATA) 332 return 0; 333 return -EBUSY; 334} 335 336static int das16m1_ai_rinsn(struct comedi_device *dev, 337 struct comedi_subdevice *s, 338 struct comedi_insn *insn, unsigned int *data) 339{ 340 struct das16m1_private_struct *devpriv = dev->private; 341 int ret; 342 int n; 343 int byte; 344 345 /* disable interrupts and internal pacer */ 346 devpriv->control_state &= ~INTE & ~PACER_MASK; 347 outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL); 348 349 /* setup channel/gain queue */ 350 outb(0, dev->iobase + DAS16M1_QUEUE_ADDR); 351 byte = 352 Q_CHAN(CR_CHAN(insn->chanspec)) | Q_RANGE(CR_RANGE(insn->chanspec)); 353 outb(byte, dev->iobase + DAS16M1_QUEUE_DATA); 354 355 for (n = 0; n < insn->n; n++) { 356 /* clear IRQDATA bit */ 357 outb(0, dev->iobase + DAS16M1_CLEAR_INTR); 358 /* trigger conversion */ 359 outb(0, dev->iobase); 360 361 ret = comedi_timeout(dev, s, insn, das16m1_ai_eoc, 0); 362 if (ret) 363 return ret; 364 365 data[n] = munge_sample(inw(dev->iobase)); 366 } 367 368 return n; 369} 370 371static int das16m1_di_rbits(struct comedi_device *dev, 372 struct comedi_subdevice *s, 373 struct comedi_insn *insn, unsigned int *data) 374{ 375 unsigned int bits; 376 377 bits = inb(dev->iobase + DAS16M1_DIO) & 0xf; 378 data[1] = bits; 379 data[0] = 0; 380 381 return insn->n; 382} 383 384static int das16m1_do_wbits(struct comedi_device *dev, 385 struct comedi_subdevice *s, 386 struct comedi_insn *insn, 387 unsigned int *data) 388{ 389 if (comedi_dio_update_state(s, data)) 390 outb(s->state, dev->iobase + DAS16M1_DIO); 391 392 data[1] = s->state; 393 394 return insn->n; 395} 396 397static void das16m1_handler(struct comedi_device *dev, unsigned int status) 398{ 399 struct das16m1_private_struct *devpriv = dev->private; 400 struct comedi_subdevice *s; 401 struct comedi_async *async; 402 struct comedi_cmd *cmd; 403 u16 num_samples; 404 u16 hw_counter; 405 406 s = dev->read_subdev; 407 async = s->async; 408 cmd = &async->cmd; 409 410 /* figure out how many samples are in fifo */ 411 hw_counter = comedi_8254_read(devpriv->counter, 1); 412 /* make sure hardware counter reading is not bogus due to initial value 413 * not having been loaded yet */ 414 if (devpriv->adc_count == 0 && hw_counter == devpriv->initial_hw_count) { 415 num_samples = 0; 416 } else { 417 /* The calculation of num_samples looks odd, but it uses the following facts. 418 * 16 bit hardware counter is initialized with value of zero (which really 419 * means 0x1000). The counter decrements by one on each conversion 420 * (when the counter decrements from zero it goes to 0xffff). num_samples 421 * is a 16 bit variable, so it will roll over in a similar fashion to the 422 * hardware counter. Work it out, and this is what you get. */ 423 num_samples = -hw_counter - devpriv->adc_count; 424 } 425 /* check if we only need some of the points */ 426 if (cmd->stop_src == TRIG_COUNT) { 427 if (num_samples > cmd->stop_arg * cmd->chanlist_len) 428 num_samples = cmd->stop_arg * cmd->chanlist_len; 429 } 430 /* make sure we dont try to get too many points if fifo has overrun */ 431 if (num_samples > FIFO_SIZE) 432 num_samples = FIFO_SIZE; 433 insw(dev->iobase, devpriv->ai_buffer, num_samples); 434 munge_sample_array(devpriv->ai_buffer, num_samples); 435 comedi_buf_write_samples(s, devpriv->ai_buffer, num_samples); 436 devpriv->adc_count += num_samples; 437 438 if (cmd->stop_src == TRIG_COUNT) { 439 if (devpriv->adc_count >= cmd->stop_arg * cmd->chanlist_len) { 440 /* end of acquisition */ 441 async->events |= COMEDI_CB_EOA; 442 } 443 } 444 445 /* this probably won't catch overruns since the card doesn't generate 446 * overrun interrupts, but we might as well try */ 447 if (status & OVRUN) { 448 async->events |= COMEDI_CB_ERROR; 449 dev_err(dev->class_dev, "fifo overflow\n"); 450 } 451 452 comedi_handle_events(dev, s); 453} 454 455static int das16m1_poll(struct comedi_device *dev, struct comedi_subdevice *s) 456{ 457 unsigned long flags; 458 unsigned int status; 459 460 /* prevent race with interrupt handler */ 461 spin_lock_irqsave(&dev->spinlock, flags); 462 status = inb(dev->iobase + DAS16M1_CS); 463 das16m1_handler(dev, status); 464 spin_unlock_irqrestore(&dev->spinlock, flags); 465 466 return comedi_buf_n_bytes_ready(s); 467} 468 469static irqreturn_t das16m1_interrupt(int irq, void *d) 470{ 471 int status; 472 struct comedi_device *dev = d; 473 474 if (!dev->attached) { 475 dev_err(dev->class_dev, "premature interrupt\n"); 476 return IRQ_HANDLED; 477 } 478 /* prevent race with comedi_poll() */ 479 spin_lock(&dev->spinlock); 480 481 status = inb(dev->iobase + DAS16M1_CS); 482 483 if ((status & (IRQDATA | OVRUN)) == 0) { 484 dev_err(dev->class_dev, "spurious interrupt\n"); 485 spin_unlock(&dev->spinlock); 486 return IRQ_NONE; 487 } 488 489 das16m1_handler(dev, status); 490 491 /* clear interrupt */ 492 outb(0, dev->iobase + DAS16M1_CLEAR_INTR); 493 494 spin_unlock(&dev->spinlock); 495 return IRQ_HANDLED; 496} 497 498static int das16m1_irq_bits(unsigned int irq) 499{ 500 switch (irq) { 501 case 10: 502 return 0x0; 503 case 11: 504 return 0x1; 505 case 12: 506 return 0x2; 507 case 15: 508 return 0x3; 509 case 2: 510 return 0x4; 511 case 3: 512 return 0x5; 513 case 5: 514 return 0x6; 515 case 7: 516 return 0x7; 517 default: 518 return 0x0; 519 } 520} 521 522/* 523 * Options list: 524 * 0 I/O base 525 * 1 IRQ 526 */ 527static int das16m1_attach(struct comedi_device *dev, 528 struct comedi_devconfig *it) 529{ 530 struct das16m1_private_struct *devpriv; 531 struct comedi_subdevice *s; 532 int ret; 533 534 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv)); 535 if (!devpriv) 536 return -ENOMEM; 537 538 ret = comedi_request_region(dev, it->options[0], 0x10); 539 if (ret) 540 return ret; 541 /* Request an additional region for the 8255 */ 542 ret = __comedi_request_region(dev, dev->iobase + DAS16M1_82C55, 543 DAS16M1_SIZE2); 544 if (ret) 545 return ret; 546 devpriv->extra_iobase = dev->iobase + DAS16M1_82C55; 547 548 /* only irqs 2, 3, 4, 5, 6, 7, 10, 11, 12, 14, and 15 are valid */ 549 if ((1 << it->options[1]) & 0xdcfc) { 550 ret = request_irq(it->options[1], das16m1_interrupt, 0, 551 dev->board_name, dev); 552 if (ret == 0) 553 dev->irq = it->options[1]; 554 } 555 556 dev->pacer = comedi_8254_init(dev->iobase + DAS16M1_8254_SECOND, 557 I8254_OSC_BASE_10MHZ, I8254_IO8, 0); 558 if (!dev->pacer) 559 return -ENOMEM; 560 561 devpriv->counter = comedi_8254_init(dev->iobase + DAS16M1_8254_FIRST, 562 0, I8254_IO8, 0); 563 if (!devpriv->counter) 564 return -ENOMEM; 565 566 ret = comedi_alloc_subdevices(dev, 4); 567 if (ret) 568 return ret; 569 570 s = &dev->subdevices[0]; 571 /* ai */ 572 s->type = COMEDI_SUBD_AI; 573 s->subdev_flags = SDF_READABLE | SDF_DIFF; 574 s->n_chan = 8; 575 s->maxdata = (1 << 12) - 1; 576 s->range_table = &range_das16m1; 577 s->insn_read = das16m1_ai_rinsn; 578 if (dev->irq) { 579 dev->read_subdev = s; 580 s->subdev_flags |= SDF_CMD_READ; 581 s->len_chanlist = 256; 582 s->do_cmdtest = das16m1_cmd_test; 583 s->do_cmd = das16m1_cmd_exec; 584 s->cancel = das16m1_cancel; 585 s->poll = das16m1_poll; 586 } 587 588 s = &dev->subdevices[1]; 589 /* di */ 590 s->type = COMEDI_SUBD_DI; 591 s->subdev_flags = SDF_READABLE; 592 s->n_chan = 4; 593 s->maxdata = 1; 594 s->range_table = &range_digital; 595 s->insn_bits = das16m1_di_rbits; 596 597 s = &dev->subdevices[2]; 598 /* do */ 599 s->type = COMEDI_SUBD_DO; 600 s->subdev_flags = SDF_WRITABLE; 601 s->n_chan = 4; 602 s->maxdata = 1; 603 s->range_table = &range_digital; 604 s->insn_bits = das16m1_do_wbits; 605 606 s = &dev->subdevices[3]; 607 /* 8255 */ 608 ret = subdev_8255_init(dev, s, NULL, DAS16M1_82C55); 609 if (ret) 610 return ret; 611 612 /* initialize digital output lines */ 613 outb(0, dev->iobase + DAS16M1_DIO); 614 615 /* set the interrupt level */ 616 devpriv->control_state = das16m1_irq_bits(dev->irq) << 4; 617 outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL); 618 619 return 0; 620} 621 622static void das16m1_detach(struct comedi_device *dev) 623{ 624 struct das16m1_private_struct *devpriv = dev->private; 625 626 if (devpriv) { 627 if (devpriv->extra_iobase) 628 release_region(devpriv->extra_iobase, DAS16M1_SIZE2); 629 kfree(devpriv->counter); 630 } 631 comedi_legacy_detach(dev); 632} 633 634static struct comedi_driver das16m1_driver = { 635 .driver_name = "das16m1", 636 .module = THIS_MODULE, 637 .attach = das16m1_attach, 638 .detach = das16m1_detach, 639}; 640module_comedi_driver(das16m1_driver); 641 642MODULE_AUTHOR("Comedi http://www.comedi.org"); 643MODULE_DESCRIPTION("Comedi low-level driver"); 644MODULE_LICENSE("GPL"); 645