Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 | /*
comedi/drivers/daqboard2000.c
hardware driver for IOtech DAQboard/2000
COMEDI - Linux Control and Measurement Device Interface
Copyright (C) 1999 Anders Blomdell <anders.blomdell@control.lth.se>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
/*
Driver: daqboard2000
Description: IOTech DAQBoard/2000
Author: Anders Blomdell <anders.blomdell@control.lth.se>
Status: works
Updated: Mon, 14 Apr 2008 15:28:52 +0100
Devices: [IOTech] DAQBoard/2000 (daqboard2000)
Much of the functionality of this driver was determined from reading
the source code for the Windows driver.
The FPGA on the board requires fimware, which is available from
http://www.comedi.org in the comedi_nonfree_firmware tarball.
Configuration options: not applicable, uses PCI auto config
*/
/*
This card was obviously never intended to leave the Windows world,
since it lacked all kind of hardware documentation (except for cable
pinouts, plug and pray has something to catch up with yet).
With some help from our swedish distributor, we got the Windows sourcecode
for the card, and here are the findings so far.
1. A good document that describes the PCI interface chip is 9080db-106.pdf
available from http://www.plxtech.com/products/io/pci9080
2. The initialization done so far is:
a. program the FPGA (windows code sans a lot of error messages)
b.
3. Analog out seems to work OK with DAC's disabled, if DAC's are enabled,
you have to output values to all enabled DAC's until result appears, I
guess that it has something to do with pacer clocks, but the source
gives me no clues. I'll keep it simple so far.
4. Analog in.
Each channel in the scanlist seems to be controlled by four
control words:
Word0:
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
! | | | ! | | | ! | | | ! | | | !
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Word1:
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
! | | | ! | | | ! | | | ! | | | !
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | |
+------+------+ | | | | +-- Digital input (??)
| | | | +---- 10 us settling time
| | | +------ Suspend acquisition (last to scan)
| | +-------- Simultaneous sample and hold
| +---------- Signed data format
+------------------------- Correction offset low
Word2:
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
! | | | ! | | | ! | | | ! | | | !
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | |
+-----+ +--+--+ +++ +++ +--+--+
| | | | +----- Expansion channel
| | | +----------- Expansion gain
| | +--------------- Channel (low)
| +--------------------- Correction offset high
+----------------------------- Correction gain low
Word3:
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
! | | | ! | | | ! | | | ! | | | !
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | |
+------+------+ | | +-+-+ | | +-- Low bank enable
| | | | | +---- High bank enable
| | | | +------ Hi/low select
| | | +---------- Gain (1,?,2,4,8,16,32,64)
| | +-------------- differential/single ended
| +---------------- Unipolar
+------------------------- Correction gain high
999. The card seems to have an incredible amount of capabilities, but
trying to reverse engineer them from the Windows source is beyond my
patience.
*/
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include "../comedidev.h"
#include "8255.h"
#define DAQBOARD2000_FIRMWARE "daqboard2000_firmware.bin"
#define DAQBOARD2000_SUBSYSTEM_IDS2 0x0002 /* Daqboard/2000 - 2 Dacs */
#define DAQBOARD2000_SUBSYSTEM_IDS4 0x0004 /* Daqboard/2000 - 4 Dacs */
/* Initialization bits for the Serial EEPROM Control Register */
#define DAQBOARD2000_SECRProgPinHi 0x8001767e
#define DAQBOARD2000_SECRProgPinLo 0x8000767e
#define DAQBOARD2000_SECRLocalBusHi 0xc000767e
#define DAQBOARD2000_SECRLocalBusLo 0x8000767e
#define DAQBOARD2000_SECRReloadHi 0xa000767e
#define DAQBOARD2000_SECRReloadLo 0x8000767e
/* SECR status bits */
#define DAQBOARD2000_EEPROM_PRESENT 0x10000000
/* CPLD status bits */
#define DAQBOARD2000_CPLD_INIT 0x0002
#define DAQBOARD2000_CPLD_DONE 0x0004
static const struct comedi_lrange range_daqboard2000_ai = {
13, {
BIP_RANGE(10),
BIP_RANGE(5),
BIP_RANGE(2.5),
BIP_RANGE(1.25),
BIP_RANGE(0.625),
BIP_RANGE(0.3125),
BIP_RANGE(0.156),
UNI_RANGE(10),
UNI_RANGE(5),
UNI_RANGE(2.5),
UNI_RANGE(1.25),
UNI_RANGE(0.625),
UNI_RANGE(0.3125)
}
};
/*
* Register Memory Map
*/
#define acqControl 0x00 /* u16 */
#define acqScanListFIFO 0x02 /* u16 */
#define acqPacerClockDivLow 0x04 /* u32 */
#define acqScanCounter 0x08 /* u16 */
#define acqPacerClockDivHigh 0x0a /* u16 */
#define acqTriggerCount 0x0c /* u16 */
#define acqResultsFIFO 0x10 /* u16 */
#define acqResultsShadow 0x14 /* u16 */
#define acqAdcResult 0x18 /* u16 */
#define dacScanCounter 0x1c /* u16 */
#define dacControl 0x20 /* u16 */
#define dacFIFO 0x24 /* s16 */
#define dacPacerClockDiv 0x2a /* u16 */
#define refDacs 0x2c /* u16 */
#define dioControl 0x30 /* u16 */
#define dioP3hsioData 0x32 /* s16 */
#define dioP3Control 0x34 /* u16 */
#define calEepromControl 0x36 /* u16 */
#define dacSetting(x) (0x38 + (x)*2) /* s16 */
#define dioP2ExpansionIO8Bit 0x40 /* s16 */
#define ctrTmrControl 0x80 /* u16 */
#define ctrInput(x) (0x88 + (x)*2) /* s16 */
#define timerDivisor(x) (0xa0 + (x)*2) /* u16 */
#define dmaControl 0xb0 /* u16 */
#define trigControl 0xb2 /* u16 */
#define calEeprom 0xb8 /* u16 */
#define acqDigitalMark 0xba /* u16 */
#define trigDacs 0xbc /* u16 */
#define dioP2ExpansionIO16Bit(x) (0xc0 + (x)*2) /* s16 */
/* Scan Sequencer programming */
#define DAQBOARD2000_SeqStartScanList 0x0011
#define DAQBOARD2000_SeqStopScanList 0x0010
/* Prepare for acquisition */
#define DAQBOARD2000_AcqResetScanListFifo 0x0004
#define DAQBOARD2000_AcqResetResultsFifo 0x0002
#define DAQBOARD2000_AcqResetConfigPipe 0x0001
/* Acqusition status bits */
#define DAQBOARD2000_AcqResultsFIFOMore1Sample 0x0001
#define DAQBOARD2000_AcqResultsFIFOHasValidData 0x0002
#define DAQBOARD2000_AcqResultsFIFOOverrun 0x0004
#define DAQBOARD2000_AcqLogicScanning 0x0008
#define DAQBOARD2000_AcqConfigPipeFull 0x0010
#define DAQBOARD2000_AcqScanListFIFOEmpty 0x0020
#define DAQBOARD2000_AcqAdcNotReady 0x0040
#define DAQBOARD2000_ArbitrationFailure 0x0080
#define DAQBOARD2000_AcqPacerOverrun 0x0100
#define DAQBOARD2000_DacPacerOverrun 0x0200
#define DAQBOARD2000_AcqHardwareError 0x01c0
/* Scan Sequencer programming */
#define DAQBOARD2000_SeqStartScanList 0x0011
#define DAQBOARD2000_SeqStopScanList 0x0010
/* Pacer Clock Control */
#define DAQBOARD2000_AdcPacerInternal 0x0030
#define DAQBOARD2000_AdcPacerExternal 0x0032
#define DAQBOARD2000_AdcPacerEnable 0x0031
#define DAQBOARD2000_AdcPacerEnableDacPacer 0x0034
#define DAQBOARD2000_AdcPacerDisable 0x0030
#define DAQBOARD2000_AdcPacerNormalMode 0x0060
#define DAQBOARD2000_AdcPacerCompatibilityMode 0x0061
#define DAQBOARD2000_AdcPacerInternalOutEnable 0x0008
#define DAQBOARD2000_AdcPacerExternalRising 0x0100
/* DAC status */
#define DAQBOARD2000_DacFull 0x0001
#define DAQBOARD2000_RefBusy 0x0002
#define DAQBOARD2000_TrgBusy 0x0004
#define DAQBOARD2000_CalBusy 0x0008
#define DAQBOARD2000_Dac0Busy 0x0010
#define DAQBOARD2000_Dac1Busy 0x0020
#define DAQBOARD2000_Dac2Busy 0x0040
#define DAQBOARD2000_Dac3Busy 0x0080
/* DAC control */
#define DAQBOARD2000_Dac0Enable 0x0021
#define DAQBOARD2000_Dac1Enable 0x0031
#define DAQBOARD2000_Dac2Enable 0x0041
#define DAQBOARD2000_Dac3Enable 0x0051
#define DAQBOARD2000_DacEnableBit 0x0001
#define DAQBOARD2000_Dac0Disable 0x0020
#define DAQBOARD2000_Dac1Disable 0x0030
#define DAQBOARD2000_Dac2Disable 0x0040
#define DAQBOARD2000_Dac3Disable 0x0050
#define DAQBOARD2000_DacResetFifo 0x0004
#define DAQBOARD2000_DacPatternDisable 0x0060
#define DAQBOARD2000_DacPatternEnable 0x0061
#define DAQBOARD2000_DacSelectSignedData 0x0002
#define DAQBOARD2000_DacSelectUnsignedData 0x0000
/* Trigger Control */
#define DAQBOARD2000_TrigAnalog 0x0000
#define DAQBOARD2000_TrigTTL 0x0010
#define DAQBOARD2000_TrigTransHiLo 0x0004
#define DAQBOARD2000_TrigTransLoHi 0x0000
#define DAQBOARD2000_TrigAbove 0x0000
#define DAQBOARD2000_TrigBelow 0x0004
#define DAQBOARD2000_TrigLevelSense 0x0002
#define DAQBOARD2000_TrigEdgeSense 0x0000
#define DAQBOARD2000_TrigEnable 0x0001
#define DAQBOARD2000_TrigDisable 0x0000
/* Reference Dac Selection */
#define DAQBOARD2000_PosRefDacSelect 0x0100
#define DAQBOARD2000_NegRefDacSelect 0x0000
struct daq200_boardtype {
const char *name;
int id;
};
static const struct daq200_boardtype boardtypes[] = {
{"ids2", DAQBOARD2000_SUBSYSTEM_IDS2},
{"ids4", DAQBOARD2000_SUBSYSTEM_IDS4},
};
struct daqboard2000_private {
enum {
card_daqboard_2000
} card;
void __iomem *daq;
void __iomem *plx;
unsigned int ao_readback[2];
};
static void writeAcqScanListEntry(struct comedi_device *dev, u16 entry)
{
struct daqboard2000_private *devpriv = dev->private;
/* udelay(4); */
writew(entry & 0x00ff, devpriv->daq + acqScanListFIFO);
/* udelay(4); */
writew((entry >> 8) & 0x00ff, devpriv->daq + acqScanListFIFO);
}
static void setup_sampling(struct comedi_device *dev, int chan, int gain)
{
u16 word0, word1, word2, word3;
/* Channel 0-7 diff, channel 8-23 single ended */
word0 = 0;
word1 = 0x0004; /* Last scan */
word2 = (chan << 6) & 0x00c0;
switch (chan / 4) {
case 0:
word3 = 0x0001;
break;
case 1:
word3 = 0x0002;
break;
case 2:
word3 = 0x0005;
break;
case 3:
word3 = 0x0006;
break;
case 4:
word3 = 0x0041;
break;
case 5:
word3 = 0x0042;
break;
default:
word3 = 0;
break;
}
/*
dev->eeprom.correctionDACSE[i][j][k].offset = 0x800;
dev->eeprom.correctionDACSE[i][j][k].gain = 0xc00;
*/
/* These should be read from EEPROM */
word2 |= 0x0800;
word3 |= 0xc000;
writeAcqScanListEntry(dev, word0);
writeAcqScanListEntry(dev, word1);
writeAcqScanListEntry(dev, word2);
writeAcqScanListEntry(dev, word3);
}
static int daqboard2000_ai_status(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned long context)
{
struct daqboard2000_private *devpriv = dev->private;
unsigned int status;
status = readw(devpriv->daq + acqControl);
if (status & context)
return 0;
return -EBUSY;
}
static int daqboard2000_ai_insn_read(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned int *data)
{
struct daqboard2000_private *devpriv = dev->private;
int gain, chan;
int ret;
int i;
writew(DAQBOARD2000_AcqResetScanListFifo |
DAQBOARD2000_AcqResetResultsFifo |
DAQBOARD2000_AcqResetConfigPipe, devpriv->daq + acqControl);
/*
* If pacer clock is not set to some high value (> 10 us), we
* risk multiple samples to be put into the result FIFO.
*/
/* 1 second, should be long enough */
writel(1000000, devpriv->daq + acqPacerClockDivLow);
writew(0, devpriv->daq + acqPacerClockDivHigh);
gain = CR_RANGE(insn->chanspec);
chan = CR_CHAN(insn->chanspec);
/* This doesn't look efficient. I decided to take the conservative
* approach when I did the insn conversion. Perhaps it would be
* better to have broken it completely, then someone would have been
* forced to fix it. --ds */
for (i = 0; i < insn->n; i++) {
setup_sampling(dev, chan, gain);
/* Enable reading from the scanlist FIFO */
writew(DAQBOARD2000_SeqStartScanList,
devpriv->daq + acqControl);
ret = comedi_timeout(dev, s, insn, daqboard2000_ai_status,
DAQBOARD2000_AcqConfigPipeFull);
if (ret)
return ret;
writew(DAQBOARD2000_AdcPacerEnable, devpriv->daq + acqControl);
ret = comedi_timeout(dev, s, insn, daqboard2000_ai_status,
DAQBOARD2000_AcqLogicScanning);
if (ret)
return ret;
ret = comedi_timeout(dev, s, insn, daqboard2000_ai_status,
DAQBOARD2000_AcqResultsFIFOHasValidData);
if (ret)
return ret;
data[i] = readw(devpriv->daq + acqResultsFIFO);
writew(DAQBOARD2000_AdcPacerDisable, devpriv->daq + acqControl);
writew(DAQBOARD2000_SeqStopScanList, devpriv->daq + acqControl);
}
return i;
}
static int daqboard2000_ao_insn_read(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned int *data)
{
struct daqboard2000_private *devpriv = dev->private;
int chan = CR_CHAN(insn->chanspec);
int i;
for (i = 0; i < insn->n; i++)
data[i] = devpriv->ao_readback[chan];
return i;
}
static int daqboard2000_ao_eoc(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned long context)
{
struct daqboard2000_private *devpriv = dev->private;
unsigned int chan = CR_CHAN(insn->chanspec);
unsigned int status;
status = readw(devpriv->daq + dacControl);
if ((status & ((chan + 1) * 0x0010)) == 0)
return 0;
return -EBUSY;
}
static int daqboard2000_ao_insn_write(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned int *data)
{
struct daqboard2000_private *devpriv = dev->private;
int chan = CR_CHAN(insn->chanspec);
int ret;
int i;
for (i = 0; i < insn->n; i++) {
#if 0
/*
* OK, since it works OK without enabling the DAC's,
* let's keep it as simple as possible...
*/
writew((chan + 2) * 0x0010 | 0x0001,
devpriv->daq + dacControl);
udelay(1000);
#endif
writew(data[i], devpriv->daq + dacSetting(chan));
ret = comedi_timeout(dev, s, insn, daqboard2000_ao_eoc, 0);
if (ret)
return ret;
devpriv->ao_readback[chan] = data[i];
#if 0
/*
* Since we never enabled the DAC's, we don't need
* to disable it...
*/
writew((chan + 2) * 0x0010 | 0x0000,
devpriv->daq + dacControl);
udelay(1000);
#endif
}
return i;
}
static void daqboard2000_resetLocalBus(struct comedi_device *dev)
{
struct daqboard2000_private *devpriv = dev->private;
writel(DAQBOARD2000_SECRLocalBusHi, devpriv->plx + 0x6c);
mdelay(10);
writel(DAQBOARD2000_SECRLocalBusLo, devpriv->plx + 0x6c);
mdelay(10);
}
static void daqboard2000_reloadPLX(struct comedi_device *dev)
{
struct daqboard2000_private *devpriv = dev->private;
writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
mdelay(10);
writel(DAQBOARD2000_SECRReloadHi, devpriv->plx + 0x6c);
mdelay(10);
writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
mdelay(10);
}
static void daqboard2000_pulseProgPin(struct comedi_device *dev)
{
struct daqboard2000_private *devpriv = dev->private;
writel(DAQBOARD2000_SECRProgPinHi, devpriv->plx + 0x6c);
mdelay(10);
writel(DAQBOARD2000_SECRProgPinLo, devpriv->plx + 0x6c);
mdelay(10); /* Not in the original code, but I like symmetry... */
}
static int daqboard2000_pollCPLD(struct comedi_device *dev, int mask)
{
struct daqboard2000_private *devpriv = dev->private;
int result = 0;
int i;
int cpld;
/* timeout after 50 tries -> 5ms */
for (i = 0; i < 50; i++) {
cpld = readw(devpriv->daq + 0x1000);
if ((cpld & mask) == mask) {
result = 1;
break;
}
udelay(100);
}
udelay(5);
return result;
}
static int daqboard2000_writeCPLD(struct comedi_device *dev, int data)
{
struct daqboard2000_private *devpriv = dev->private;
int result = 0;
udelay(10);
writew(data, devpriv->daq + 0x1000);
if ((readw(devpriv->daq + 0x1000) & DAQBOARD2000_CPLD_INIT) ==
DAQBOARD2000_CPLD_INIT) {
result = 1;
}
return result;
}
static int initialize_daqboard2000(struct comedi_device *dev,
const u8 *cpld_array, size_t len,
unsigned long context)
{
struct daqboard2000_private *devpriv = dev->private;
int result = -EIO;
/* Read the serial EEPROM control register */
int secr;
int retry;
size_t i;
/* Check to make sure the serial eeprom is present on the board */
secr = readl(devpriv->plx + 0x6c);
if (!(secr & DAQBOARD2000_EEPROM_PRESENT))
return -EIO;
for (retry = 0; retry < 3; retry++) {
daqboard2000_resetLocalBus(dev);
daqboard2000_reloadPLX(dev);
daqboard2000_pulseProgPin(dev);
if (daqboard2000_pollCPLD(dev, DAQBOARD2000_CPLD_INIT)) {
for (i = 0; i < len; i++) {
if (cpld_array[i] == 0xff &&
cpld_array[i + 1] == 0x20)
break;
}
for (; i < len; i += 2) {
int data =
(cpld_array[i] << 8) + cpld_array[i + 1];
if (!daqboard2000_writeCPLD(dev, data))
break;
}
if (i >= len) {
daqboard2000_resetLocalBus(dev);
daqboard2000_reloadPLX(dev);
result = 0;
break;
}
}
}
return result;
}
static void daqboard2000_adcStopDmaTransfer(struct comedi_device *dev)
{
}
static void daqboard2000_adcDisarm(struct comedi_device *dev)
{
struct daqboard2000_private *devpriv = dev->private;
/* Disable hardware triggers */
udelay(2);
writew(DAQBOARD2000_TrigAnalog | DAQBOARD2000_TrigDisable,
devpriv->daq + trigControl);
udelay(2);
writew(DAQBOARD2000_TrigTTL | DAQBOARD2000_TrigDisable,
devpriv->daq + trigControl);
/* Stop the scan list FIFO from loading the configuration pipe */
udelay(2);
writew(DAQBOARD2000_SeqStopScanList, devpriv->daq + acqControl);
/* Stop the pacer clock */
udelay(2);
writew(DAQBOARD2000_AdcPacerDisable, devpriv->daq + acqControl);
/* Stop the input dma (abort channel 1) */
daqboard2000_adcStopDmaTransfer(dev);
}
static void daqboard2000_activateReferenceDacs(struct comedi_device *dev)
{
struct daqboard2000_private *devpriv = dev->private;
unsigned int val;
int timeout;
/* Set the + reference dac value in the FPGA */
writew(0x80 | DAQBOARD2000_PosRefDacSelect, devpriv->daq + refDacs);
for (timeout = 0; timeout < 20; timeout++) {
val = readw(devpriv->daq + dacControl);
if ((val & DAQBOARD2000_RefBusy) == 0)
break;
udelay(2);
}
/* Set the - reference dac value in the FPGA */
writew(0x80 | DAQBOARD2000_NegRefDacSelect, devpriv->daq + refDacs);
for (timeout = 0; timeout < 20; timeout++) {
val = readw(devpriv->daq + dacControl);
if ((val & DAQBOARD2000_RefBusy) == 0)
break;
udelay(2);
}
}
static void daqboard2000_initializeCtrs(struct comedi_device *dev)
{
}
static void daqboard2000_initializeTmrs(struct comedi_device *dev)
{
}
static void daqboard2000_dacDisarm(struct comedi_device *dev)
{
}
static void daqboard2000_initializeAdc(struct comedi_device *dev)
{
daqboard2000_adcDisarm(dev);
daqboard2000_activateReferenceDacs(dev);
daqboard2000_initializeCtrs(dev);
daqboard2000_initializeTmrs(dev);
}
static void daqboard2000_initializeDac(struct comedi_device *dev)
{
daqboard2000_dacDisarm(dev);
}
static int daqboard2000_8255_cb(int dir, int port, int data,
unsigned long ioaddr)
{
void __iomem *mmio_base = (void __iomem *)ioaddr;
if (dir) {
writew(data, mmio_base + port * 2);
return 0;
} else {
return readw(mmio_base + port * 2);
}
}
static const void *daqboard2000_find_boardinfo(struct comedi_device *dev,
struct pci_dev *pcidev)
{
const struct daq200_boardtype *board;
int i;
if (pcidev->subsystem_vendor != PCI_VENDOR_ID_IOTECH)
return NULL;
for (i = 0; i < ARRAY_SIZE(boardtypes); i++) {
board = &boardtypes[i];
if (pcidev->subsystem_device == board->id)
return board;
}
return NULL;
}
static int daqboard2000_auto_attach(struct comedi_device *dev,
unsigned long context_unused)
{
struct pci_dev *pcidev = comedi_to_pci_dev(dev);
const struct daq200_boardtype *board;
struct daqboard2000_private *devpriv;
struct comedi_subdevice *s;
int result;
board = daqboard2000_find_boardinfo(dev, pcidev);
if (!board)
return -ENODEV;
dev->board_ptr = board;
dev->board_name = board->name;
devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
if (!devpriv)
return -ENOMEM;
result = comedi_pci_enable(dev);
if (result)
return result;
devpriv->plx = pci_ioremap_bar(pcidev, 0);
devpriv->daq = pci_ioremap_bar(pcidev, 2);
if (!devpriv->plx || !devpriv->daq)
return -ENOMEM;
result = comedi_alloc_subdevices(dev, 3);
if (result)
return result;
readl(devpriv->plx + 0x6c);
result = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
DAQBOARD2000_FIRMWARE,
initialize_daqboard2000, 0);
if (result < 0)
return result;
daqboard2000_initializeAdc(dev);
daqboard2000_initializeDac(dev);
s = &dev->subdevices[0];
/* ai subdevice */
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = 24;
s->maxdata = 0xffff;
s->insn_read = daqboard2000_ai_insn_read;
s->range_table = &range_daqboard2000_ai;
s = &dev->subdevices[1];
/* ao subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 2;
s->maxdata = 0xffff;
s->insn_read = daqboard2000_ao_insn_read;
s->insn_write = daqboard2000_ao_insn_write;
s->range_table = &range_bipolar10;
s = &dev->subdevices[2];
result = subdev_8255_init(dev, s, daqboard2000_8255_cb,
(unsigned long)(devpriv->daq + dioP2ExpansionIO8Bit));
if (result)
return result;
return 0;
}
static void daqboard2000_detach(struct comedi_device *dev)
{
struct daqboard2000_private *devpriv = dev->private;
if (dev->irq)
free_irq(dev->irq, dev);
if (devpriv) {
if (devpriv->daq)
iounmap(devpriv->daq);
if (devpriv->plx)
iounmap(devpriv->plx);
}
comedi_pci_disable(dev);
}
static struct comedi_driver daqboard2000_driver = {
.driver_name = "daqboard2000",
.module = THIS_MODULE,
.auto_attach = daqboard2000_auto_attach,
.detach = daqboard2000_detach,
};
static int daqboard2000_pci_probe(struct pci_dev *dev,
const struct pci_device_id *id)
{
return comedi_pci_auto_config(dev, &daqboard2000_driver,
id->driver_data);
}
static const struct pci_device_id daqboard2000_pci_table[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_IOTECH, 0x0409) },
{ 0 }
};
MODULE_DEVICE_TABLE(pci, daqboard2000_pci_table);
static struct pci_driver daqboard2000_pci_driver = {
.name = "daqboard2000",
.id_table = daqboard2000_pci_table,
.probe = daqboard2000_pci_probe,
.remove = comedi_pci_auto_unconfig,
};
module_comedi_pci_driver(daqboard2000_driver, daqboard2000_pci_driver);
MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
MODULE_FIRMWARE(DAQBOARD2000_FIRMWARE);
|