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