das16.c revision c3744138715045adb316284ee7a1e608f0278f6c
1/* 2 comedi/drivers/das16.c 3 DAS16 driver 4 5 COMEDI - Linux Control and Measurement Device Interface 6 Copyright (C) 2000 David A. Schleef <ds@schleef.org> 7 Copyright (C) 2000 Chris R. Baugher <baugher@enteract.com> 8 Copyright (C) 2001,2002 Frank Mori Hess <fmhess@users.sourceforge.net> 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 23 24************************************************************************ 25*/ 26/* 27Driver: das16 28Description: DAS16 compatible boards 29Author: Sam Moore, Warren Jasper, ds, Chris Baugher, Frank Hess, Roman Fietze 30Devices: [Keithley Metrabyte] DAS-16 (das-16), DAS-16G (das-16g), 31 DAS-16F (das-16f), DAS-1201 (das-1201), DAS-1202 (das-1202), 32 DAS-1401 (das-1401), DAS-1402 (das-1402), DAS-1601 (das-1601), 33 DAS-1602 (das-1602), 34 [ComputerBoards] PC104-DAS16/JR (pc104-das16jr), 35 PC104-DAS16JR/16 (pc104-das16jr/16), 36 CIO-DAS16JR/16 (cio-das16jr/16), 37 CIO-DAS16/JR (cio-das16/jr), CIO-DAS1401/12 (cio-das1401/12), 38 CIO-DAS1402/12 (cio-das1402/12), CIO-DAS1402/16 (cio-das1402/16), 39 CIO-DAS1601/12 (cio-das1601/12), CIO-DAS1602/12 (cio-das1602/12), 40 CIO-DAS1602/16 (cio-das1602/16), CIO-DAS16/330 (cio-das16/330) 41Status: works 42Updated: 2003-10-12 43 44A rewrite of the das16 and das1600 drivers. 45Options: 46 [0] - base io address 47 [1] - irq (does nothing, irq is not used anymore) 48 [2] - dma (optional, required for comedi_command support) 49 [3] - master clock speed in MHz (optional, 1 or 10, ignored if 50 board can probe clock, defaults to 1) 51 [4] - analog input range lowest voltage in microvolts (optional, 52 only useful if your board does not have software 53 programmable gain) 54 [5] - analog input range highest voltage in microvolts (optional, 55 only useful if board does not have software programmable 56 gain) 57 [6] - analog output range lowest voltage in microvolts (optional) 58 [7] - analog output range highest voltage in microvolts (optional) 59 [8] - use timer mode for DMA. Timer mode is needed e.g. for 60 buggy DMA controllers in NS CS5530A (Geode Companion), and for 61 'jr' cards that lack a hardware fifo. This option is no 62 longer needed, since timer mode is _always_ used. 63 64Passing a zero for an option is the same as leaving it unspecified. 65 66*/ 67/* 68 69Testing and debugging help provided by Daniel Koch. 70 71Keithley Manuals: 72 2309.PDF (das16) 73 4919.PDF (das1400, 1600) 74 4922.PDF (das-1400) 75 4923.PDF (das1200, 1400, 1600) 76 77Computer boards manuals also available from their website www.measurementcomputing.com 78 79*/ 80 81#include <linux/pci.h> 82#include <asm/dma.h> 83#include "../comedidev.h" 84 85#include "8253.h" 86#include "8255.h" 87#include "comedi_fc.h" 88 89#undef DEBUG 90/* #define DEBUG */ 91 92#ifdef DEBUG 93#define DEBUG_PRINT(format, args...) rt_printk("das16: " format, ## args) 94#else 95#define DEBUG_PRINT(format, args...) 96#endif 97 98#define DAS16_SIZE 20 /* number of ioports */ 99#define DAS16_DMA_SIZE 0xff00 /* size in bytes of allocated dma buffer */ 100 101/* 102 cio-das16.pdf 103 104 "das16" 105 "das16/f" 106 107 0 a/d bits 0-3 start 12 bit 108 1 a/d bits 4-11 unused 109 2 mux read mux set 110 3 di 4 bit do 4 bit 111 4 unused ao0_lsb 112 5 unused ao0_msb 113 6 unused ao1_lsb 114 7 unused ao1_msb 115 8 status eoc uni/bip interrupt reset 116 9 dma, int, trig ctrl set dma, int 117 a pacer control unused 118 b reserved reserved 119 cdef 8254 120 0123 8255 121 122*/ 123 124/* 125 cio-das16jr.pdf 126 127 "das16jr" 128 129 0 a/d bits 0-3 start 12 bit 130 1 a/d bits 4-11 unused 131 2 mux read mux set 132 3 di 4 bit do 4 bit 133 4567 unused unused 134 8 status eoc uni/bip interrupt reset 135 9 dma, int, trig ctrl set dma, int 136 a pacer control unused 137 b gain status gain control 138 cdef 8254 139 140*/ 141 142/* 143 cio-das16jr_16.pdf 144 145 "das16jr_16" 146 147 0 a/d bits 0-7 start 16 bit 148 1 a/d bits 8-15 unused 149 2 mux read mux set 150 3 di 4 bit do 4 bit 151 4567 unused unused 152 8 status eoc uni/bip interrupt reset 153 9 dma, int, trig ctrl set dma, int 154 a pacer control unused 155 b gain status gain control 156 cdef 8254 157 158*/ 159/* 160 cio-das160x-1x.pdf 161 162 "das1601/12" 163 "das1602/12" 164 "das1602/16" 165 166 0 a/d bits 0-3 start 12 bit 167 1 a/d bits 4-11 unused 168 2 mux read mux set 169 3 di 4 bit do 4 bit 170 4 unused ao0_lsb 171 5 unused ao0_msb 172 6 unused ao1_lsb 173 7 unused ao1_msb 174 8 status eoc uni/bip interrupt reset 175 9 dma, int, trig ctrl set dma, int 176 a pacer control unused 177 b gain status gain control 178 cdef 8254 179 400 8255 180 404 unused conversion enable 181 405 unused burst enable 182 406 unused das1600 enable 183 407 status 184 185*/ 186 187static const int sample_size = 2; /* size in bytes of a sample from board */ 188 189#define DAS16_TRIG 0 190#define DAS16_AI_LSB 0 191#define DAS16_AI_MSB 1 192#define DAS16_MUX 2 193#define DAS16_DIO 3 194#define DAS16_AO_LSB(x) ((x)?6:4) 195#define DAS16_AO_MSB(x) ((x)?7:5) 196#define DAS16_STATUS 8 197#define BUSY (1<<7) 198#define UNIPOLAR (1<<6) 199#define DAS16_MUXBIT (1<<5) 200#define DAS16_INT (1<<4) 201#define DAS16_CONTROL 9 202#define DAS16_INTE (1<<7) 203#define DAS16_IRQ(x) (((x) & 0x7) << 4) 204#define DMA_ENABLE (1<<2) 205#define PACING_MASK 0x3 206#define INT_PACER 0x03 207#define EXT_PACER 0x02 208#define DAS16_SOFT 0x00 209#define DAS16_PACER 0x0A 210#define DAS16_CTR0 (1<<1) 211#define DAS16_TRIG0 (1<<0) 212#define BURST_LEN_BITS(x) (((x) & 0xf) << 4) 213#define DAS16_GAIN 0x0B 214#define DAS16_CNTR0_DATA 0x0C 215#define DAS16_CNTR1_DATA 0x0D 216#define DAS16_CNTR2_DATA 0x0E 217#define DAS16_CNTR_CONTROL 0x0F 218#define DAS16_TERM_CNT 0x00 219#define DAS16_ONE_SHOT 0x02 220#define DAS16_RATE_GEN 0x04 221#define DAS16_CNTR_LSB_MSB 0x30 222#define DAS16_CNTR0 0x00 223#define DAS16_CNTR1 0x40 224#define DAS16_CNTR2 0x80 225 226#define DAS1600_CONV 0x404 227#define DAS1600_CONV_DISABLE 0x40 228#define DAS1600_BURST 0x405 229#define DAS1600_BURST_VAL 0x40 230#define DAS1600_ENABLE 0x406 231#define DAS1600_ENABLE_VAL 0x40 232#define DAS1600_STATUS_B 0x407 233#define DAS1600_BME 0x40 234#define DAS1600_ME 0x20 235#define DAS1600_CD 0x10 236#define DAS1600_WS 0x02 237#define DAS1600_CLK_10MHZ 0x01 238 239static const struct comedi_lrange range_das1x01_bip = { 4, { 240 BIP_RANGE(10), 241 BIP_RANGE(1), 242 BIP_RANGE(0.1), 243 BIP_RANGE(0.01), 244 } 245}; 246static const struct comedi_lrange range_das1x01_unip = { 4, { 247 UNI_RANGE(10), 248 UNI_RANGE(1), 249 UNI_RANGE(0.1), 250 UNI_RANGE(0.01), 251 } 252}; 253static const struct comedi_lrange range_das1x02_bip = { 4, { 254 BIP_RANGE(10), 255 BIP_RANGE(5), 256 BIP_RANGE(2.5), 257 BIP_RANGE(1.25), 258 } 259}; 260static const struct comedi_lrange range_das1x02_unip = { 4, { 261 UNI_RANGE(10), 262 UNI_RANGE(5), 263 UNI_RANGE(2.5), 264 UNI_RANGE(1.25), 265 } 266}; 267static const struct comedi_lrange range_das16jr = { 9, { 268 /* also used by 16/330 */ 269 BIP_RANGE(10), 270 BIP_RANGE(5), 271 BIP_RANGE(2.5), 272 BIP_RANGE(1.25), 273 BIP_RANGE(0.625), 274 UNI_RANGE(10), 275 UNI_RANGE(5), 276 UNI_RANGE(2.5), 277 UNI_RANGE(1.25), 278 } 279}; 280static const struct comedi_lrange range_das16jr_16 = { 8, { 281 BIP_RANGE(10), 282 BIP_RANGE(5), 283 BIP_RANGE(2.5), 284 BIP_RANGE(1.25), 285 UNI_RANGE(10), 286 UNI_RANGE(5), 287 UNI_RANGE(2.5), 288 UNI_RANGE(1.25), 289 } 290}; 291 292static const int das16jr_gainlist[] = { 8, 0, 1, 2, 3, 4, 5, 6, 7 }; 293static const int das16jr_16_gainlist[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; 294static const int das1600_gainlist[] = { 0, 1, 2, 3 }; 295enum { 296 das16_pg_none = 0, 297 das16_pg_16jr, 298 das16_pg_16jr_16, 299 das16_pg_1601, 300 das16_pg_1602, 301}; 302static const int *const das16_gainlists[] = { 303 NULL, 304 das16jr_gainlist, 305 das16jr_16_gainlist, 306 das1600_gainlist, 307 das1600_gainlist, 308}; 309static const struct comedi_lrange *const das16_ai_uni_lranges[] = { 310 &range_unknown, 311 &range_das16jr, 312 &range_das16jr_16, 313 &range_das1x01_unip, 314 &range_das1x02_unip, 315}; 316static const struct comedi_lrange *const das16_ai_bip_lranges[] = { 317 &range_unknown, 318 &range_das16jr, 319 &range_das16jr_16, 320 &range_das1x01_bip, 321 &range_das1x02_bip, 322}; 323 324struct munge_info { 325 uint8_t byte; 326 unsigned have_byte:1; 327}; 328 329static int das16_ao_winsn(struct comedi_device * dev, struct comedi_subdevice * s, 330 struct comedi_insn * insn, unsigned int * data); 331static int das16_do_wbits(struct comedi_device * dev, struct comedi_subdevice * s, 332 struct comedi_insn * insn, unsigned int * data); 333static int das16_di_rbits(struct comedi_device * dev, struct comedi_subdevice * s, 334 struct comedi_insn * insn, unsigned int * data); 335static int das16_ai_rinsn(struct comedi_device * dev, struct comedi_subdevice * s, 336 struct comedi_insn * insn, unsigned int * data); 337 338static int das16_cmd_test(struct comedi_device * dev, struct comedi_subdevice * s, 339 struct comedi_cmd * cmd); 340static int das16_cmd_exec(struct comedi_device * dev, struct comedi_subdevice * s); 341static int das16_cancel(struct comedi_device * dev, struct comedi_subdevice * s); 342static void das16_ai_munge(struct comedi_device * dev, struct comedi_subdevice * s, 343 void *array, unsigned int num_bytes, unsigned int start_chan_index); 344 345static void das16_reset(struct comedi_device * dev); 346static irqreturn_t das16_dma_interrupt(int irq, void *d); 347static void das16_timer_interrupt(unsigned long arg); 348static void das16_interrupt(struct comedi_device * dev); 349 350static unsigned int das16_set_pacer(struct comedi_device * dev, unsigned int ns, 351 int flags); 352static int das1600_mode_detect(struct comedi_device * dev); 353static unsigned int das16_suggest_transfer_size(struct comedi_device * dev, 354 struct comedi_cmd cmd); 355 356static void reg_dump(struct comedi_device * dev); 357 358struct das16_board { 359 const char *name; 360 void *ai; 361 unsigned int ai_nbits; 362 unsigned int ai_speed; /* max conversion speed in nanosec */ 363 unsigned int ai_pg; 364 void *ao; 365 unsigned int ao_nbits; 366 void *di; 367 void *do_; 368 369 unsigned int i8255_offset; 370 unsigned int i8254_offset; 371 372 unsigned int size; 373 unsigned int id; 374}; 375 376static const struct das16_board das16_boards[] = { 377 { 378 name: "das-16", 379 ai: das16_ai_rinsn, 380 ai_nbits:12, 381 ai_speed:15000, 382 ai_pg: das16_pg_none, 383 ao: das16_ao_winsn, 384 ao_nbits:12, 385 di: das16_di_rbits, 386 do_: das16_do_wbits, 387 i8255_offset:0x10, 388 i8254_offset:0x0c, 389 size: 0x14, 390 id: 0x00, 391 }, 392 { 393 name: "das-16g", 394 ai: das16_ai_rinsn, 395 ai_nbits:12, 396 ai_speed:15000, 397 ai_pg: das16_pg_none, 398 ao: das16_ao_winsn, 399 ao_nbits:12, 400 di: das16_di_rbits, 401 do_: das16_do_wbits, 402 i8255_offset:0x10, 403 i8254_offset:0x0c, 404 size: 0x14, 405 id: 0x00, 406 }, 407 { 408 name: "das-16f", 409 ai: das16_ai_rinsn, 410 ai_nbits:12, 411 ai_speed:8500, 412 ai_pg: das16_pg_none, 413 ao: das16_ao_winsn, 414 ao_nbits:12, 415 di: das16_di_rbits, 416 do_: das16_do_wbits, 417 i8255_offset:0x10, 418 i8254_offset:0x0c, 419 size: 0x14, 420 id: 0x00, 421 }, 422 { 423 name: "cio-das16", /* cio-das16.pdf */ 424 ai: das16_ai_rinsn, 425 ai_nbits:12, 426 ai_speed:20000, 427 ai_pg: das16_pg_none, 428 ao: das16_ao_winsn, 429 ao_nbits:12, 430 di: das16_di_rbits, 431 do_: das16_do_wbits, 432 i8255_offset:0x10, 433 i8254_offset:0x0c, 434 size: 0x14, 435 id: 0x80, 436 }, 437 { 438 name: "cio-das16/f", /* das16.pdf */ 439 ai: das16_ai_rinsn, 440 ai_nbits:12, 441 ai_speed:10000, 442 ai_pg: das16_pg_none, 443 ao: das16_ao_winsn, 444 ao_nbits:12, 445 di: das16_di_rbits, 446 do_: das16_do_wbits, 447 i8255_offset:0x10, 448 i8254_offset:0x0c, 449 size: 0x14, 450 id: 0x80, 451 }, 452 { 453 name: "cio-das16/jr", /* cio-das16jr.pdf */ 454 ai: das16_ai_rinsn, 455 ai_nbits:12, 456 ai_speed:7692, 457 ai_pg: das16_pg_16jr, 458 ao: NULL, 459 di: das16_di_rbits, 460 do_: das16_do_wbits, 461 i8255_offset:0, 462 i8254_offset:0x0c, 463 size: 0x10, 464 id: 0x00, 465 }, 466 { 467 name: "pc104-das16jr", /* pc104-das16jr_xx.pdf */ 468 ai: das16_ai_rinsn, 469 ai_nbits:12, 470 ai_speed:3300, 471 ai_pg: das16_pg_16jr, 472 ao: NULL, 473 di: das16_di_rbits, 474 do_: das16_do_wbits, 475 i8255_offset:0, 476 i8254_offset:0x0c, 477 size: 0x10, 478 id: 0x00, 479 }, 480 { 481 name: "cio-das16jr/16", /* cio-das16jr_16.pdf */ 482 ai: das16_ai_rinsn, 483 ai_nbits:16, 484 ai_speed:10000, 485 ai_pg: das16_pg_16jr_16, 486 ao: NULL, 487 di: das16_di_rbits, 488 do_: das16_do_wbits, 489 i8255_offset:0, 490 i8254_offset:0x0c, 491 size: 0x10, 492 id: 0x00, 493 }, 494 { 495 name: "pc104-das16jr/16", /* pc104-das16jr_xx.pdf */ 496 ai: das16_ai_rinsn, 497 ai_nbits:16, 498 ai_speed:10000, 499 ai_pg: das16_pg_16jr_16, 500 ao: NULL, 501 di: das16_di_rbits, 502 do_: das16_do_wbits, 503 i8255_offset:0, 504 i8254_offset:0x0c, 505 size: 0x10, 506 id: 0x00, 507 }, 508 { 509 name: "das-1201", /* 4924.pdf (keithley user's manual) */ 510 ai: das16_ai_rinsn, 511 ai_nbits:12, 512 ai_speed:20000, 513 ai_pg: das16_pg_none, 514 ao: NULL, 515 di: das16_di_rbits, 516 do_: das16_do_wbits, 517 i8255_offset:0x400, 518 i8254_offset:0x0c, 519 size: 0x408, 520 id: 0x20, 521 }, 522 { 523 name: "das-1202", /* 4924.pdf (keithley user's manual) */ 524 ai: das16_ai_rinsn, 525 ai_nbits:12, 526 ai_speed:10000, 527 ai_pg: das16_pg_none, 528 ao: NULL, 529 di: das16_di_rbits, 530 do_: das16_do_wbits, 531 i8255_offset:0x400, 532 i8254_offset:0x0c, 533 size: 0x408, 534 id: 0x20, 535 }, 536 { 537 name: "das-1401", /* 4919.pdf and 4922.pdf (keithley user's manual) */ 538 ai: das16_ai_rinsn, 539 ai_nbits:12, 540 ai_speed:10000, 541 ai_pg: das16_pg_1601, 542 ao: NULL, 543 di: das16_di_rbits, 544 do_: das16_do_wbits, 545 i8255_offset:0x0, 546 i8254_offset:0x0c, 547 size: 0x408, 548 id: 0xc0 /* 4919.pdf says id bits are 0xe0, 4922.pdf says 0xc0 */ 549 }, 550 { 551 name: "das-1402", /* 4919.pdf and 4922.pdf (keithley user's manual) */ 552 ai: das16_ai_rinsn, 553 ai_nbits:12, 554 ai_speed:10000, 555 ai_pg: das16_pg_1602, 556 ao: NULL, 557 di: das16_di_rbits, 558 do_: das16_do_wbits, 559 i8255_offset:0x0, 560 i8254_offset:0x0c, 561 size: 0x408, 562 id: 0xc0 /* 4919.pdf says id bits are 0xe0, 4922.pdf says 0xc0 */ 563 }, 564 { 565 name: "das-1601", /* 4919.pdf */ 566 ai: das16_ai_rinsn, 567 ai_nbits:12, 568 ai_speed:10000, 569 ai_pg: das16_pg_1601, 570 ao: das16_ao_winsn, 571 ao_nbits:12, 572 di: das16_di_rbits, 573 do_: das16_do_wbits, 574 i8255_offset:0x400, 575 i8254_offset:0x0c, 576 size: 0x408, 577 id: 0xc0}, 578 { 579 name: "das-1602", /* 4919.pdf */ 580 ai: das16_ai_rinsn, 581 ai_nbits:12, 582 ai_speed:10000, 583 ai_pg: das16_pg_1602, 584 ao: das16_ao_winsn, 585 ao_nbits:12, 586 di: das16_di_rbits, 587 do_: das16_do_wbits, 588 i8255_offset:0x400, 589 i8254_offset:0x0c, 590 size: 0x408, 591 id: 0xc0}, 592 { 593 name: "cio-das1401/12", /* cio-das1400_series.pdf */ 594 ai: das16_ai_rinsn, 595 ai_nbits:12, 596 ai_speed:6250, 597 ai_pg: das16_pg_1601, 598 ao: NULL, 599 di: das16_di_rbits, 600 do_: das16_do_wbits, 601 i8255_offset:0, 602 i8254_offset:0x0c, 603 size: 0x408, 604 id: 0xc0}, 605 { 606 name: "cio-das1402/12", /* cio-das1400_series.pdf */ 607 ai: das16_ai_rinsn, 608 ai_nbits:12, 609 ai_speed:6250, 610 ai_pg: das16_pg_1602, 611 ao: NULL, 612 di: das16_di_rbits, 613 do_: das16_do_wbits, 614 i8255_offset:0, 615 i8254_offset:0x0c, 616 size: 0x408, 617 id: 0xc0}, 618 { 619 name: "cio-das1402/16", /* cio-das1400_series.pdf */ 620 ai: das16_ai_rinsn, 621 ai_nbits:16, 622 ai_speed:10000, 623 ai_pg: das16_pg_1602, 624 ao: NULL, 625 di: das16_di_rbits, 626 do_: das16_do_wbits, 627 i8255_offset:0, 628 i8254_offset:0x0c, 629 size: 0x408, 630 id: 0xc0}, 631 { 632 name: "cio-das1601/12", /* cio-das160x-1x.pdf */ 633 ai: das16_ai_rinsn, 634 ai_nbits:12, 635 ai_speed:6250, 636 ai_pg: das16_pg_1601, 637 ao: das16_ao_winsn, 638 ao_nbits:12, 639 di: das16_di_rbits, 640 do_: das16_do_wbits, 641 i8255_offset:0x400, 642 i8254_offset:0x0c, 643 size: 0x408, 644 id: 0xc0}, 645 { 646 name: "cio-das1602/12", /* cio-das160x-1x.pdf */ 647 ai: das16_ai_rinsn, 648 ai_nbits:12, 649 ai_speed:10000, 650 ai_pg: das16_pg_1602, 651 ao: das16_ao_winsn, 652 ao_nbits:12, 653 di: das16_di_rbits, 654 do_: das16_do_wbits, 655 i8255_offset:0x400, 656 i8254_offset:0x0c, 657 size: 0x408, 658 id: 0xc0}, 659 { 660 name: "cio-das1602/16", /* cio-das160x-1x.pdf */ 661 ai: das16_ai_rinsn, 662 ai_nbits:16, 663 ai_speed:10000, 664 ai_pg: das16_pg_1602, 665 ao: das16_ao_winsn, 666 ao_nbits:12, 667 di: das16_di_rbits, 668 do_: das16_do_wbits, 669 i8255_offset:0x400, 670 i8254_offset:0x0c, 671 size: 0x408, 672 id: 0xc0}, 673 { 674 name: "cio-das16/330", /* ? */ 675 ai: das16_ai_rinsn, 676 ai_nbits:12, 677 ai_speed:3030, 678 ai_pg: das16_pg_16jr, 679 ao: NULL, 680 di: das16_di_rbits, 681 do_: das16_do_wbits, 682 i8255_offset:0, 683 i8254_offset:0x0c, 684 size: 0x14, 685 id: 0xf0}, 686#if 0 687 { 688 name: "das16/330i", /* ? */ 689 }, 690 { 691 name: "das16/jr/ctr5", /* ? */ 692 }, 693 { 694 name: "cio-das16/m1/16", /* cio-das16_m1_16.pdf, this board is a bit quirky, no dma */ 695 }, 696#endif 697}; 698 699#define n_das16_boards ((sizeof(das16_boards))/(sizeof(struct das16_board))) 700 701static int das16_attach(struct comedi_device *dev, struct comedi_devconfig *it); 702static int das16_detach(struct comedi_device *dev); 703static struct comedi_driver driver_das16 = { 704 driver_name:"das16", 705 module:THIS_MODULE, 706 attach:das16_attach, 707 detach:das16_detach, 708 board_name:&das16_boards[0].name, 709 num_names:n_das16_boards, 710 offset:sizeof(das16_boards[0]), 711}; 712 713#define DAS16_TIMEOUT 1000 714 715/* Period for timer interrupt in jiffies. It's a function 716 * to deal with possibility of dynamic HZ patches */ 717static inline int timer_period(void) 718{ 719 return HZ / 20; 720} 721struct das16_private_struct { 722 unsigned int ai_unipolar; /* unipolar flag */ 723 unsigned int ai_singleended; /* single ended flag */ 724 unsigned int clockbase; /* master clock speed in ns */ 725 volatile unsigned int control_state; /* dma, interrupt and trigger control bits */ 726 volatile unsigned long adc_byte_count; /* number of bytes remaining */ 727 unsigned int divisor1; /* divisor dividing master clock to get conversion frequency */ 728 unsigned int divisor2; /* divisor dividing master clock to get conversion frequency */ 729 unsigned int dma_chan; /* dma channel */ 730 uint16_t *dma_buffer[2]; 731 dma_addr_t dma_buffer_addr[2]; 732 unsigned int current_buffer; 733 volatile unsigned int dma_transfer_size; /* target number of bytes to transfer per dma shot */ 734 /* user-defined analog input and output ranges defined from config options */ 735 struct comedi_lrange *user_ai_range_table; 736 struct comedi_lrange *user_ao_range_table; 737 738 struct timer_list timer; /* for timed interrupt */ 739 volatile short timer_running; 740 volatile short timer_mode; /* true if using timer mode */ 741}; 742#define devpriv ((struct das16_private_struct *)(dev->private)) 743#define thisboard ((struct das16_board *)(dev->board_ptr)) 744 745static int das16_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s, 746 struct comedi_cmd *cmd) 747{ 748 int err = 0, tmp; 749 int gain, start_chan, i; 750 int mask; 751 752 /* make sure triggers are valid */ 753 tmp = cmd->start_src; 754 cmd->start_src &= TRIG_NOW; 755 if (!cmd->start_src || tmp != cmd->start_src) 756 err++; 757 758 tmp = cmd->scan_begin_src; 759 mask = TRIG_FOLLOW; 760 /* if board supports burst mode */ 761 if (thisboard->size > 0x400) 762 mask |= TRIG_TIMER | TRIG_EXT; 763 cmd->scan_begin_src &= mask; 764 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) 765 err++; 766 767 tmp = cmd->convert_src; 768 mask = TRIG_TIMER | TRIG_EXT; 769 /* if board supports burst mode */ 770 if (thisboard->size > 0x400) 771 mask |= TRIG_NOW; 772 cmd->convert_src &= mask; 773 if (!cmd->convert_src || tmp != cmd->convert_src) 774 err++; 775 776 tmp = cmd->scan_end_src; 777 cmd->scan_end_src &= TRIG_COUNT; 778 if (!cmd->scan_end_src || tmp != cmd->scan_end_src) 779 err++; 780 781 tmp = cmd->stop_src; 782 cmd->stop_src &= TRIG_COUNT | TRIG_NONE; 783 if (!cmd->stop_src || tmp != cmd->stop_src) 784 err++; 785 786 if (err) 787 return 1; 788 789 /* step 2: make sure trigger sources are unique and mutually compatible */ 790 if (cmd->scan_begin_src != TRIG_TIMER && 791 cmd->scan_begin_src != TRIG_EXT && 792 cmd->scan_begin_src != TRIG_FOLLOW) 793 err++; 794 if (cmd->convert_src != TRIG_TIMER && 795 cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_NOW) 796 err++; 797 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT) 798 err++; 799 800 /* make sure scan_begin_src and convert_src dont conflict */ 801 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW) 802 err++; 803 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW) 804 err++; 805 806 if (err) 807 return 2; 808 809 /* step 3: make sure arguments are trivially compatible */ 810 if (cmd->start_arg != 0) { 811 cmd->start_arg = 0; 812 err++; 813 } 814 815 if (cmd->scan_begin_src == TRIG_FOLLOW) { 816 /* internal trigger */ 817 if (cmd->scan_begin_arg != 0) { 818 cmd->scan_begin_arg = 0; 819 err++; 820 } 821 } 822 823 if (cmd->scan_end_arg != cmd->chanlist_len) { 824 cmd->scan_end_arg = cmd->chanlist_len; 825 err++; 826 } 827 /* check against maximum frequency */ 828 if (cmd->scan_begin_src == TRIG_TIMER) { 829 if (cmd->scan_begin_arg < 830 thisboard->ai_speed * cmd->chanlist_len) { 831 cmd->scan_begin_arg = 832 thisboard->ai_speed * cmd->chanlist_len; 833 err++; 834 } 835 } 836 if (cmd->convert_src == TRIG_TIMER) { 837 if (cmd->convert_arg < thisboard->ai_speed) { 838 cmd->convert_arg = thisboard->ai_speed; 839 err++; 840 } 841 } 842 843 if (cmd->stop_src == TRIG_NONE) { 844 if (cmd->stop_arg != 0) { 845 cmd->stop_arg = 0; 846 err++; 847 } 848 } 849 if (err) 850 return 3; 851 852 /* step 4: fix up arguments */ 853 if (cmd->scan_begin_src == TRIG_TIMER) { 854 unsigned int tmp = cmd->scan_begin_arg; 855 /* set divisors, correct timing arguments */ 856 i8253_cascade_ns_to_timer_2div(devpriv->clockbase, 857 &(devpriv->divisor1), &(devpriv->divisor2), 858 &(cmd->scan_begin_arg), cmd->flags & TRIG_ROUND_MASK); 859 err += (tmp != cmd->scan_begin_arg); 860 } 861 if (cmd->convert_src == TRIG_TIMER) { 862 unsigned int tmp = cmd->convert_arg; 863 /* set divisors, correct timing arguments */ 864 i8253_cascade_ns_to_timer_2div(devpriv->clockbase, 865 &(devpriv->divisor1), &(devpriv->divisor2), 866 &(cmd->convert_arg), cmd->flags & TRIG_ROUND_MASK); 867 err += (tmp != cmd->convert_arg); 868 } 869 if (err) 870 return 4; 871 872 /* check channel/gain list against card's limitations */ 873 if (cmd->chanlist) { 874 gain = CR_RANGE(cmd->chanlist[0]); 875 start_chan = CR_CHAN(cmd->chanlist[0]); 876 for (i = 1; i < cmd->chanlist_len; i++) { 877 if (CR_CHAN(cmd->chanlist[i]) != 878 (start_chan + i) % s->n_chan) { 879 comedi_error(dev, 880 "entries in chanlist must be consecutive channels, counting upwards\n"); 881 err++; 882 } 883 if (CR_RANGE(cmd->chanlist[i]) != gain) { 884 comedi_error(dev, 885 "entries in chanlist must all have the same gain\n"); 886 err++; 887 } 888 } 889 } 890 if (err) 891 return 5; 892 893 return 0; 894} 895 896static int das16_cmd_exec(struct comedi_device *dev, struct comedi_subdevice *s) 897{ 898 struct comedi_async *async = s->async; 899 struct comedi_cmd *cmd = &async->cmd; 900 unsigned int byte; 901 unsigned long flags; 902 int range; 903 904 if (devpriv->dma_chan == 0 || (dev->irq == 0 905 && devpriv->timer_mode == 0)) { 906 comedi_error(dev, 907 "irq (or use of 'timer mode') dma required to execute comedi_cmd"); 908 return -1; 909 } 910 if (cmd->flags & TRIG_RT) { 911 comedi_error(dev, 912 "isa dma transfers cannot be performed with TRIG_RT, aborting"); 913 return -1; 914 } 915 916 devpriv->adc_byte_count = 917 cmd->stop_arg * cmd->chanlist_len * sizeof(uint16_t); 918 919 /* disable conversions for das1600 mode */ 920 if (thisboard->size > 0x400) { 921 outb(DAS1600_CONV_DISABLE, dev->iobase + DAS1600_CONV); 922 } 923 /* set scan limits */ 924 byte = CR_CHAN(cmd->chanlist[0]); 925 byte |= CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1]) << 4; 926 outb(byte, dev->iobase + DAS16_MUX); 927 928 /* set gain (this is also burst rate register but according to 929 * computer boards manual, burst rate does nothing, even on keithley cards) */ 930 if (thisboard->ai_pg != das16_pg_none) { 931 range = CR_RANGE(cmd->chanlist[0]); 932 outb((das16_gainlists[thisboard->ai_pg])[range], 933 dev->iobase + DAS16_GAIN); 934 } 935 936 /* set counter mode and counts */ 937 cmd->convert_arg = 938 das16_set_pacer(dev, cmd->convert_arg, 939 cmd->flags & TRIG_ROUND_MASK); 940 DEBUG_PRINT("pacer period: %d ns\n", cmd->convert_arg); 941 942 /* enable counters */ 943 byte = 0; 944 /* Enable burst mode if appropriate. */ 945 if (thisboard->size > 0x400) { 946 if (cmd->convert_src == TRIG_NOW) { 947 outb(DAS1600_BURST_VAL, dev->iobase + DAS1600_BURST); 948 /* set burst length */ 949 byte |= BURST_LEN_BITS(cmd->chanlist_len - 1); 950 } else { 951 outb(0, dev->iobase + DAS1600_BURST); 952 } 953 } 954 outb(byte, dev->iobase + DAS16_PACER); 955 956 /* set up dma transfer */ 957 flags = claim_dma_lock(); 958 disable_dma(devpriv->dma_chan); 959 /* clear flip-flop to make sure 2-byte registers for 960 * count and address get set correctly */ 961 clear_dma_ff(devpriv->dma_chan); 962 devpriv->current_buffer = 0; 963 set_dma_addr(devpriv->dma_chan, 964 devpriv->dma_buffer_addr[devpriv->current_buffer]); 965 /* set appropriate size of transfer */ 966 devpriv->dma_transfer_size = das16_suggest_transfer_size(dev, *cmd); 967 set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size); 968 enable_dma(devpriv->dma_chan); 969 release_dma_lock(flags); 970 971 /* set up interrupt */ 972 if (devpriv->timer_mode) { 973 devpriv->timer_running = 1; 974 devpriv->timer.expires = jiffies + timer_period(); 975 add_timer(&devpriv->timer); 976 devpriv->control_state &= ~DAS16_INTE; 977 } else { 978 /* clear interrupt bit */ 979 outb(0x00, dev->iobase + DAS16_STATUS); 980 /* enable interrupts */ 981 devpriv->control_state |= DAS16_INTE; 982 } 983 devpriv->control_state |= DMA_ENABLE; 984 devpriv->control_state &= ~PACING_MASK; 985 if (cmd->convert_src == TRIG_EXT) 986 devpriv->control_state |= EXT_PACER; 987 else 988 devpriv->control_state |= INT_PACER; 989 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL); 990 991 /* Enable conversions if using das1600 mode */ 992 if (thisboard->size > 0x400) { 993 outb(0, dev->iobase + DAS1600_CONV); 994 } 995 996 return 0; 997} 998 999static int das16_cancel(struct comedi_device *dev, struct comedi_subdevice *s) 1000{ 1001 unsigned long flags; 1002 1003 comedi_spin_lock_irqsave(&dev->spinlock, flags); 1004 /* disable interrupts, dma and pacer clocked conversions */ 1005 devpriv->control_state &= ~DAS16_INTE & ~PACING_MASK & ~DMA_ENABLE; 1006 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL); 1007 if (devpriv->dma_chan) 1008 disable_dma(devpriv->dma_chan); 1009 1010 /* disable SW timer */ 1011 if (devpriv->timer_mode && devpriv->timer_running) { 1012 devpriv->timer_running = 0; 1013 del_timer(&devpriv->timer); 1014 } 1015 1016 /* disable burst mode */ 1017 if (thisboard->size > 0x400) { 1018 outb(0, dev->iobase + DAS1600_BURST); 1019 } 1020 1021 comedi_spin_unlock_irqrestore(&dev->spinlock, flags); 1022 1023 return 0; 1024} 1025 1026static void das16_reset(struct comedi_device *dev) 1027{ 1028 outb(0, dev->iobase + DAS16_STATUS); 1029 outb(0, dev->iobase + DAS16_CONTROL); 1030 outb(0, dev->iobase + DAS16_PACER); 1031 outb(0, dev->iobase + DAS16_CNTR_CONTROL); 1032} 1033 1034static int das16_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s, 1035 struct comedi_insn *insn, unsigned int *data) 1036{ 1037 int i, n; 1038 int range; 1039 int chan; 1040 int msb, lsb; 1041 1042 /* disable interrupts and pacing */ 1043 devpriv->control_state &= ~DAS16_INTE & ~DMA_ENABLE & ~PACING_MASK; 1044 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL); 1045 1046 /* set multiplexer */ 1047 chan = CR_CHAN(insn->chanspec); 1048 chan |= CR_CHAN(insn->chanspec) << 4; 1049 outb(chan, dev->iobase + DAS16_MUX); 1050 1051 /* set gain */ 1052 if (thisboard->ai_pg != das16_pg_none) { 1053 range = CR_RANGE(insn->chanspec); 1054 outb((das16_gainlists[thisboard->ai_pg])[range], 1055 dev->iobase + DAS16_GAIN); 1056 } 1057 1058 for (n = 0; n < insn->n; n++) { 1059 /* trigger conversion */ 1060 outb_p(0, dev->iobase + DAS16_TRIG); 1061 1062 for (i = 0; i < DAS16_TIMEOUT; i++) { 1063 if (!(inb(dev->iobase + DAS16_STATUS) & BUSY)) 1064 break; 1065 } 1066 if (i == DAS16_TIMEOUT) { 1067 rt_printk("das16: timeout\n"); 1068 return -ETIME; 1069 } 1070 msb = inb(dev->iobase + DAS16_AI_MSB); 1071 lsb = inb(dev->iobase + DAS16_AI_LSB); 1072 if (thisboard->ai_nbits == 12) { 1073 data[n] = ((lsb >> 4) & 0xf) | (msb << 4); 1074 } else { 1075 data[n] = lsb | (msb << 8); 1076 } 1077 } 1078 1079 return n; 1080} 1081 1082static int das16_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s, 1083 struct comedi_insn *insn, unsigned int *data) 1084{ 1085 unsigned int bits; 1086 1087 bits = inb(dev->iobase + DAS16_DIO) & 0xf; 1088 data[1] = bits; 1089 data[0] = 0; 1090 1091 return 2; 1092} 1093 1094static int das16_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s, 1095 struct comedi_insn *insn, unsigned int *data) 1096{ 1097 unsigned int wbits; 1098 1099 /* only set bits that have been masked */ 1100 data[0] &= 0xf; 1101 wbits = s->state; 1102 /* zero bits that have been masked */ 1103 wbits &= ~data[0]; 1104 /* set masked bits */ 1105 wbits |= data[0] & data[1]; 1106 s->state = wbits; 1107 data[1] = wbits; 1108 1109 outb(s->state, dev->iobase + DAS16_DIO); 1110 1111 return 2; 1112} 1113 1114static int das16_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s, 1115 struct comedi_insn *insn, unsigned int *data) 1116{ 1117 int i; 1118 int lsb, msb; 1119 int chan; 1120 1121 chan = CR_CHAN(insn->chanspec); 1122 1123 for (i = 0; i < insn->n; i++) { 1124 if (thisboard->ao_nbits == 12) { 1125 lsb = (data[i] << 4) & 0xff; 1126 msb = (data[i] >> 4) & 0xff; 1127 } else { 1128 lsb = data[i] & 0xff; 1129 msb = (data[i] >> 8) & 0xff; 1130 } 1131 outb(lsb, dev->iobase + DAS16_AO_LSB(chan)); 1132 outb(msb, dev->iobase + DAS16_AO_MSB(chan)); 1133 } 1134 1135 return i; 1136} 1137 1138static irqreturn_t das16_dma_interrupt(int irq, void *d) 1139{ 1140 int status; 1141 struct comedi_device *dev = d; 1142 1143 status = inb(dev->iobase + DAS16_STATUS); 1144 1145 if ((status & DAS16_INT) == 0) { 1146 DEBUG_PRINT("spurious interrupt\n"); 1147 return IRQ_NONE; 1148 } 1149 1150 /* clear interrupt */ 1151 outb(0x00, dev->iobase + DAS16_STATUS); 1152 das16_interrupt(dev); 1153 return IRQ_HANDLED; 1154} 1155 1156static void das16_timer_interrupt(unsigned long arg) 1157{ 1158 struct comedi_device *dev = (struct comedi_device *) arg; 1159 1160 das16_interrupt(dev); 1161 1162 if (devpriv->timer_running) 1163 mod_timer(&devpriv->timer, jiffies + timer_period()); 1164} 1165 1166/* the pc104-das16jr (at least) has problems if the dma 1167 transfer is interrupted in the middle of transferring 1168 a 16 bit sample, so this function takes care to get 1169 an even transfer count after disabling dma 1170 channel. 1171*/ 1172static int disable_dma_on_even(struct comedi_device *dev) 1173{ 1174 int residue; 1175 int i; 1176 static const int disable_limit = 100; 1177 static const int enable_timeout = 100; 1178 disable_dma(devpriv->dma_chan); 1179 residue = get_dma_residue(devpriv->dma_chan); 1180 for (i = 0; i < disable_limit && (residue % 2); ++i) { 1181 int j; 1182 enable_dma(devpriv->dma_chan); 1183 for (j = 0; j < enable_timeout; ++j) { 1184 int new_residue; 1185 comedi_udelay(2); 1186 new_residue = get_dma_residue(devpriv->dma_chan); 1187 if (new_residue != residue) 1188 break; 1189 } 1190 disable_dma(devpriv->dma_chan); 1191 residue = get_dma_residue(devpriv->dma_chan); 1192 } 1193 if (i == disable_limit) { 1194 comedi_error(dev, 1195 "failed to get an even dma transfer, could be trouble."); 1196 } 1197 return residue; 1198} 1199 1200static void das16_interrupt(struct comedi_device *dev) 1201{ 1202 unsigned long dma_flags, spin_flags; 1203 struct comedi_subdevice *s = dev->read_subdev; 1204 struct comedi_async *async; 1205 struct comedi_cmd *cmd; 1206 int num_bytes, residue; 1207 int buffer_index; 1208 1209 if (dev->attached == 0) { 1210 comedi_error(dev, "premature interrupt"); 1211 return; 1212 } 1213 /* initialize async here to make sure it is not NULL */ 1214 async = s->async; 1215 cmd = &async->cmd; 1216 1217 if (devpriv->dma_chan == 0) { 1218 comedi_error(dev, "interrupt with no dma channel?"); 1219 return; 1220 } 1221 1222 comedi_spin_lock_irqsave(&dev->spinlock, spin_flags); 1223 if ((devpriv->control_state & DMA_ENABLE) == 0) { 1224 comedi_spin_unlock_irqrestore(&dev->spinlock, spin_flags); 1225 DEBUG_PRINT("interrupt while dma disabled?\n"); 1226 return; 1227 } 1228 1229 dma_flags = claim_dma_lock(); 1230 clear_dma_ff(devpriv->dma_chan); 1231 residue = disable_dma_on_even(dev); 1232 1233 /* figure out how many points to read */ 1234 if (residue > devpriv->dma_transfer_size) { 1235 comedi_error(dev, "residue > transfer size!\n"); 1236 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA; 1237 num_bytes = 0; 1238 } else 1239 num_bytes = devpriv->dma_transfer_size - residue; 1240 1241 if (cmd->stop_src == TRIG_COUNT && num_bytes >= devpriv->adc_byte_count) { 1242 num_bytes = devpriv->adc_byte_count; 1243 async->events |= COMEDI_CB_EOA; 1244 } 1245 1246 buffer_index = devpriv->current_buffer; 1247 devpriv->current_buffer = (devpriv->current_buffer + 1) % 2; 1248 devpriv->adc_byte_count -= num_bytes; 1249 1250 /* figure out how many bytes for next transfer */ 1251 if (cmd->stop_src == TRIG_COUNT && devpriv->timer_mode == 0 && 1252 devpriv->dma_transfer_size > devpriv->adc_byte_count) 1253 devpriv->dma_transfer_size = devpriv->adc_byte_count; 1254 1255 /* re-enable dma */ 1256 if ((async->events & COMEDI_CB_EOA) == 0) { 1257 set_dma_addr(devpriv->dma_chan, 1258 devpriv->dma_buffer_addr[devpriv->current_buffer]); 1259 set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size); 1260 enable_dma(devpriv->dma_chan); 1261 /* reenable conversions for das1600 mode, (stupid hardware) */ 1262 if (thisboard->size > 0x400 && devpriv->timer_mode == 0) { 1263 outb(0x00, dev->iobase + DAS1600_CONV); 1264 } 1265 } 1266 release_dma_lock(dma_flags); 1267 1268 comedi_spin_unlock_irqrestore(&dev->spinlock, spin_flags); 1269 1270 cfc_write_array_to_buffer(s, 1271 devpriv->dma_buffer[buffer_index], num_bytes); 1272 1273 cfc_handle_events(dev, s); 1274} 1275 1276static unsigned int das16_set_pacer(struct comedi_device *dev, unsigned int ns, 1277 int rounding_flags) 1278{ 1279 i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &(devpriv->divisor1), 1280 &(devpriv->divisor2), &ns, rounding_flags & TRIG_ROUND_MASK); 1281 1282 /* Write the values of ctr1 and ctr2 into counters 1 and 2 */ 1283 i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 1, devpriv->divisor1, 2); 1284 i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 2, devpriv->divisor2, 2); 1285 1286 return ns; 1287} 1288 1289static void reg_dump(struct comedi_device *dev) 1290{ 1291 DEBUG_PRINT("********DAS1600 REGISTER DUMP********\n"); 1292 DEBUG_PRINT("DAS16_MUX: %x\n", inb(dev->iobase + DAS16_MUX)); 1293 DEBUG_PRINT("DAS16_DIO: %x\n", inb(dev->iobase + DAS16_DIO)); 1294 DEBUG_PRINT("DAS16_STATUS: %x\n", inb(dev->iobase + DAS16_STATUS)); 1295 DEBUG_PRINT("DAS16_CONTROL: %x\n", inb(dev->iobase + DAS16_CONTROL)); 1296 DEBUG_PRINT("DAS16_PACER: %x\n", inb(dev->iobase + DAS16_PACER)); 1297 DEBUG_PRINT("DAS16_GAIN: %x\n", inb(dev->iobase + DAS16_GAIN)); 1298 DEBUG_PRINT("DAS16_CNTR_CONTROL: %x\n", 1299 inb(dev->iobase + DAS16_CNTR_CONTROL)); 1300 DEBUG_PRINT("DAS1600_CONV: %x\n", inb(dev->iobase + DAS1600_CONV)); 1301 DEBUG_PRINT("DAS1600_BURST: %x\n", inb(dev->iobase + DAS1600_BURST)); 1302 DEBUG_PRINT("DAS1600_ENABLE: %x\n", inb(dev->iobase + DAS1600_ENABLE)); 1303 DEBUG_PRINT("DAS1600_STATUS_B: %x\n", 1304 inb(dev->iobase + DAS1600_STATUS_B)); 1305} 1306 1307static int das16_probe(struct comedi_device *dev, struct comedi_devconfig *it) 1308{ 1309 int status; 1310 int diobits; 1311 1312 /* status is available on all boards */ 1313 1314 status = inb(dev->iobase + DAS16_STATUS); 1315 1316 if ((status & UNIPOLAR)) { 1317 devpriv->ai_unipolar = 1; 1318 } else { 1319 devpriv->ai_unipolar = 0; 1320 } 1321 1322 if ((status & DAS16_MUXBIT)) { 1323 devpriv->ai_singleended = 1; 1324 } else { 1325 devpriv->ai_singleended = 0; 1326 } 1327 1328 /* diobits indicates boards */ 1329 1330 diobits = inb(dev->iobase + DAS16_DIO) & 0xf0; 1331 1332 printk(" id bits are 0x%02x\n", diobits); 1333 if (thisboard->id != diobits) { 1334 printk(" requested board's id bits are 0x%x (ignore)\n", 1335 thisboard->id); 1336 } 1337 1338 return 0; 1339} 1340 1341static int das1600_mode_detect(struct comedi_device *dev) 1342{ 1343 int status = 0; 1344 1345 status = inb(dev->iobase + DAS1600_STATUS_B); 1346 1347 if (status & DAS1600_CLK_10MHZ) { 1348 devpriv->clockbase = 100; 1349 printk(" 10MHz pacer clock\n"); 1350 } else { 1351 devpriv->clockbase = 1000; 1352 printk(" 1MHz pacer clock\n"); 1353 } 1354 1355 reg_dump(dev); 1356 1357 return 0; 1358} 1359 1360/* 1361 * 1362 * Options list: 1363 * 0 I/O base 1364 * 1 IRQ 1365 * 2 DMA 1366 * 3 Clock speed (in MHz) 1367 */ 1368 1369static int das16_attach(struct comedi_device *dev, struct comedi_devconfig *it) 1370{ 1371 struct comedi_subdevice *s; 1372 int ret; 1373 unsigned int irq; 1374 unsigned long iobase; 1375 unsigned int dma_chan; 1376 int timer_mode; 1377 unsigned long flags; 1378 struct comedi_krange *user_ai_range, *user_ao_range; 1379 1380 iobase = it->options[0]; 1381#if 0 1382 irq = it->options[1]; 1383 timer_mode = it->options[8]; 1384#endif 1385 /* always use time_mode since using irq can drop samples while 1386 * waiting for dma done interrupt (due to hardware limitations) */ 1387 irq = 0; 1388 timer_mode = 1; 1389 if (timer_mode) 1390 irq = 0; 1391 1392 printk("comedi%d: das16:", dev->minor); 1393 1394 /* check that clock setting is valid */ 1395 if (it->options[3]) { 1396 if (it->options[3] != 0 && 1397 it->options[3] != 1 && it->options[3] != 10) { 1398 printk("\n Invalid option. Master clock must be set to 1 or 10 (MHz)\n"); 1399 return -EINVAL; 1400 } 1401 } 1402 1403 ret = alloc_private(dev, sizeof(struct das16_private_struct)); 1404 if (ret < 0) 1405 return ret; 1406 1407 if (thisboard->size < 0x400) { 1408 printk(" 0x%04lx-0x%04lx\n", iobase, iobase + thisboard->size); 1409 if (!request_region(iobase, thisboard->size, "das16")) { 1410 printk(" I/O port conflict\n"); 1411 return -EIO; 1412 } 1413 } else { 1414 printk(" 0x%04lx-0x%04lx 0x%04lx-0x%04lx\n", 1415 iobase, iobase + 0x0f, 1416 iobase + 0x400, 1417 iobase + 0x400 + (thisboard->size & 0x3ff)); 1418 if (!request_region(iobase, 0x10, "das16")) { 1419 printk(" I/O port conflict: 0x%04lx-0x%04lx\n", 1420 iobase, iobase + 0x0f); 1421 return -EIO; 1422 } 1423 if (!request_region(iobase + 0x400, thisboard->size & 0x3ff, 1424 "das16")) { 1425 release_region(iobase, 0x10); 1426 printk(" I/O port conflict: 0x%04lx-0x%04lx\n", 1427 iobase + 0x400, 1428 iobase + 0x400 + (thisboard->size & 0x3ff)); 1429 return -EIO; 1430 } 1431 } 1432 1433 dev->iobase = iobase; 1434 1435 /* probe id bits to make sure they are consistent */ 1436 if (das16_probe(dev, it)) { 1437 printk(" id bits do not match selected board, aborting\n"); 1438 return -EINVAL; 1439 } 1440 dev->board_name = thisboard->name; 1441 1442 /* get master clock speed */ 1443 if (thisboard->size < 0x400) { 1444 if (it->options[3]) 1445 devpriv->clockbase = 1000 / it->options[3]; 1446 else 1447 devpriv->clockbase = 1000; /* 1 MHz default */ 1448 } else { 1449 das1600_mode_detect(dev); 1450 } 1451 1452 /* now for the irq */ 1453 if (irq > 1 && irq < 8) { 1454 ret = comedi_request_irq(irq, das16_dma_interrupt, 0, 1455 "das16", dev); 1456 1457 if (ret < 0) 1458 return ret; 1459 dev->irq = irq; 1460 printk(" ( irq = %u )", irq); 1461 } else if (irq == 0) { 1462 printk(" ( no irq )"); 1463 } else { 1464 printk(" invalid irq\n"); 1465 return -EINVAL; 1466 } 1467 1468 /* initialize dma */ 1469 dma_chan = it->options[2]; 1470 if (dma_chan == 1 || dma_chan == 3) { 1471 /* allocate dma buffers */ 1472 int i; 1473 for (i = 0; i < 2; i++) { 1474 devpriv->dma_buffer[i] = pci_alloc_consistent(NULL, 1475 DAS16_DMA_SIZE, &devpriv->dma_buffer_addr[i]); 1476 if (devpriv->dma_buffer[i] == NULL) 1477 return -ENOMEM; 1478 } 1479 if (request_dma(dma_chan, "das16")) { 1480 printk(" failed to allocate dma channel %i\n", 1481 dma_chan); 1482 return -EINVAL; 1483 } 1484 devpriv->dma_chan = dma_chan; 1485 flags = claim_dma_lock(); 1486 disable_dma(devpriv->dma_chan); 1487 set_dma_mode(devpriv->dma_chan, DMA_MODE_READ); 1488 release_dma_lock(flags); 1489 printk(" ( dma = %u)\n", dma_chan); 1490 } else if (dma_chan == 0) { 1491 printk(" ( no dma )\n"); 1492 } else { 1493 printk(" invalid dma channel\n"); 1494 return -EINVAL; 1495 } 1496 1497 /* get any user-defined input range */ 1498 if (thisboard->ai_pg == das16_pg_none && 1499 (it->options[4] || it->options[5])) { 1500 /* allocate single-range range table */ 1501 devpriv->user_ai_range_table = 1502 kmalloc(sizeof(struct comedi_lrange) + sizeof(struct comedi_krange), 1503 GFP_KERNEL); 1504 /* initialize ai range */ 1505 devpriv->user_ai_range_table->length = 1; 1506 user_ai_range = devpriv->user_ai_range_table->range; 1507 user_ai_range->min = it->options[4]; 1508 user_ai_range->max = it->options[5]; 1509 user_ai_range->flags = UNIT_volt; 1510 } 1511 /* get any user-defined output range */ 1512 if (it->options[6] || it->options[7]) { 1513 /* allocate single-range range table */ 1514 devpriv->user_ao_range_table = 1515 kmalloc(sizeof(struct comedi_lrange) + sizeof(struct comedi_krange), 1516 GFP_KERNEL); 1517 /* initialize ao range */ 1518 devpriv->user_ao_range_table->length = 1; 1519 user_ao_range = devpriv->user_ao_range_table->range; 1520 user_ao_range->min = it->options[6]; 1521 user_ao_range->max = it->options[7]; 1522 user_ao_range->flags = UNIT_volt; 1523 } 1524 1525 if (timer_mode) { 1526 init_timer(&(devpriv->timer)); 1527 devpriv->timer.function = das16_timer_interrupt; 1528 devpriv->timer.data = (unsigned long)dev; 1529 } 1530 devpriv->timer_mode = timer_mode ? 1 : 0; 1531 1532 ret = alloc_subdevices(dev, 5); 1533 if (ret < 0) 1534 return ret; 1535 1536 s = dev->subdevices + 0; 1537 dev->read_subdev = s; 1538 /* ai */ 1539 if (thisboard->ai) { 1540 s->type = COMEDI_SUBD_AI; 1541 s->subdev_flags = SDF_READABLE | SDF_CMD_READ; 1542 if (devpriv->ai_singleended) { 1543 s->n_chan = 16; 1544 s->len_chanlist = 16; 1545 s->subdev_flags |= SDF_GROUND; 1546 } else { 1547 s->n_chan = 8; 1548 s->len_chanlist = 8; 1549 s->subdev_flags |= SDF_DIFF; 1550 } 1551 s->maxdata = (1 << thisboard->ai_nbits) - 1; 1552 if (devpriv->user_ai_range_table) { /* user defined ai range */ 1553 s->range_table = devpriv->user_ai_range_table; 1554 } else if (devpriv->ai_unipolar) { 1555 s->range_table = das16_ai_uni_lranges[thisboard->ai_pg]; 1556 } else { 1557 s->range_table = das16_ai_bip_lranges[thisboard->ai_pg]; 1558 } 1559 s->insn_read = thisboard->ai; 1560 s->do_cmdtest = das16_cmd_test; 1561 s->do_cmd = das16_cmd_exec; 1562 s->cancel = das16_cancel; 1563 s->munge = das16_ai_munge; 1564 } else { 1565 s->type = COMEDI_SUBD_UNUSED; 1566 } 1567 1568 s = dev->subdevices + 1; 1569 /* ao */ 1570 if (thisboard->ao) { 1571 s->type = COMEDI_SUBD_AO; 1572 s->subdev_flags = SDF_WRITABLE; 1573 s->n_chan = 2; 1574 s->maxdata = (1 << thisboard->ao_nbits) - 1; 1575 if (devpriv->user_ao_range_table) { /* user defined ao range */ 1576 s->range_table = devpriv->user_ao_range_table; 1577 } else { 1578 s->range_table = &range_unknown; 1579 } 1580 s->insn_write = thisboard->ao; 1581 } else { 1582 s->type = COMEDI_SUBD_UNUSED; 1583 } 1584 1585 s = dev->subdevices + 2; 1586 /* di */ 1587 if (thisboard->di) { 1588 s->type = COMEDI_SUBD_DI; 1589 s->subdev_flags = SDF_READABLE; 1590 s->n_chan = 4; 1591 s->maxdata = 1; 1592 s->range_table = &range_digital; 1593 s->insn_bits = thisboard->di; 1594 } else { 1595 s->type = COMEDI_SUBD_UNUSED; 1596 } 1597 1598 s = dev->subdevices + 3; 1599 /* do */ 1600 if (thisboard->do_) { 1601 s->type = COMEDI_SUBD_DO; 1602 s->subdev_flags = SDF_WRITABLE | SDF_READABLE; 1603 s->n_chan = 4; 1604 s->maxdata = 1; 1605 s->range_table = &range_digital; 1606 s->insn_bits = thisboard->do_; 1607 /* initialize digital output lines */ 1608 outb(s->state, dev->iobase + DAS16_DIO); 1609 } else { 1610 s->type = COMEDI_SUBD_UNUSED; 1611 } 1612 1613 s = dev->subdevices + 4; 1614 /* 8255 */ 1615 if (thisboard->i8255_offset != 0) { 1616 subdev_8255_init(dev, s, NULL, (dev->iobase + 1617 thisboard->i8255_offset)); 1618 } else { 1619 s->type = COMEDI_SUBD_UNUSED; 1620 } 1621 1622 das16_reset(dev); 1623 /* set the interrupt level */ 1624 devpriv->control_state = DAS16_IRQ(dev->irq); 1625 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL); 1626 1627 /* turn on das1600 mode if available */ 1628 if (thisboard->size > 0x400) { 1629 outb(DAS1600_ENABLE_VAL, dev->iobase + DAS1600_ENABLE); 1630 outb(0, dev->iobase + DAS1600_CONV); 1631 outb(0, dev->iobase + DAS1600_BURST); 1632 } 1633 1634 return 0; 1635} 1636 1637static int das16_detach(struct comedi_device *dev) 1638{ 1639 printk("comedi%d: das16: remove\n", dev->minor); 1640 1641 das16_reset(dev); 1642 1643 if (dev->subdevices) 1644 subdev_8255_cleanup(dev, dev->subdevices + 4); 1645 1646 if (devpriv) { 1647 int i; 1648 for (i = 0; i < 2; i++) { 1649 if (devpriv->dma_buffer[i]) 1650 pci_free_consistent(NULL, DAS16_DMA_SIZE, 1651 devpriv->dma_buffer[i], 1652 devpriv->dma_buffer_addr[i]); 1653 } 1654 if (devpriv->dma_chan) 1655 free_dma(devpriv->dma_chan); 1656 if (devpriv->user_ai_range_table) 1657 kfree(devpriv->user_ai_range_table); 1658 if (devpriv->user_ao_range_table) 1659 kfree(devpriv->user_ao_range_table); 1660 } 1661 1662 if (dev->irq) 1663 comedi_free_irq(dev->irq, dev); 1664 1665 if (dev->iobase) { 1666 if (thisboard->size < 0x400) { 1667 release_region(dev->iobase, thisboard->size); 1668 } else { 1669 release_region(dev->iobase, 0x10); 1670 release_region(dev->iobase + 0x400, 1671 thisboard->size & 0x3ff); 1672 } 1673 } 1674 1675 return 0; 1676} 1677 1678COMEDI_INITCLEANUP(driver_das16); 1679 1680/* utility function that suggests a dma transfer size in bytes */ 1681static unsigned int das16_suggest_transfer_size(struct comedi_device *dev, 1682 struct comedi_cmd cmd) 1683{ 1684 unsigned int size; 1685 unsigned int freq; 1686 1687 /* if we are using timer interrupt, we don't care how long it 1688 * will take to complete transfer since it will be interrupted 1689 * by timer interrupt */ 1690 if (devpriv->timer_mode) 1691 return DAS16_DMA_SIZE; 1692 1693 /* otherwise, we are relying on dma terminal count interrupt, 1694 * so pick a reasonable size */ 1695 if (cmd.convert_src == TRIG_TIMER) 1696 freq = 1000000000 / cmd.convert_arg; 1697 else if (cmd.scan_begin_src == TRIG_TIMER) 1698 freq = (1000000000 / cmd.scan_begin_arg) * cmd.chanlist_len; 1699 /* return some default value */ 1700 else 1701 freq = 0xffffffff; 1702 1703 if (cmd.flags & TRIG_WAKE_EOS) { 1704 size = sample_size * cmd.chanlist_len; 1705 } else { 1706 /* make buffer fill in no more than 1/3 second */ 1707 size = (freq / 3) * sample_size; 1708 } 1709 1710 /* set a minimum and maximum size allowed */ 1711 if (size > DAS16_DMA_SIZE) 1712 size = DAS16_DMA_SIZE - DAS16_DMA_SIZE % sample_size; 1713 else if (size < sample_size) 1714 size = sample_size; 1715 1716 if (cmd.stop_src == TRIG_COUNT && size > devpriv->adc_byte_count) 1717 size = devpriv->adc_byte_count; 1718 1719 return size; 1720} 1721 1722static void das16_ai_munge(struct comedi_device *dev, struct comedi_subdevice *s, 1723 void *array, unsigned int num_bytes, unsigned int start_chan_index) 1724{ 1725 unsigned int i, num_samples = num_bytes / sizeof(short); 1726 short *data = array; 1727 1728 for (i = 0; i < num_samples; i++) { 1729 data[i] = le16_to_cpu(data[i]); 1730 if (thisboard->ai_nbits == 12) { 1731 data[i] = (data[i] >> 4) & 0xfff; 1732 } 1733 } 1734} 1735