quatech_daqp_cs.c revision 3420f6b4c1ac731e80d0911e0092705992cef14f
1/*====================================================================== 2 3 comedi/drivers/quatech_daqp_cs.c 4 5 Quatech DAQP PCMCIA data capture cards COMEDI client driver 6 Copyright (C) 2000, 2003 Brent Baccala <baccala@freesoft.org> 7 The DAQP interface code in this file is released into the public domain. 8 9 COMEDI - Linux Control and Measurement Device Interface 10 Copyright (C) 1998 David A. Schleef <ds@schleef.org> 11 http://www.comedi.org/ 12 13 quatech_daqp_cs.c 1.10 14 15 Documentation for the DAQP PCMCIA cards can be found on Quatech's site: 16 17 ftp://ftp.quatech.com/Manuals/daqp-208.pdf 18 19 This manual is for both the DAQP-208 and the DAQP-308. 20 21 What works: 22 23 - A/D conversion 24 - 8 channels 25 - 4 gain ranges 26 - ground ref or differential 27 - single-shot and timed both supported 28 - D/A conversion, single-shot 29 - digital I/O 30 31 What doesn't: 32 33 - any kind of triggering - external or D/A channel 1 34 - the card's optional expansion board 35 - the card's timer (for anything other than A/D conversion) 36 - D/A update modes other than immediate (i.e, timed) 37 - fancier timing modes 38 - setting card's FIFO buffer thresholds to anything but default 39 40======================================================================*/ 41 42/* 43Driver: quatech_daqp_cs 44Description: Quatech DAQP PCMCIA data capture cards 45Author: Brent Baccala <baccala@freesoft.org> 46Status: works 47Devices: [Quatech] DAQP-208 (daqp), DAQP-308 48*/ 49 50#include "../comedidev.h" 51#include <linux/semaphore.h> 52 53#include <pcmcia/cs_types.h> 54#include <pcmcia/cs.h> 55#include <pcmcia/cistpl.h> 56#include <pcmcia/cisreg.h> 57#include <pcmcia/ds.h> 58 59#include <linux/completion.h> 60 61/* Maximum number of separate DAQP devices we'll allow */ 62#define MAX_DEV 4 63 64struct local_info_t { 65 struct pcmcia_device *link; 66 int stop; 67 int table_index; 68 char board_name[32]; 69 70 enum { semaphore, buffer } interrupt_mode; 71 72 struct completion eos; 73 74 struct comedi_device *dev; 75 struct comedi_subdevice *s; 76 int count; 77}; 78 79/* A list of "instances" of the device. */ 80 81static struct local_info_t *dev_table[MAX_DEV] = { NULL, /* ... */ }; 82 83/* The DAQP communicates with the system through a 16 byte I/O window. */ 84 85#define DAQP_FIFO_SIZE 4096 86 87#define DAQP_FIFO 0 88#define DAQP_SCANLIST 1 89#define DAQP_CONTROL 2 90#define DAQP_STATUS 2 91#define DAQP_DIGITAL_IO 3 92#define DAQP_PACER_LOW 4 93#define DAQP_PACER_MID 5 94#define DAQP_PACER_HIGH 6 95#define DAQP_COMMAND 7 96#define DAQP_DA 8 97#define DAQP_TIMER 10 98#define DAQP_AUX 15 99 100#define DAQP_SCANLIST_DIFFERENTIAL 0x4000 101#define DAQP_SCANLIST_GAIN(x) ((x)<<12) 102#define DAQP_SCANLIST_CHANNEL(x) ((x)<<8) 103#define DAQP_SCANLIST_START 0x0080 104#define DAQP_SCANLIST_EXT_GAIN(x) ((x)<<4) 105#define DAQP_SCANLIST_EXT_CHANNEL(x) (x) 106 107#define DAQP_CONTROL_PACER_100kHz 0xc0 108#define DAQP_CONTROL_PACER_1MHz 0x80 109#define DAQP_CONTROL_PACER_5MHz 0x40 110#define DAQP_CONTROL_PACER_EXTERNAL 0x00 111#define DAQP_CONTORL_EXPANSION 0x20 112#define DAQP_CONTROL_EOS_INT_ENABLE 0x10 113#define DAQP_CONTROL_FIFO_INT_ENABLE 0x08 114#define DAQP_CONTROL_TRIGGER_ONESHOT 0x00 115#define DAQP_CONTROL_TRIGGER_CONTINUOUS 0x04 116#define DAQP_CONTROL_TRIGGER_INTERNAL 0x00 117#define DAQP_CONTROL_TRIGGER_EXTERNAL 0x02 118#define DAQP_CONTROL_TRIGGER_RISING 0x00 119#define DAQP_CONTROL_TRIGGER_FALLING 0x01 120 121#define DAQP_STATUS_IDLE 0x80 122#define DAQP_STATUS_RUNNING 0x40 123#define DAQP_STATUS_EVENTS 0x38 124#define DAQP_STATUS_DATA_LOST 0x20 125#define DAQP_STATUS_END_OF_SCAN 0x10 126#define DAQP_STATUS_FIFO_THRESHOLD 0x08 127#define DAQP_STATUS_FIFO_FULL 0x04 128#define DAQP_STATUS_FIFO_NEARFULL 0x02 129#define DAQP_STATUS_FIFO_EMPTY 0x01 130 131#define DAQP_COMMAND_ARM 0x80 132#define DAQP_COMMAND_RSTF 0x40 133#define DAQP_COMMAND_RSTQ 0x20 134#define DAQP_COMMAND_STOP 0x10 135#define DAQP_COMMAND_LATCH 0x08 136#define DAQP_COMMAND_100kHz 0x00 137#define DAQP_COMMAND_50kHz 0x02 138#define DAQP_COMMAND_25kHz 0x04 139#define DAQP_COMMAND_FIFO_DATA 0x01 140#define DAQP_COMMAND_FIFO_PROGRAM 0x00 141 142#define DAQP_AUX_TRIGGER_TTL 0x00 143#define DAQP_AUX_TRIGGER_ANALOG 0x80 144#define DAQP_AUX_TRIGGER_PRETRIGGER 0x40 145#define DAQP_AUX_TIMER_INT_ENABLE 0x20 146#define DAQP_AUX_TIMER_RELOAD 0x00 147#define DAQP_AUX_TIMER_PAUSE 0x08 148#define DAQP_AUX_TIMER_GO 0x10 149#define DAQP_AUX_TIMER_GO_EXTERNAL 0x18 150#define DAQP_AUX_TIMER_EXTERNAL_SRC 0x04 151#define DAQP_AUX_TIMER_INTERNAL_SRC 0x00 152#define DAQP_AUX_DA_DIRECT 0x00 153#define DAQP_AUX_DA_OVERFLOW 0x01 154#define DAQP_AUX_DA_EXTERNAL 0x02 155#define DAQP_AUX_DA_PACER 0x03 156 157#define DAQP_AUX_RUNNING 0x80 158#define DAQP_AUX_TRIGGERED 0x40 159#define DAQP_AUX_DA_BUFFER 0x20 160#define DAQP_AUX_TIMER_OVERFLOW 0x10 161#define DAQP_AUX_CONVERSION 0x08 162#define DAQP_AUX_DATA_LOST 0x04 163#define DAQP_AUX_FIFO_NEARFULL 0x02 164#define DAQP_AUX_FIFO_EMPTY 0x01 165 166/* These range structures tell COMEDI how the sample values map to 167 * voltages. The A/D converter has four .ranges = +/- 10V through 168 * +/- 1.25V, and the D/A converter has only .one = +/- 5V. 169 */ 170 171static const struct comedi_lrange range_daqp_ai = { 4, { 172 BIP_RANGE(10), 173 BIP_RANGE(5), 174 BIP_RANGE(2.5), 175 BIP_RANGE(1.25) 176 } 177}; 178 179static const struct comedi_lrange range_daqp_ao = { 1, {BIP_RANGE(5)} }; 180 181/*====================================================================*/ 182 183/* comedi interface code */ 184 185static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it); 186static int daqp_detach(struct comedi_device *dev); 187static struct comedi_driver driver_daqp = { 188 .driver_name = "quatech_daqp_cs", 189 .module = THIS_MODULE, 190 .attach = daqp_attach, 191 .detach = daqp_detach, 192}; 193 194#ifdef DAQP_DEBUG 195 196static void daqp_dump(struct comedi_device *dev) 197{ 198 printk(KERN_INFO "DAQP: status %02x; aux status %02x\n", 199 inb(dev->iobase + DAQP_STATUS), inb(dev->iobase + DAQP_AUX)); 200} 201 202static void hex_dump(char *str, void *ptr, int len) 203{ 204 unsigned char *cptr = ptr; 205 int i; 206 207 printk(str); 208 209 for (i = 0; i < len; i++) { 210 if (i % 16 == 0) 211 printk("\n0x%08x:", (unsigned int)cptr); 212 213 printk(" %02x", *(cptr++)); 214 } 215 printk("\n"); 216} 217 218#endif 219 220/* Cancel a running acquisition */ 221 222static int daqp_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s) 223{ 224 struct local_info_t *local = (struct local_info_t *)s->private; 225 226 if (local->stop) 227 return -EIO; 228 229 230 outb(DAQP_COMMAND_STOP, dev->iobase + DAQP_COMMAND); 231 232 /* flush any linguring data in FIFO - superfluous here */ 233 /* outb(DAQP_COMMAND_RSTF, dev->iobase+DAQP_COMMAND); */ 234 235 local->interrupt_mode = semaphore; 236 237 return 0; 238} 239 240/* Interrupt handler 241 * 242 * Operates in one of two modes. If local->interrupt_mode is 243 * 'semaphore', just signal the local->eos completion and return 244 * (one-shot mode). Otherwise (continuous mode), read data in from 245 * the card, transfer it to the buffer provided by the higher-level 246 * comedi kernel module, and signal various comedi callback routines, 247 * which run pretty quick. 248 */ 249static enum irqreturn daqp_interrupt(int irq, void *dev_id) 250{ 251 struct local_info_t *local = (struct local_info_t *)dev_id; 252 struct comedi_device *dev; 253 struct comedi_subdevice *s; 254 int loop_limit = 10000; 255 int status; 256 257 if (local == NULL) { 258 printk(KERN_WARNING 259 "daqp_interrupt(): irq %d for unknown device.\n", irq); 260 return IRQ_NONE; 261 } 262 263 dev = local->dev; 264 if (dev == NULL) { 265 printk(KERN_WARNING "daqp_interrupt(): NULL comedi_device.\n"); 266 return IRQ_NONE; 267 } 268 269 if (!dev->attached) { 270 printk(KERN_WARNING 271 "daqp_interrupt(): struct comedi_device not yet attached.\n"); 272 return IRQ_NONE; 273 } 274 275 s = local->s; 276 if (s == NULL) { 277 printk(KERN_WARNING 278 "daqp_interrupt(): NULL comedi_subdevice.\n"); 279 return IRQ_NONE; 280 } 281 282 if ((struct local_info_t *)s->private != local) { 283 printk(KERN_WARNING 284 "daqp_interrupt(): invalid comedi_subdevice.\n"); 285 return IRQ_NONE; 286 } 287 288 switch (local->interrupt_mode) { 289 290 case semaphore: 291 292 complete(&local->eos); 293 break; 294 295 case buffer: 296 297 while (!((status = inb(dev->iobase + DAQP_STATUS)) 298 & DAQP_STATUS_FIFO_EMPTY)) { 299 300 short data; 301 302 if (status & DAQP_STATUS_DATA_LOST) { 303 s->async->events |= 304 COMEDI_CB_EOA | COMEDI_CB_OVERFLOW; 305 printk("daqp: data lost\n"); 306 daqp_ai_cancel(dev, s); 307 break; 308 } 309 310 data = inb(dev->iobase + DAQP_FIFO); 311 data |= inb(dev->iobase + DAQP_FIFO) << 8; 312 data ^= 0x8000; 313 314 comedi_buf_put(s->async, data); 315 316 /* If there's a limit, decrement it 317 * and stop conversion if zero 318 */ 319 320 if (local->count > 0) { 321 local->count--; 322 if (local->count == 0) { 323 daqp_ai_cancel(dev, s); 324 s->async->events |= COMEDI_CB_EOA; 325 break; 326 } 327 } 328 329 if ((loop_limit--) <= 0) 330 break; 331 } 332 333 if (loop_limit <= 0) { 334 printk(KERN_WARNING 335 "loop_limit reached in daqp_interrupt()\n"); 336 daqp_ai_cancel(dev, s); 337 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR; 338 } 339 340 s->async->events |= COMEDI_CB_BLOCK; 341 342 comedi_event(dev, s); 343 } 344 return IRQ_HANDLED; 345} 346 347/* One-shot analog data acquisition routine */ 348 349static int daqp_ai_insn_read(struct comedi_device *dev, 350 struct comedi_subdevice *s, 351 struct comedi_insn *insn, unsigned int *data) 352{ 353 struct local_info_t *local = (struct local_info_t *)s->private; 354 int i; 355 int v; 356 int counter = 10000; 357 358 if (local->stop) 359 return -EIO; 360 361 362 /* Stop any running conversion */ 363 daqp_ai_cancel(dev, s); 364 365 outb(0, dev->iobase + DAQP_AUX); 366 367 /* Reset scan list queue */ 368 outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND); 369 370 /* Program one scan list entry */ 371 372 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(insn->chanspec)) 373 | DAQP_SCANLIST_GAIN(CR_RANGE(insn->chanspec)); 374 375 if (CR_AREF(insn->chanspec) == AREF_DIFF) 376 v |= DAQP_SCANLIST_DIFFERENTIAL; 377 378 379 v |= DAQP_SCANLIST_START; 380 381 outb(v & 0xff, dev->iobase + DAQP_SCANLIST); 382 outb(v >> 8, dev->iobase + DAQP_SCANLIST); 383 384 /* Reset data FIFO (see page 28 of DAQP User's Manual) */ 385 386 outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND); 387 388 /* Set trigger */ 389 390 v = DAQP_CONTROL_TRIGGER_ONESHOT | DAQP_CONTROL_TRIGGER_INTERNAL 391 | DAQP_CONTROL_PACER_100kHz | DAQP_CONTROL_EOS_INT_ENABLE; 392 393 outb(v, dev->iobase + DAQP_CONTROL); 394 395 /* Reset any pending interrupts (my card has a tendancy to require 396 * require multiple reads on the status register to achieve this) 397 */ 398 399 while (--counter 400 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ; 401 if (!counter) { 402 printk("daqp: couldn't clear interrupts in status register\n"); 403 return -1; 404 } 405 406 init_completion(&local->eos); 407 local->interrupt_mode = semaphore; 408 local->dev = dev; 409 local->s = s; 410 411 for (i = 0; i < insn->n; i++) { 412 413 /* Start conversion */ 414 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA, 415 dev->iobase + DAQP_COMMAND); 416 417 /* Wait for interrupt service routine to unblock completion */ 418 /* Maybe could use a timeout here, but it's interruptible */ 419 if (wait_for_completion_interruptible(&local->eos)) 420 return -EINTR; 421 422 data[i] = inb(dev->iobase + DAQP_FIFO); 423 data[i] |= inb(dev->iobase + DAQP_FIFO) << 8; 424 data[i] ^= 0x8000; 425 } 426 427 return insn->n; 428} 429 430/* This function converts ns nanoseconds to a counter value suitable 431 * for programming the device. We always use the DAQP's 5 MHz clock, 432 * which with its 24-bit counter, allows values up to 84 seconds. 433 * Also, the function adjusts ns so that it cooresponds to the actual 434 * time that the device will use. 435 */ 436 437static int daqp_ns_to_timer(unsigned int *ns, int round) 438{ 439 int timer; 440 441 timer = *ns / 200; 442 *ns = timer * 200; 443 444 return timer; 445} 446 447/* cmdtest tests a particular command to see if it is valid. 448 * Using the cmdtest ioctl, a user can create a valid cmd 449 * and then have it executed by the cmd ioctl. 450 * 451 * cmdtest returns 1,2,3,4 or 0, depending on which tests 452 * the command passes. 453 */ 454 455static int daqp_ai_cmdtest(struct comedi_device *dev, 456 struct comedi_subdevice *s, struct comedi_cmd *cmd) 457{ 458 int err = 0; 459 int tmp; 460 461 /* step 1: make sure trigger sources are trivially valid */ 462 463 tmp = cmd->start_src; 464 cmd->start_src &= TRIG_NOW; 465 if (!cmd->start_src || tmp != cmd->start_src) 466 err++; 467 468 tmp = cmd->scan_begin_src; 469 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW; 470 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 471 err++; 472 473 tmp = cmd->convert_src; 474 cmd->convert_src &= TRIG_TIMER | TRIG_NOW; 475 if (!cmd->convert_src || tmp != cmd->convert_src) 476 err++; 477 478 tmp = cmd->scan_end_src; 479 cmd->scan_end_src &= TRIG_COUNT; 480 if (!cmd->scan_end_src || tmp != cmd->scan_end_src) 481 err++; 482 483 tmp = cmd->stop_src; 484 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 485 if (!cmd->stop_src || tmp != cmd->stop_src) 486 err++; 487 488 if (err) 489 return 1; 490 491 /* 492 * step 2: make sure trigger sources 493 * are unique and mutually compatible 494 */ 495 496 /* note that mutual compatibility is not an issue here */ 497 if (cmd->scan_begin_src != TRIG_TIMER && 498 cmd->scan_begin_src != TRIG_FOLLOW) 499 err++; 500 if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER) 501 err++; 502 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW) 503 err++; 504 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) 505 err++; 506 507 if (err) 508 return 2; 509 510 /* step 3: make sure arguments are trivially compatible */ 511 512 if (cmd->start_arg != 0) { 513 cmd->start_arg = 0; 514 err++; 515 } 516#define MAX_SPEED 10000 /* 100 kHz - in nanoseconds */ 517 518 if (cmd->scan_begin_src == TRIG_TIMER 519 && cmd->scan_begin_arg < MAX_SPEED) { 520 cmd->scan_begin_arg = MAX_SPEED; 521 err++; 522 } 523 524 /* If both scan_begin and convert are both timer values, the only 525 * way that can make sense is if the scan time is the number of 526 * conversions times the convert time 527 */ 528 529 if (cmd->scan_begin_src == TRIG_TIMER && cmd->convert_src == TRIG_TIMER 530 && cmd->scan_begin_arg != cmd->convert_arg * cmd->scan_end_arg) { 531 err++; 532 } 533 534 if (cmd->convert_src == TRIG_TIMER && cmd->convert_arg < MAX_SPEED) { 535 cmd->convert_arg = MAX_SPEED; 536 err++; 537 } 538 539 if (cmd->scan_end_arg != cmd->chanlist_len) { 540 cmd->scan_end_arg = cmd->chanlist_len; 541 err++; 542 } 543 if (cmd->stop_src == TRIG_COUNT) { 544 if (cmd->stop_arg > 0x00ffffff) { 545 cmd->stop_arg = 0x00ffffff; 546 err++; 547 } 548 } else { 549 /* TRIG_NONE */ 550 if (cmd->stop_arg != 0) { 551 cmd->stop_arg = 0; 552 err++; 553 } 554 } 555 556 if (err) 557 return 3; 558 559 /* step 4: fix up any arguments */ 560 561 if (cmd->scan_begin_src == TRIG_TIMER) { 562 tmp = cmd->scan_begin_arg; 563 daqp_ns_to_timer(&cmd->scan_begin_arg, 564 cmd->flags & TRIG_ROUND_MASK); 565 if (tmp != cmd->scan_begin_arg) 566 err++; 567 } 568 569 if (cmd->convert_src == TRIG_TIMER) { 570 tmp = cmd->convert_arg; 571 daqp_ns_to_timer(&cmd->convert_arg, 572 cmd->flags & TRIG_ROUND_MASK); 573 if (tmp != cmd->convert_arg) 574 err++; 575 } 576 577 if (err) 578 return 4; 579 580 return 0; 581} 582 583static int daqp_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s) 584{ 585 struct local_info_t *local = (struct local_info_t *)s->private; 586 struct comedi_cmd *cmd = &s->async->cmd; 587 int counter; 588 int scanlist_start_on_every_entry; 589 int threshold; 590 591 int i; 592 int v; 593 594 if (local->stop) 595 return -EIO; 596 597 598 /* Stop any running conversion */ 599 daqp_ai_cancel(dev, s); 600 601 outb(0, dev->iobase + DAQP_AUX); 602 603 /* Reset scan list queue */ 604 outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND); 605 606 /* Program pacer clock 607 * 608 * There's two modes we can operate in. If convert_src is 609 * TRIG_TIMER, then convert_arg specifies the time between 610 * each conversion, so we program the pacer clock to that 611 * frequency and set the SCANLIST_START bit on every scanlist 612 * entry. Otherwise, convert_src is TRIG_NOW, which means 613 * we want the fastest possible conversions, scan_begin_src 614 * is TRIG_TIMER, and scan_begin_arg specifies the time between 615 * each scan, so we program the pacer clock to this frequency 616 * and only set the SCANLIST_START bit on the first entry. 617 */ 618 619 if (cmd->convert_src == TRIG_TIMER) { 620 counter = daqp_ns_to_timer(&cmd->convert_arg, 621 cmd->flags & TRIG_ROUND_MASK); 622 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW); 623 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID); 624 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH); 625 scanlist_start_on_every_entry = 1; 626 } else { 627 counter = daqp_ns_to_timer(&cmd->scan_begin_arg, 628 cmd->flags & TRIG_ROUND_MASK); 629 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW); 630 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID); 631 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH); 632 scanlist_start_on_every_entry = 0; 633 } 634 635 /* Program scan list */ 636 637 for (i = 0; i < cmd->chanlist_len; i++) { 638 639 int chanspec = cmd->chanlist[i]; 640 641 /* Program one scan list entry */ 642 643 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(chanspec)) 644 | DAQP_SCANLIST_GAIN(CR_RANGE(chanspec)); 645 646 if (CR_AREF(chanspec) == AREF_DIFF) 647 v |= DAQP_SCANLIST_DIFFERENTIAL; 648 649 if (i == 0 || scanlist_start_on_every_entry) 650 v |= DAQP_SCANLIST_START; 651 652 outb(v & 0xff, dev->iobase + DAQP_SCANLIST); 653 outb(v >> 8, dev->iobase + DAQP_SCANLIST); 654 } 655 656 /* Now it's time to program the FIFO threshold, basically the 657 * number of samples the card will buffer before it interrupts 658 * the CPU. 659 * 660 * If we don't have a stop count, then use half the size of 661 * the FIFO (the manufacturer's recommendation). Consider 662 * that the FIFO can hold 2K samples (4K bytes). With the 663 * threshold set at half the FIFO size, we have a margin of 664 * error of 1024 samples. At the chip's maximum sample rate 665 * of 100,000 Hz, the CPU would have to delay interrupt 666 * service for a full 10 milliseconds in order to lose data 667 * here (as opposed to higher up in the kernel). I've never 668 * seen it happen. However, for slow sample rates it may 669 * buffer too much data and introduce too much delay for the 670 * user application. 671 * 672 * If we have a stop count, then things get more interesting. 673 * If the stop count is less than the FIFO size (actually 674 * three-quarters of the FIFO size - see below), we just use 675 * the stop count itself as the threshold, the card interrupts 676 * us when that many samples have been taken, and we kill the 677 * acquisition at that point and are done. If the stop count 678 * is larger than that, then we divide it by 2 until it's less 679 * than three quarters of the FIFO size (we always leave the 680 * top quarter of the FIFO as protection against sluggish CPU 681 * interrupt response) and use that as the threshold. So, if 682 * the stop count is 4000 samples, we divide by two twice to 683 * get 1000 samples, use that as the threshold, take four 684 * interrupts to get our 4000 samples and are done. 685 * 686 * The algorithm could be more clever. For example, if 81000 687 * samples are requested, we could set the threshold to 1500 688 * samples and take 54 interrupts to get 81000. But 54 isn't 689 * a power of two, so this algorithm won't find that option. 690 * Instead, it'll set the threshold at 1266 and take 64 691 * interrupts to get 81024 samples, of which the last 24 will 692 * be discarded... but we won't get the last interrupt until 693 * they've been collected. To find the first option, the 694 * computer could look at the prime decomposition of the 695 * sample count (81000 = 3^4 * 5^3 * 2^3) and factor it into a 696 * threshold (1500 = 3 * 5^3 * 2^2) and an interrupt count (54 697 * = 3^3 * 2). Hmmm... a one-line while loop or prime 698 * decomposition of integers... I'll leave it the way it is. 699 * 700 * I'll also note a mini-race condition before ignoring it in 701 * the code. Let's say we're taking 4000 samples, as before. 702 * After 1000 samples, we get an interrupt. But before that 703 * interrupt is completely serviced, another sample is taken 704 * and loaded into the FIFO. Since the interrupt handler 705 * empties the FIFO before returning, it will read 1001 samples. 706 * If that happens four times, we'll end up taking 4004 samples, 707 * not 4000. The interrupt handler will discard the extra four 708 * samples (by halting the acquisition with four samples still 709 * in the FIFO), but we will have to wait for them. 710 * 711 * In short, this code works pretty well, but for either of 712 * the two reasons noted, might end up waiting for a few more 713 * samples than actually requested. Shouldn't make too much 714 * of a difference. 715 */ 716 717 /* Save away the number of conversions we should perform, and 718 * compute the FIFO threshold (in bytes, not samples - that's 719 * why we multiple local->count by 2 = sizeof(sample)) 720 */ 721 722 if (cmd->stop_src == TRIG_COUNT) { 723 local->count = cmd->stop_arg * cmd->scan_end_arg; 724 threshold = 2 * local->count; 725 while (threshold > DAQP_FIFO_SIZE * 3 / 4) 726 threshold /= 2; 727 } else { 728 local->count = -1; 729 threshold = DAQP_FIFO_SIZE / 2; 730 } 731 732 /* Reset data FIFO (see page 28 of DAQP User's Manual) */ 733 734 outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND); 735 736 /* Set FIFO threshold. First two bytes are near-empty 737 * threshold, which is unused; next two bytes are near-full 738 * threshold. We computed the number of bytes we want in the 739 * FIFO when the interrupt is generated, what the card wants 740 * is actually the number of available bytes left in the FIFO 741 * when the interrupt is to happen. 742 */ 743 744 outb(0x00, dev->iobase + DAQP_FIFO); 745 outb(0x00, dev->iobase + DAQP_FIFO); 746 747 outb((DAQP_FIFO_SIZE - threshold) & 0xff, dev->iobase + DAQP_FIFO); 748 outb((DAQP_FIFO_SIZE - threshold) >> 8, dev->iobase + DAQP_FIFO); 749 750 /* Set trigger */ 751 752 v = DAQP_CONTROL_TRIGGER_CONTINUOUS | DAQP_CONTROL_TRIGGER_INTERNAL 753 | DAQP_CONTROL_PACER_5MHz | DAQP_CONTROL_FIFO_INT_ENABLE; 754 755 outb(v, dev->iobase + DAQP_CONTROL); 756 757 /* Reset any pending interrupts (my card has a tendancy to require 758 * require multiple reads on the status register to achieve this) 759 */ 760 counter = 100; 761 while (--counter 762 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ; 763 if (!counter) { 764 printk(KERN_ERR 765 "daqp: couldn't clear interrupts in status register\n"); 766 return -1; 767 } 768 769 local->interrupt_mode = buffer; 770 local->dev = dev; 771 local->s = s; 772 773 /* Start conversion */ 774 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA, 775 dev->iobase + DAQP_COMMAND); 776 777 return 0; 778} 779 780/* Single-shot analog output routine */ 781 782static int daqp_ao_insn_write(struct comedi_device *dev, 783 struct comedi_subdevice *s, 784 struct comedi_insn *insn, unsigned int *data) 785{ 786 struct local_info_t *local = (struct local_info_t *)s->private; 787 int d; 788 unsigned int chan; 789 790 if (local->stop) 791 return -EIO; 792 793 chan = CR_CHAN(insn->chanspec); 794 d = data[0]; 795 d &= 0x0fff; 796 d ^= 0x0800; /* Flip the sign */ 797 d |= chan << 12; 798 799 /* Make sure D/A update mode is direct update */ 800 outb(0, dev->iobase + DAQP_AUX); 801 802 outw(d, dev->iobase + DAQP_DA); 803 804 return 1; 805} 806 807/* Digital input routine */ 808 809static int daqp_di_insn_read(struct comedi_device *dev, 810 struct comedi_subdevice *s, 811 struct comedi_insn *insn, unsigned int *data) 812{ 813 struct local_info_t *local = (struct local_info_t *)s->private; 814 815 if (local->stop) 816 return -EIO; 817 818 data[0] = inb(dev->iobase + DAQP_DIGITAL_IO); 819 820 return 1; 821} 822 823/* Digital output routine */ 824 825static int daqp_do_insn_write(struct comedi_device *dev, 826 struct comedi_subdevice *s, 827 struct comedi_insn *insn, unsigned int *data) 828{ 829 struct local_info_t *local = (struct local_info_t *)s->private; 830 831 if (local->stop) 832 return -EIO; 833 834 outw(data[0] & 0xf, dev->iobase + DAQP_DIGITAL_IO); 835 836 return 1; 837} 838 839/* daqp_attach is called via comedi_config to attach a comedi device 840 * to a /dev/comedi*. Note that this is different from daqp_cs_attach() 841 * which is called by the pcmcia subsystem to attach the PCMCIA card 842 * when it is inserted. 843 */ 844 845static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it) 846{ 847 int ret; 848 struct local_info_t *local = dev_table[it->options[0]]; 849 struct comedi_subdevice *s; 850 851 if (it->options[0] < 0 || it->options[0] >= MAX_DEV || !local) { 852 printk("comedi%d: No such daqp device %d\n", 853 dev->minor, it->options[0]); 854 return -EIO; 855 } 856 857 /* Typically brittle code that I don't completely understand, 858 * but "it works on my card". The intent is to pull the model 859 * number of the card out the PCMCIA CIS and stash it away as 860 * the COMEDI board_name. Looks like the third field in 861 * CISTPL_VERS_1 (offset 2) holds what we're looking for. If 862 * it doesn't work, who cares, just leave it as "DAQP". 863 */ 864 865 strcpy(local->board_name, "DAQP"); 866 dev->board_name = local->board_name; 867 if (local->link->prod_id[2]) { 868 if (strncmp(local->link->prod_id[2], "DAQP", 4) == 0) { 869 strncpy(local->board_name, local->link->prod_id[2], 870 sizeof(local->board_name)); 871 } 872 } 873 874 dev->iobase = local->link->io.BasePort1; 875 876 ret = alloc_subdevices(dev, 4); 877 if (ret < 0) 878 return ret; 879 880 printk(KERN_INFO "comedi%d: attaching daqp%d (io 0x%04lx)\n", 881 dev->minor, it->options[0], dev->iobase); 882 883 s = dev->subdevices + 0; 884 dev->read_subdev = s; 885 s->private = local; 886 s->type = COMEDI_SUBD_AI; 887 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ; 888 s->n_chan = 8; 889 s->len_chanlist = 2048; 890 s->maxdata = 0xffff; 891 s->range_table = &range_daqp_ai; 892 s->insn_read = daqp_ai_insn_read; 893 s->do_cmdtest = daqp_ai_cmdtest; 894 s->do_cmd = daqp_ai_cmd; 895 s->cancel = daqp_ai_cancel; 896 897 s = dev->subdevices + 1; 898 dev->write_subdev = s; 899 s->private = local; 900 s->type = COMEDI_SUBD_AO; 901 s->subdev_flags = SDF_WRITEABLE; 902 s->n_chan = 2; 903 s->len_chanlist = 1; 904 s->maxdata = 0x0fff; 905 s->range_table = &range_daqp_ao; 906 s->insn_write = daqp_ao_insn_write; 907 908 s = dev->subdevices + 2; 909 s->private = local; 910 s->type = COMEDI_SUBD_DI; 911 s->subdev_flags = SDF_READABLE; 912 s->n_chan = 1; 913 s->len_chanlist = 1; 914 s->insn_read = daqp_di_insn_read; 915 916 s = dev->subdevices + 3; 917 s->private = local; 918 s->type = COMEDI_SUBD_DO; 919 s->subdev_flags = SDF_WRITEABLE; 920 s->n_chan = 1; 921 s->len_chanlist = 1; 922 s->insn_write = daqp_do_insn_write; 923 924 return 1; 925} 926 927/* daqp_detach (called from comedi_comdig) does nothing. If the PCMCIA 928 * card is removed, daqp_cs_detach() is called by the pcmcia subsystem. 929 */ 930 931static int daqp_detach(struct comedi_device *dev) 932{ 933 printk(KERN_INFO "comedi%d: detaching daqp\n", dev->minor); 934 935 return 0; 936} 937 938/*==================================================================== 939 940 PCMCIA interface code 941 942 The rest of the code in this file is based on dummy_cs.c v1.24 943 from the Linux pcmcia_cs distribution v3.1.8 and is subject 944 to the following license agreement. 945 946 The remaining contents of this file are subject to the Mozilla Public 947 License Version 1.1 (the "License"); you may not use this file 948 except in compliance with the License. You may obtain a copy of 949 the License at http://www.mozilla.org/MPL/ 950 951 Software distributed under the License is distributed on an "AS 952 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 953 implied. See the License for the specific language governing 954 rights and limitations under the License. 955 956 The initial developer of the original code is David A. Hinds 957 <dhinds@pcmcia.sourceforge.org>. Portions created by David A. Hinds 958 are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 959 960 Alternatively, the contents of this file may be used under the 961 terms of the GNU Public License version 2 (the "GPL"), in which 962 case the provisions of the GPL are applicable instead of the 963 above. If you wish to allow the use of your version of this file 964 only under the terms of the GPL and not to allow others to use 965 your version of this file under the MPL, indicate your decision 966 by deleting the provisions above and replace them with the notice 967 and other provisions required by the GPL. If you do not delete 968 the provisions above, a recipient may use your version of this 969 file under either the MPL or the GPL. 970 971======================================================================*/ 972 973/* 974 The event() function is this driver's Card Services event handler. 975 It will be called by Card Services when an appropriate card status 976 event is received. The config() and release() entry points are 977 used to configure or release a socket, in response to card 978 insertion and ejection events. 979 980 Kernel version 2.6.16 upwards uses suspend() and resume() functions 981 instead of an event() function. 982*/ 983 984static void daqp_cs_config(struct pcmcia_device *link); 985static void daqp_cs_release(struct pcmcia_device *link); 986static int daqp_cs_suspend(struct pcmcia_device *p_dev); 987static int daqp_cs_resume(struct pcmcia_device *p_dev); 988 989/* 990 The attach() and detach() entry points are used to create and destroy 991 "instances" of the driver, where each instance represents everything 992 needed to manage one actual PCMCIA card. 993*/ 994 995static int daqp_cs_attach(struct pcmcia_device *); 996static void daqp_cs_detach(struct pcmcia_device *); 997 998/* 999 The dev_info variable is the "key" that is used to match up this 1000 device driver with appropriate cards, through the card configuration 1001 database. 1002*/ 1003 1004static const dev_info_t dev_info = "quatech_daqp_cs"; 1005 1006/*====================================================================== 1007 1008 daqp_cs_attach() creates an "instance" of the driver, allocating 1009 local data structures for one device. The device is registered 1010 with Card Services. 1011 1012 The dev_link structure is initialized, but we don't actually 1013 configure the card at this point -- we wait until we receive a 1014 card insertion event. 1015 1016======================================================================*/ 1017 1018static int daqp_cs_attach(struct pcmcia_device *link) 1019{ 1020 struct local_info_t *local; 1021 int i; 1022 1023 dev_dbg(&link->dev, "daqp_cs_attach()\n"); 1024 1025 for (i = 0; i < MAX_DEV; i++) 1026 if (dev_table[i] == NULL) 1027 break; 1028 if (i == MAX_DEV) { 1029 printk(KERN_NOTICE "daqp_cs: no devices available\n"); 1030 return -ENODEV; 1031 } 1032 1033 /* Allocate space for private device-specific data */ 1034 local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL); 1035 if (!local) 1036 return -ENOMEM; 1037 1038 local->table_index = i; 1039 dev_table[i] = local; 1040 local->link = link; 1041 link->priv = local; 1042 1043 /* 1044 General socket configuration defaults can go here. In this 1045 client, we assume very little, and rely on the CIS for almost 1046 everything. In most clients, many details (i.e., number, sizes, 1047 and attributes of IO windows) are fixed by the nature of the 1048 device, and can be hard-wired here. 1049 */ 1050 link->conf.Attributes = 0; 1051 link->conf.IntType = INT_MEMORY_AND_IO; 1052 1053 daqp_cs_config(link); 1054 1055 return 0; 1056} /* daqp_cs_attach */ 1057 1058/*====================================================================== 1059 1060 This deletes a driver "instance". The device is de-registered 1061 with Card Services. If it has been released, all local data 1062 structures are freed. Otherwise, the structures will be freed 1063 when the device is released. 1064 1065======================================================================*/ 1066 1067static void daqp_cs_detach(struct pcmcia_device *link) 1068{ 1069 struct local_info_t *dev = link->priv; 1070 1071 dev_dbg(&link->dev, "daqp_cs_detach\n"); 1072 1073 dev->stop = 1; 1074 daqp_cs_release(link); 1075 1076 /* Unlink device structure, and free it */ 1077 dev_table[dev->table_index] = NULL; 1078 kfree(dev); 1079 1080} /* daqp_cs_detach */ 1081 1082/*====================================================================== 1083 1084 daqp_cs_config() is scheduled to run after a CARD_INSERTION event 1085 is received, to configure the PCMCIA socket, and to make the 1086 device available to the system. 1087 1088======================================================================*/ 1089 1090 1091static int daqp_pcmcia_config_loop(struct pcmcia_device *p_dev, 1092 cistpl_cftable_entry_t *cfg, 1093 cistpl_cftable_entry_t *dflt, 1094 unsigned int vcc, 1095 void *priv_data) 1096{ 1097 if (cfg->index == 0) 1098 return -ENODEV; 1099 1100 /* Do we need to allocate an interrupt? */ 1101 p_dev->conf.Attributes |= CONF_ENABLE_IRQ; 1102 1103 /* IO window settings */ 1104 p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0; 1105 if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) { 1106 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io; 1107 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; 1108 if (!(io->flags & CISTPL_IO_8BIT)) 1109 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16; 1110 if (!(io->flags & CISTPL_IO_16BIT)) 1111 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 1112 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK; 1113 p_dev->io.BasePort1 = io->win[0].base; 1114 p_dev->io.NumPorts1 = io->win[0].len; 1115 if (io->nwin > 1) { 1116 p_dev->io.Attributes2 = p_dev->io.Attributes1; 1117 p_dev->io.BasePort2 = io->win[1].base; 1118 p_dev->io.NumPorts2 = io->win[1].len; 1119 } 1120 } 1121 1122 /* This reserves IO space but doesn't actually enable it */ 1123 return pcmcia_request_io(p_dev, &p_dev->io); 1124} 1125 1126static void daqp_cs_config(struct pcmcia_device *link) 1127{ 1128 int ret; 1129 1130 dev_dbg(&link->dev, "daqp_cs_config\n"); 1131 1132 ret = pcmcia_loop_config(link, daqp_pcmcia_config_loop, NULL); 1133 if (ret) { 1134 dev_warn(&link->dev, "no configuration found\n"); 1135 goto failed; 1136 } 1137 1138 ret = pcmcia_request_irq(link, daqp_interrupt); 1139 if (ret) 1140 goto failed; 1141 1142 /* 1143 This actually configures the PCMCIA socket -- setting up 1144 the I/O windows and the interrupt mapping, and putting the 1145 card and host interface into "Memory and IO" mode. 1146 */ 1147 ret = pcmcia_request_configuration(link, &link->conf); 1148 if (ret) 1149 goto failed; 1150 1151 /* Finally, report what we've done */ 1152 dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex); 1153 if (link->conf.Attributes & CONF_ENABLE_IRQ) 1154 printk(KERN_INFO ", irq %u", link->irq); 1155 if (link->io.NumPorts1) 1156 printk(", io 0x%04x-0x%04x", link->io.BasePort1, 1157 link->io.BasePort1 + link->io.NumPorts1 - 1); 1158 if (link->io.NumPorts2) 1159 printk(" & 0x%04x-0x%04x", link->io.BasePort2, 1160 link->io.BasePort2 + link->io.NumPorts2 - 1); 1161 printk("\n"); 1162 1163 return; 1164 1165failed: 1166 daqp_cs_release(link); 1167 1168} /* daqp_cs_config */ 1169 1170static void daqp_cs_release(struct pcmcia_device *link) 1171{ 1172 dev_dbg(&link->dev, "daqp_cs_release\n"); 1173 1174 pcmcia_disable_device(link); 1175} /* daqp_cs_release */ 1176 1177/*====================================================================== 1178 1179 The card status event handler. Mostly, this schedules other 1180 stuff to run after an event is received. 1181 1182 When a CARD_REMOVAL event is received, we immediately set a 1183 private flag to block future accesses to this device. All the 1184 functions that actually access the device should check this flag 1185 to make sure the card is still present. 1186 1187======================================================================*/ 1188 1189static int daqp_cs_suspend(struct pcmcia_device *link) 1190{ 1191 struct local_info_t *local = link->priv; 1192 1193 /* Mark the device as stopped, to block IO until later */ 1194 local->stop = 1; 1195 return 0; 1196} 1197 1198static int daqp_cs_resume(struct pcmcia_device *link) 1199{ 1200 struct local_info_t *local = link->priv; 1201 1202 local->stop = 0; 1203 1204 return 0; 1205} 1206 1207/*====================================================================*/ 1208 1209#ifdef MODULE 1210 1211static struct pcmcia_device_id daqp_cs_id_table[] = { 1212 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0027), 1213 PCMCIA_DEVICE_NULL 1214}; 1215 1216MODULE_DEVICE_TABLE(pcmcia, daqp_cs_id_table); 1217MODULE_AUTHOR("Brent Baccala <baccala@freesoft.org>"); 1218MODULE_DESCRIPTION("Comedi driver for Quatech DAQP PCMCIA data capture cards"); 1219MODULE_LICENSE("GPL"); 1220 1221static struct pcmcia_driver daqp_cs_driver = { 1222 .probe = daqp_cs_attach, 1223 .remove = daqp_cs_detach, 1224 .suspend = daqp_cs_suspend, 1225 .resume = daqp_cs_resume, 1226 .id_table = daqp_cs_id_table, 1227 .owner = THIS_MODULE, 1228 .drv = { 1229 .name = dev_info, 1230 }, 1231}; 1232 1233int __init init_module(void) 1234{ 1235 pcmcia_register_driver(&daqp_cs_driver); 1236 comedi_driver_register(&driver_daqp); 1237 return 0; 1238} 1239 1240void __exit cleanup_module(void) 1241{ 1242 comedi_driver_unregister(&driver_daqp); 1243 pcmcia_unregister_driver(&daqp_cs_driver); 1244} 1245 1246#endif 1247