4 Copyright (C) 2004,2005 ADDI-DATA GmbH for the source code of this module.
10 Fax: +49(0)7223/9493-92
11 http://www.addi-data.com
14 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.
16 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.
22 +-----------------------------------------------------------------------+
23 | (C) ADDI-DATA GmbH Dieselstraße 3 D-77833 Ottersweier |
24 +-----------------------------------------------------------------------+
25 | Tel : +49 (0) 7223/9493-0 | email : info@addi-data.com |
26 | Fax : +49 (0) 7223/9493-92 | Internet : http://www.addi-data.com |
27 +-------------------------------+---------------------------------------+
28 | Project : APCI-3200 | Compiler : GCC |
29 | Module name : hwdrv_apci3200.c| Version : 2.96 |
30 +-------------------------------+---------------------------------------+
31 | Project manager: Eric Stolz | Date : 02/12/2002 |
32 +-------------------------------+---------------------------------------+
33 | Description : Hardware Layer Access For APCI-3200 |
34 +-----------------------------------------------------------------------+
36 +----------+-----------+------------------------------------------------+
37 | Date | Author | Description of updates |
38 +----------+-----------+------------------------------------------------+
39 | 02.07.04 | J. Krauth | Modification from the driver in order to |
40 | | | correct some errors when using several boards. |
43 +----------+-----------+------------------------------------------------+
44 | 26.10.04 | J. Krauth | - Update for COMEDI 0.7.68 |
45 | | | - Read eeprom value |
46 | | | - Append APCI-3300 |
47 +----------+-----------+------------------------------------------------+
50 /* #define PRINT_INFO */
52 /* Card Specific information */
53 /* #define APCI3200_ADDRESS_RANGE 264 */
55 /* Analog Input related Defines */
56 #define APCI3200_AI_OFFSET_GAIN 0
57 #define APCI3200_AI_SC_TEST 4
58 #define APCI3200_AI_IRQ 8
59 #define APCI3200_AI_AUTOCAL 12
60 #define APCI3200_RELOAD_CONV_TIME_VAL 32
61 #define APCI3200_CONV_TIME_TIME_BASE 36
62 #define APCI3200_RELOAD_DELAY_TIME_VAL 40
63 #define APCI3200_DELAY_TIME_TIME_BASE 44
64 #define APCI3200_AI_MODULE1 0
65 #define APCI3200_AI_MODULE2 64
66 #define APCI3200_AI_MODULE3 128
67 #define APCI3200_AI_MODULE4 192
70 #define APCI3200_AI_EOSIRQ 16
71 #define APCI3200_AI_EOS 20
72 #define APCI3200_AI_CHAN_ID 24
73 #define APCI3200_AI_CHAN_VAL 28
74 #define ANALOG_INPUT 0
78 #define ENABLE_EXT_TRIG 1
79 #define ENABLE_EXT_GATE 2
80 #define ENABLE_EXT_TRIG_GATE 3
82 #define APCI3200_MAXVOLT 2.5
83 #define ADDIDATA_GREATER_THAN_TEST 0
84 #define ADDIDATA_LESS_THAN_TEST 1
86 #define ADDIDATA_UNIPOLAR 1
87 #define ADDIDATA_BIPOLAR 2
91 /* ANALOG INPUT RANGE */
92 static const struct comedi_lrange range_apci3200_ai = {
105 static const struct comedi_lrange range_apci3300_ai = {
121 int i_AutoCalibration;
122 unsigned int ui_ReloadValue;
123 unsigned int ui_TimeUnitReloadVal;
125 int i_ModuleSelection;
126 } Config_Parameters_Module1, Config_Parameters_Module2,
127 Config_Parameters_Module3, Config_Parameters_Module4;
130 struct str_ADDIDATA_RTDStruct {
131 unsigned int ul_NumberOfValue;
132 unsigned int *pul_ResistanceValue;
133 unsigned int *pul_TemperatureValue;
137 unsigned long ul_CurrentSourceCJC;
138 unsigned long ul_CurrentSource[5];
139 unsigned long ul_GainFactor[8]; /* Gain Factor */
140 unsigned int w_GainValue[10];
143 struct str_BoardInfos {
149 int i_ADDIDATAPolarity;
151 int i_AutoCalibration;
152 int i_ADDIDATAConversionTime;
153 int i_ADDIDATAConversionTimeUnit;
162 unsigned int ui_Channel_num;
165 unsigned int ui_InterruptChannelValue[144]; /* Buffer */
166 unsigned char b_StructInitialized;
167 /* 7 is the maximal number of channels */
168 unsigned int ui_ScanValueArray[7 + 12];
170 int i_ConnectionType;
172 struct str_Module s_Module[MAX_MODULE];
175 /* BEGIN JK 06.07.04: Management of sevrals boards */
177 int i_CJCAvailable=1;
179 int i_CJCGain=2;/* changed from 0 to 2 */
180 int i_InterruptFlag=0;
181 int i_ADDIDATAPolarity;
183 int i_AutoCalibration=0; /* : auto calibration */
184 int i_ADDIDATAConversionTime;
185 int i_ADDIDATAConversionTimeUnit;
188 int i_ChannelCount=0;
194 unsigned int ui_Channel_num=0;
195 static int i_Count=0;
197 unsigned int ui_InterruptChannelValue[96]; /* Buffer */
199 struct str_BoardInfos s_BoardInfos[100]; /* 100 will be the max number of boards to be used */
200 /* END JK 06.07.04: Management of sevrals boards */
202 #define AMCC_OP_REG_MCSR 0x3c
203 #define EEPROM_BUSY 0x80000000
204 #define NVCMD_LOAD_LOW (0x4 << 5) /* nvRam load low command */
205 #define NVCMD_LOAD_HIGH (0x5 << 5) /* nvRam load high command */
206 #define NVCMD_BEGIN_READ (0x7 << 5) /* nvRam begin read command */
207 #define NVCMD_BEGIN_WRITE (0x6 << 5) /* EEPROM begin write command */
209 static int i_AddiHeaderRW_ReadEeprom(int i_NbOfWordsToRead,
210 unsigned int dw_PCIBoardEepromAddress,
211 unsigned short w_EepromStartAddress,
212 unsigned short *pw_DataRead)
214 unsigned int dw_eeprom_busy = 0;
218 unsigned char pb_ReadByte[1];
219 unsigned char b_ReadLowByte = 0;
220 unsigned char b_ReadHighByte = 0;
221 unsigned char b_SelectedAddressLow = 0;
222 unsigned char b_SelectedAddressHigh = 0;
223 unsigned short w_ReadWord = 0;
225 for (i_WordCounter = 0; i_WordCounter < i_NbOfWordsToRead;
229 inl(dw_PCIBoardEepromAddress +
231 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
232 } while (dw_eeprom_busy == EEPROM_BUSY);
234 for (i_Counter = 0; i_Counter < 2; i_Counter++) {
235 b_SelectedAddressLow = (w_EepromStartAddress + i_Counter) % 256; /* Read the low 8 bit part */
236 b_SelectedAddressHigh = (w_EepromStartAddress + i_Counter) / 256; /* Read the high 8 bit part */
238 /* Select the load low address mode */
240 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
246 inl(dw_PCIBoardEepromAddress +
248 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
249 } while (dw_eeprom_busy == EEPROM_BUSY);
251 /* Load the low address */
252 outb(b_SelectedAddressLow,
253 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
259 inl(dw_PCIBoardEepromAddress +
261 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
262 } while (dw_eeprom_busy == EEPROM_BUSY);
264 /* Select the load high address mode */
265 outb(NVCMD_LOAD_HIGH,
266 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
272 inl(dw_PCIBoardEepromAddress +
274 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
275 } while (dw_eeprom_busy == EEPROM_BUSY);
277 /* Load the high address */
278 outb(b_SelectedAddressHigh,
279 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
285 inl(dw_PCIBoardEepromAddress +
287 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
288 } while (dw_eeprom_busy == EEPROM_BUSY);
290 /* Select the READ mode */
291 outb(NVCMD_BEGIN_READ,
292 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
298 inl(dw_PCIBoardEepromAddress +
300 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
301 } while (dw_eeprom_busy == EEPROM_BUSY);
303 /* Read data into the EEPROM */
305 inb(dw_PCIBoardEepromAddress +
306 AMCC_OP_REG_MCSR + 2);
311 inl(dw_PCIBoardEepromAddress +
313 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
314 } while (dw_eeprom_busy == EEPROM_BUSY);
316 /* Select the upper address part */
318 b_ReadLowByte = pb_ReadByte[0];
320 b_ReadHighByte = pb_ReadByte[0];
328 (b_ReadLowByte | (((unsigned short)b_ReadHighByte) *
331 pw_DataRead[i_WordCounter] = w_ReadWord;
333 w_EepromStartAddress += 2; /* to read the next word */
335 } /* for (...) i_NbOfWordsToRead */
339 static void v_GetAPCI3200EepromCalibrationValue(unsigned int dw_PCIBoardEepromAddress,
340 struct str_BoardInfos *BoardInformations)
342 unsigned short w_AnalogInputMainHeaderAddress;
343 unsigned short w_AnalogInputComponentAddress;
344 unsigned short w_NumberOfModuls = 0;
345 unsigned short w_CurrentSources[2];
346 unsigned short w_ModulCounter = 0;
347 unsigned short w_FirstHeaderSize = 0;
348 unsigned short w_NumberOfInputs = 0;
349 unsigned short w_CJCFlag = 0;
350 unsigned short w_NumberOfGainValue = 0;
351 unsigned short w_SingleHeaderAddress = 0;
352 unsigned short w_SingleHeaderSize = 0;
353 unsigned short w_Input = 0;
354 unsigned short w_GainFactorAddress = 0;
355 unsigned short w_GainFactorValue[2];
356 unsigned short w_GainIndex = 0;
357 unsigned short w_GainValue = 0;
359 /*****************************************/
360 /** Get the Analog input header address **/
361 /*****************************************/
362 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
363 dw_PCIBoardEepromAddress, 0x116, /* w_EepromStartAddress: Analog input header address */
364 &w_AnalogInputMainHeaderAddress);
366 /*******************************************/
367 /** Compute the real analog input address **/
368 /*******************************************/
369 w_AnalogInputMainHeaderAddress = w_AnalogInputMainHeaderAddress + 0x100;
371 /******************************/
372 /** Get the number of moduls **/
373 /******************************/
374 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
375 dw_PCIBoardEepromAddress, w_AnalogInputMainHeaderAddress + 0x02, /* w_EepromStartAddress: Number of conponment */
378 for (w_ModulCounter = 0; w_ModulCounter < w_NumberOfModuls;
380 /***********************************/
381 /** Compute the component address **/
382 /***********************************/
383 w_AnalogInputComponentAddress =
384 w_AnalogInputMainHeaderAddress +
385 (w_FirstHeaderSize * w_ModulCounter) + 0x04;
387 /****************************/
388 /** Read first header size **/
389 /****************************/
390 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
391 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress, /* Address of the first header */
394 w_FirstHeaderSize = w_FirstHeaderSize >> 4;
396 /***************************/
397 /** Read number of inputs **/
398 /***************************/
399 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
400 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 0x06, /* Number of inputs for the first modul */
403 w_NumberOfInputs = w_NumberOfInputs >> 4;
405 /***********************/
406 /** Read the CJC flag **/
407 /***********************/
408 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
409 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 0x08, /* CJC flag */
412 w_CJCFlag = (w_CJCFlag >> 3) & 0x1; /* Get only the CJC flag */
414 /*******************************/
415 /** Read number of gain value **/
416 /*******************************/
417 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
418 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 0x44, /* Number of gain value */
419 &w_NumberOfGainValue);
421 w_NumberOfGainValue = w_NumberOfGainValue & 0xFF;
423 /***********************************/
424 /** Compute single header address **/
425 /***********************************/
426 w_SingleHeaderAddress =
427 w_AnalogInputComponentAddress + 0x46 +
428 (((w_NumberOfGainValue / 16) + 1) * 2) +
429 (6 * w_NumberOfGainValue) +
430 (4 * (((w_NumberOfGainValue / 16) + 1) * 2));
432 /********************************************/
433 /** Read current sources value for input 1 **/
434 /********************************************/
435 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
436 dw_PCIBoardEepromAddress, w_SingleHeaderAddress, /* w_EepromStartAddress: Single header address */
437 &w_SingleHeaderSize);
439 w_SingleHeaderSize = w_SingleHeaderSize >> 4;
441 /*************************************/
442 /** Read gain factor for the module **/
443 /*************************************/
444 w_GainFactorAddress = w_AnalogInputComponentAddress;
446 for (w_GainIndex = 0; w_GainIndex < w_NumberOfGainValue;
448 /************************************/
449 /** Read gain value for the module **/
450 /************************************/
451 i_AddiHeaderRW_ReadEeprom(1, /* i_NbOfWordsToRead */
452 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 70 + (2 * (1 + (w_NumberOfGainValue / 16))) + (0x02 * w_GainIndex), /* Gain value */
455 BoardInformations->s_Module[w_ModulCounter].
456 w_GainValue[w_GainIndex] = w_GainValue;
459 printk("\n Gain value = %d",
460 BoardInformations->s_Module[w_ModulCounter].
461 w_GainValue[w_GainIndex]);
464 /*************************************/
465 /** Read gain factor for the module **/
466 /*************************************/
467 i_AddiHeaderRW_ReadEeprom(2, /* i_NbOfWordsToRead */
468 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 70 + ((2 * w_NumberOfGainValue) + (2 * (1 + (w_NumberOfGainValue / 16)))) + (0x04 * w_GainIndex), /* Gain factor */
471 BoardInformations->s_Module[w_ModulCounter].
472 ul_GainFactor[w_GainIndex] =
473 (w_GainFactorValue[1] << 16) +
474 w_GainFactorValue[0];
477 printk("\n w_GainFactorValue [%d] = %lu", w_GainIndex,
478 BoardInformations->s_Module[w_ModulCounter].
479 ul_GainFactor[w_GainIndex]);
483 /***************************************************************/
484 /** Read current source value for each channels of the module **/
485 /***************************************************************/
486 for (w_Input = 0; w_Input < w_NumberOfInputs; w_Input++) {
487 /********************************************/
488 /** Read current sources value for input 1 **/
489 /********************************************/
490 i_AddiHeaderRW_ReadEeprom(2, /* i_NbOfWordsToRead */
491 dw_PCIBoardEepromAddress,
492 (w_Input * w_SingleHeaderSize) +
493 w_SingleHeaderAddress + 0x0C, w_CurrentSources);
495 /************************************/
496 /** Save the current sources value **/
497 /************************************/
498 BoardInformations->s_Module[w_ModulCounter].
499 ul_CurrentSource[w_Input] =
500 (w_CurrentSources[0] +
501 ((w_CurrentSources[1] & 0xFFF) << 16));
504 printk("\n Current sources [%d] = %lu", w_Input,
505 BoardInformations->s_Module[w_ModulCounter].
506 ul_CurrentSource[w_Input]);
510 /***************************************/
511 /** Read the CJC current source value **/
512 /***************************************/
513 i_AddiHeaderRW_ReadEeprom(2, /* i_NbOfWordsToRead */
514 dw_PCIBoardEepromAddress,
515 (w_Input * w_SingleHeaderSize) + w_SingleHeaderAddress +
516 0x0C, w_CurrentSources);
518 /************************************/
519 /** Save the current sources value **/
520 /************************************/
521 BoardInformations->s_Module[w_ModulCounter].
522 ul_CurrentSourceCJC =
523 (w_CurrentSources[0] +
524 ((w_CurrentSources[1] & 0xFFF) << 16));
527 printk("\n Current sources CJC = %lu",
528 BoardInformations->s_Module[w_ModulCounter].
529 ul_CurrentSourceCJC);
534 static int i_APCI3200_GetChannelCalibrationValue(struct comedi_device *dev,
535 unsigned int ui_Channel_num,
536 unsigned int *CJCCurrentSource,
537 unsigned int *ChannelCurrentSource,
538 unsigned int *ChannelGainFactor)
540 int i_DiffChannel = 0;
544 printk("\n Channel = %u", ui_Channel_num);
547 /* Test if single or differential mode */
548 if (s_BoardInfos[dev->minor].i_ConnectionType == 1) {
551 if (ui_Channel_num <= 1)
552 i_DiffChannel = ui_Channel_num, i_Module = 0;
553 else if ((ui_Channel_num >= 2) && (ui_Channel_num <= 3))
554 i_DiffChannel = ui_Channel_num - 2, i_Module = 1;
555 else if ((ui_Channel_num >= 4) && (ui_Channel_num <= 5))
556 i_DiffChannel = ui_Channel_num - 4, i_Module = 2;
557 else if ((ui_Channel_num >= 6) && (ui_Channel_num <= 7))
558 i_DiffChannel = ui_Channel_num - 6, i_Module = 3;
562 if ((ui_Channel_num == 0) || (ui_Channel_num == 1))
563 i_DiffChannel = 0, i_Module = 0;
564 else if ((ui_Channel_num == 2) || (ui_Channel_num == 3))
565 i_DiffChannel = 1, i_Module = 0;
566 else if ((ui_Channel_num == 4) || (ui_Channel_num == 5))
567 i_DiffChannel = 0, i_Module = 1;
568 else if ((ui_Channel_num == 6) || (ui_Channel_num == 7))
569 i_DiffChannel = 1, i_Module = 1;
570 else if ((ui_Channel_num == 8) || (ui_Channel_num == 9))
571 i_DiffChannel = 0, i_Module = 2;
572 else if ((ui_Channel_num == 10) || (ui_Channel_num == 11))
573 i_DiffChannel = 1, i_Module = 2;
574 else if ((ui_Channel_num == 12) || (ui_Channel_num == 13))
575 i_DiffChannel = 0, i_Module = 3;
576 else if ((ui_Channel_num == 14) || (ui_Channel_num == 15))
577 i_DiffChannel = 1, i_Module = 3;
580 /* Test if thermocouple or RTD mode */
582 s_BoardInfos[dev->minor].s_Module[i_Module].ul_CurrentSourceCJC;
584 printk("\n CJCCurrentSource = %lu", *CJCCurrentSource);
587 *ChannelCurrentSource =
588 s_BoardInfos[dev->minor].s_Module[i_Module].
589 ul_CurrentSource[i_DiffChannel];
591 printk("\n ChannelCurrentSource = %lu", *ChannelCurrentSource);
596 /* Channle gain factor */
598 s_BoardInfos[dev->minor].s_Module[i_Module].
599 ul_GainFactor[s_BoardInfos[dev->minor].i_ADDIDATAGain];
601 printk("\n ChannelGainFactor = %lu", *ChannelGainFactor);
603 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
608 static int apci3200_di_insn_bits(struct comedi_device *dev,
609 struct comedi_subdevice *s,
610 struct comedi_insn *insn,
613 struct addi_private *devpriv = dev->private;
615 data[1] = inl(devpriv->i_IobaseReserved) & 0xf;
620 static int apci3200_do_insn_bits(struct comedi_device *dev,
621 struct comedi_subdevice *s,
622 struct comedi_insn *insn,
625 struct addi_private *devpriv = dev->private;
626 unsigned int mask = data[0];
627 unsigned int bits = data[1];
629 s->state = inl(devpriv->i_IobaseAddon) & 0xf;
632 s->state |= (bits & mask);
634 outl(s->state, devpriv->i_IobaseAddon);
642 static int i_APCI3200_Read1AnalogInputChannel(struct comedi_device *dev,
643 struct comedi_subdevice *s,
644 struct comedi_insn *insn,
647 struct addi_private *devpriv = dev->private;
648 unsigned int ui_EOC = 0;
649 unsigned int ui_ChannelNo = 0;
650 unsigned int ui_CommandRegister = 0;
652 /* BEGIN JK 06.07.04: Management of sevrals boards */
653 /* ui_ChannelNo=i_ChannelNo; */
654 ui_ChannelNo = s_BoardInfos[dev->minor].i_ChannelNo;
656 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
657 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
658 12) >> 19) & 1) != 1) ;
659 /*********************************/
660 /* Write the channel to configure */
661 /*********************************/
662 /* Begin JK 20.10.2004: Bad channel value is used when using differential mode */
663 /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
664 /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
665 outl(0 | s_BoardInfos[dev->minor].i_ChannelNo,
666 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x4);
667 /* End JK 20.10.2004: Bad channel value is used when using differential mode */
669 /*******************************/
670 /* Set the convert timing unit */
671 /*******************************/
672 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
673 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
674 12) >> 19) & 1) != 1) ;
676 /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
677 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
678 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
680 /**************************/
681 /* Set the convert timing */
682 /**************************/
683 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
684 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
685 12) >> 19) & 1) != 1) ;
687 /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
688 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
689 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
691 /**************************************************************************/
692 /* Set the start end stop index to the selected channel and set the start */
693 /**************************************************************************/
695 ui_CommandRegister = ui_ChannelNo | (ui_ChannelNo << 8) | 0x80000;
697 /*********************************/
698 /*Test if the interrupt is enable */
699 /*********************************/
701 /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
702 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
703 /************************/
704 /* Enable the interrupt */
705 /************************/
706 ui_CommandRegister = ui_CommandRegister | 0x00100000;
707 } /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
709 /******************************/
710 /* Write the command register */
711 /******************************/
712 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
713 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
714 12) >> 19) & 1) != 1) ;
716 /* outl(ui_CommandRegister, devpriv->iobase+i_Offset + 8); */
717 outl(ui_CommandRegister,
718 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
720 /*****************************/
721 /*Test if interrupt is enable */
722 /*****************************/
723 /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
724 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
726 /*************************/
727 /*Read the EOC Status bit */
728 /*************************/
730 /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
731 ui_EOC = inl(devpriv->iobase +
732 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
734 } while (ui_EOC != 1);
736 /***************************************/
737 /* Read the digital value of the input */
738 /***************************************/
740 /* data[0] = inl (devpriv->iobase+i_Offset + 28); */
742 inl(devpriv->iobase +
743 s_BoardInfos[dev->minor].i_Offset + 28);
744 /* END JK 06.07.04: Management of sevrals boards */
746 } /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
750 static int i_APCI3200_ReadCalibrationOffsetValue(struct comedi_device *dev,
753 struct addi_private *devpriv = dev->private;
754 unsigned int ui_Temp = 0, ui_EOC = 0;
755 unsigned int ui_CommandRegister = 0;
757 /* BEGIN JK 06.07.04: Management of sevrals boards */
758 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
759 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
760 12) >> 19) & 1) != 1) ;
761 /*********************************/
762 /* Write the channel to configure */
763 /*********************************/
764 /* Begin JK 20.10.2004: This seems not necessary ! */
765 /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
766 /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
767 /* End JK 20.10.2004: This seems not necessary ! */
769 /*******************************/
770 /* Set the convert timing unit */
771 /*******************************/
772 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
773 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
774 12) >> 19) & 1) != 1) ;
775 /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
776 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
777 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
778 /**************************/
779 /* Set the convert timing */
780 /**************************/
781 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
782 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
783 12) >> 19) & 1) != 1) ;
784 /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
785 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
786 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
787 /*****************************/
788 /*Read the calibration offset */
789 /*****************************/
790 /* ui_Temp = inl(devpriv->iobase+i_Offset + 12); */
791 ui_Temp = inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
793 /*********************************/
794 /*Configure the Offset Conversion */
795 /*********************************/
796 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
797 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
798 12) >> 19) & 1) != 1) ;
799 /* outl((ui_Temp | 0x00020000), devpriv->iobase+i_Offset + 12); */
800 outl((ui_Temp | 0x00020000),
801 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
802 /*******************************/
803 /*Initialise ui_CommandRegister */
804 /*******************************/
806 ui_CommandRegister = 0;
808 /*********************************/
809 /*Test if the interrupt is enable */
810 /*********************************/
812 /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
813 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
815 /**********************/
816 /*Enable the interrupt */
817 /**********************/
819 ui_CommandRegister = ui_CommandRegister | 0x00100000;
821 } /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
823 /**********************/
824 /*Start the conversion */
825 /**********************/
826 ui_CommandRegister = ui_CommandRegister | 0x00080000;
828 /***************************/
829 /*Write the command regiter */
830 /***************************/
831 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
832 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
833 12) >> 19) & 1) != 1) ;
834 /* outl(ui_CommandRegister, devpriv->iobase+i_Offset + 8); */
835 outl(ui_CommandRegister,
836 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
838 /*****************************/
839 /*Test if interrupt is enable */
840 /*****************************/
842 /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
843 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
846 /*******************/
847 /*Read the EOC flag */
848 /*******************/
850 /* ui_EOC = inl (devpriv->iobase+i_Offset + 20) & 1; */
851 ui_EOC = inl(devpriv->iobase +
852 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
854 } while (ui_EOC != 1);
856 /**************************************************/
857 /*Read the digital value of the calibration Offset */
858 /**************************************************/
860 /* data[0] = inl(devpriv->iobase+i_Offset+ 28); */
862 inl(devpriv->iobase +
863 s_BoardInfos[dev->minor].i_Offset + 28);
864 } /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
868 static int i_APCI3200_ReadCalibrationGainValue(struct comedi_device *dev,
871 struct addi_private *devpriv = dev->private;
872 unsigned int ui_EOC = 0;
873 int ui_CommandRegister = 0;
875 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
876 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
877 12) >> 19) & 1) != 1) ;
878 /*********************************/
879 /* Write the channel to configure */
880 /*********************************/
881 /* Begin JK 20.10.2004: This seems not necessary ! */
882 /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
883 /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
884 /* End JK 20.10.2004: This seems not necessary ! */
886 /***************************/
887 /*Read the calibration gain */
888 /***************************/
889 /*******************************/
890 /* Set the convert timing unit */
891 /*******************************/
892 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
893 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
894 12) >> 19) & 1) != 1) ;
895 /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
896 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
897 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
898 /**************************/
899 /* Set the convert timing */
900 /**************************/
901 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
902 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
903 12) >> 19) & 1) != 1) ;
904 /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
905 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
906 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
907 /*******************************/
908 /*Configure the Gain Conversion */
909 /*******************************/
910 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
911 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
912 12) >> 19) & 1) != 1) ;
913 /* outl(0x00040000 , devpriv->iobase+i_Offset + 12); */
915 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
917 /*******************************/
918 /*Initialise ui_CommandRegister */
919 /*******************************/
921 ui_CommandRegister = 0;
923 /*********************************/
924 /*Test if the interrupt is enable */
925 /*********************************/
927 /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
928 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
930 /**********************/
931 /*Enable the interrupt */
932 /**********************/
934 ui_CommandRegister = ui_CommandRegister | 0x00100000;
936 } /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
938 /**********************/
939 /*Start the conversion */
940 /**********************/
942 ui_CommandRegister = ui_CommandRegister | 0x00080000;
943 /***************************/
944 /*Write the command regiter */
945 /***************************/
946 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
947 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
948 12) >> 19) & 1) != 1) ;
949 /* outl(ui_CommandRegister , devpriv->iobase+i_Offset + 8); */
950 outl(ui_CommandRegister,
951 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
953 /*****************************/
954 /*Test if interrupt is enable */
955 /*****************************/
957 /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
958 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
962 /*******************/
963 /*Read the EOC flag */
964 /*******************/
966 /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
967 ui_EOC = inl(devpriv->iobase +
968 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
970 } while (ui_EOC != 1);
972 /************************************************/
973 /*Read the digital value of the calibration Gain */
974 /************************************************/
976 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
978 inl(devpriv->iobase +
979 s_BoardInfos[dev->minor].i_Offset + 28);
981 } /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
985 static int i_APCI3200_ReadCJCValue(struct comedi_device *dev,
988 struct addi_private *devpriv = dev->private;
989 unsigned int ui_EOC = 0;
990 int ui_CommandRegister = 0;
992 /******************************/
993 /*Set the converting time unit */
994 /******************************/
996 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
997 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
998 12) >> 19) & 1) != 1) ;
1000 /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1001 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1002 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1003 /**************************/
1004 /* Set the convert timing */
1005 /**************************/
1006 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1007 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1008 12) >> 19) & 1) != 1) ;
1010 /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1011 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1012 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1014 /******************************/
1015 /*Configure the CJC Conversion */
1016 /******************************/
1017 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1018 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1019 12) >> 19) & 1) != 1) ;
1021 /* outl( 0x00000400 , devpriv->iobase+i_Offset + 4); */
1023 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1024 /*******************************/
1025 /*Initialise dw_CommandRegister */
1026 /*******************************/
1027 ui_CommandRegister = 0;
1028 /*********************************/
1029 /*Test if the interrupt is enable */
1030 /*********************************/
1031 /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1032 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1033 /**********************/
1034 /*Enable the interrupt */
1035 /**********************/
1036 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1039 /**********************/
1040 /*Start the conversion */
1041 /**********************/
1043 ui_CommandRegister = ui_CommandRegister | 0x00080000;
1045 /***************************/
1046 /*Write the command regiter */
1047 /***************************/
1048 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1049 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1050 12) >> 19) & 1) != 1) ;
1051 /* outl(ui_CommandRegister , devpriv->iobase+i_Offset + 8); */
1052 outl(ui_CommandRegister,
1053 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1055 /*****************************/
1056 /*Test if interrupt is enable */
1057 /*****************************/
1059 /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1060 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1063 /*******************/
1064 /*Read the EOC flag */
1065 /*******************/
1067 /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1068 ui_EOC = inl(devpriv->iobase +
1069 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1071 } while (ui_EOC != 1);
1073 /***********************************/
1074 /*Read the digital value of the CJC */
1075 /***********************************/
1077 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
1079 inl(devpriv->iobase +
1080 s_BoardInfos[dev->minor].i_Offset + 28);
1082 } /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1086 static int i_APCI3200_ReadCJCCalOffset(struct comedi_device *dev,
1089 struct addi_private *devpriv = dev->private;
1090 unsigned int ui_EOC = 0;
1091 int ui_CommandRegister = 0;
1093 /*******************************************/
1094 /*Read calibration offset value for the CJC */
1095 /*******************************************/
1096 /*******************************/
1097 /* Set the convert timing unit */
1098 /*******************************/
1099 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1100 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1101 12) >> 19) & 1) != 1) ;
1102 /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1103 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1104 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1105 /**************************/
1106 /* Set the convert timing */
1107 /**************************/
1108 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1109 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1110 12) >> 19) & 1) != 1) ;
1111 /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1112 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1113 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1114 /******************************/
1115 /*Configure the CJC Conversion */
1116 /******************************/
1117 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1118 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1119 12) >> 19) & 1) != 1) ;
1120 /* outl(0x00000400 , devpriv->iobase+i_Offset + 4); */
1122 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1123 /*********************************/
1124 /*Configure the Offset Conversion */
1125 /*********************************/
1126 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1127 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1128 12) >> 19) & 1) != 1) ;
1129 /* outl(0x00020000, devpriv->iobase+i_Offset + 12); */
1131 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
1132 /*******************************/
1133 /*Initialise ui_CommandRegister */
1134 /*******************************/
1135 ui_CommandRegister = 0;
1136 /*********************************/
1137 /*Test if the interrupt is enable */
1138 /*********************************/
1140 /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1141 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1142 /**********************/
1143 /*Enable the interrupt */
1144 /**********************/
1145 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1149 /**********************/
1150 /*Start the conversion */
1151 /**********************/
1152 ui_CommandRegister = ui_CommandRegister | 0x00080000;
1153 /***************************/
1154 /*Write the command regiter */
1155 /***************************/
1156 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1157 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1158 12) >> 19) & 1) != 1) ;
1159 /* outl(ui_CommandRegister,devpriv->iobase+i_Offset + 8); */
1160 outl(ui_CommandRegister,
1161 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1162 /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1163 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1165 /*******************/
1166 /*Read the EOC flag */
1167 /*******************/
1168 /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1169 ui_EOC = inl(devpriv->iobase +
1170 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1171 } while (ui_EOC != 1);
1173 /**************************************************/
1174 /*Read the digital value of the calibration Offset */
1175 /**************************************************/
1176 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
1178 inl(devpriv->iobase +
1179 s_BoardInfos[dev->minor].i_Offset + 28);
1180 } /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1184 static int i_APCI3200_ReadCJCCalGain(struct comedi_device *dev,
1187 struct addi_private *devpriv = dev->private;
1188 unsigned int ui_EOC = 0;
1189 int ui_CommandRegister = 0;
1191 /*******************************/
1192 /* Set the convert timing unit */
1193 /*******************************/
1194 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1195 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1196 12) >> 19) & 1) != 1) ;
1197 /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1198 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1199 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1200 /**************************/
1201 /* Set the convert timing */
1202 /**************************/
1203 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1204 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1205 12) >> 19) & 1) != 1) ;
1206 /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1207 outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1208 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1209 /******************************/
1210 /*Configure the CJC Conversion */
1211 /******************************/
1212 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1213 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1214 12) >> 19) & 1) != 1) ;
1215 /* outl(0x00000400,devpriv->iobase+i_Offset + 4); */
1217 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1218 /*******************************/
1219 /*Configure the Gain Conversion */
1220 /*******************************/
1221 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1222 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1223 12) >> 19) & 1) != 1) ;
1224 /* outl(0x00040000,devpriv->iobase+i_Offset + 12); */
1226 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
1228 /*******************************/
1229 /*Initialise dw_CommandRegister */
1230 /*******************************/
1231 ui_CommandRegister = 0;
1232 /*********************************/
1233 /*Test if the interrupt is enable */
1234 /*********************************/
1235 /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1236 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1237 /**********************/
1238 /*Enable the interrupt */
1239 /**********************/
1240 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1242 /**********************/
1243 /*Start the conversion */
1244 /**********************/
1245 ui_CommandRegister = ui_CommandRegister | 0x00080000;
1246 /***************************/
1247 /*Write the command regiter */
1248 /***************************/
1249 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1250 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1251 12) >> 19) & 1) != 1) ;
1252 /* outl(ui_CommandRegister ,devpriv->iobase+i_Offset + 8); */
1253 outl(ui_CommandRegister,
1254 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1255 /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1256 if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1258 /*******************/
1259 /*Read the EOC flag */
1260 /*******************/
1261 /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1262 ui_EOC = inl(devpriv->iobase +
1263 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1264 } while (ui_EOC != 1);
1265 /************************************************/
1266 /*Read the digital value of the calibration Gain */
1267 /************************************************/
1268 /* data[0] = inl (devpriv->iobase+i_Offset + 28); */
1270 inl(devpriv->iobase +
1271 s_BoardInfos[dev->minor].i_Offset + 28);
1272 } /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1276 static int i_APCI3200_Reset(struct comedi_device *dev)
1278 struct addi_private *devpriv = dev->private;
1280 unsigned int dw_Dummy;
1282 /* i_InterruptFlag=0; */
1283 /* i_Initialised==0; */
1287 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1288 s_BoardInfos[dev->minor].i_Initialised = 0;
1289 s_BoardInfos[dev->minor].i_Count = 0;
1290 s_BoardInfos[dev->minor].i_Sum = 0;
1291 s_BoardInfos[dev->minor].b_StructInitialized = 0;
1293 outl(0x83838383, devpriv->i_IobaseAmcc + 0x60);
1295 /* Enable the interrupt for the controller */
1296 dw_Dummy = inl(devpriv->i_IobaseAmcc + 0x38);
1297 outl(dw_Dummy | 0x2000, devpriv->i_IobaseAmcc + 0x38);
1298 outl(0, devpriv->i_IobaseAddon); /* Resets the output */
1300 /*Empty the buffer */
1302 for (i_Temp = 0; i_Temp <= 95; i_Temp++) {
1303 /* ui_InterruptChannelValue[i_Temp]=0; */
1304 s_BoardInfos[dev->minor].ui_InterruptChannelValue[i_Temp] = 0;
1305 } /* for(i_Temp=0;i_Temp<=95;i_Temp++) */
1306 /*****************************/
1307 /*Reset the START and IRQ bit */
1308 /*****************************/
1309 for (i_Temp = 0; i_Temp <= 192;) {
1310 while (((inl(devpriv->iobase + i_Temp + 12) >> 19) & 1) != 1) ;
1311 outl(0, devpriv->iobase + i_Temp + 8);
1312 i_Temp = i_Temp + 64;
1313 } /* for(i_Temp=0;i_Temp<=192;i_Temp+64) */
1318 * Read value of the selected channel
1320 * data[0] : Digital Value Of Input
1321 * data[1] : Calibration Offset Value
1322 * data[2] : Calibration Gain Value
1323 * data[3] : CJC value
1324 * data[4] : CJC offset value
1325 * data[5] : CJC gain value
1326 * data[6] : CJC current source from eeprom
1327 * data[7] : Channel current source from eeprom
1328 * data[8] : Channle gain factor from eeprom
1330 static int i_APCI3200_ReadAnalogInput(struct comedi_device *dev,
1331 struct comedi_subdevice *s,
1332 struct comedi_insn *insn,
1335 unsigned int ui_DummyValue = 0;
1336 int i_ConvertCJCCalibration;
1339 /* BEGIN JK 06.07.04: Management of sevrals boards */
1340 /* if(i_Initialised==0) */
1341 if (s_BoardInfos[dev->minor].i_Initialised == 0)
1342 /* END JK 06.07.04: Management of sevrals boards */
1344 i_APCI3200_Reset(dev);
1346 } /* if(i_Initialised==0); */
1349 printk("\n insn->unused[0] = %i", insn->unused[0]);
1352 switch (insn->unused[0]) {
1355 i_APCI3200_Read1AnalogInputChannel(dev, s, insn,
1357 /* BEGIN JK 06.07.04: Management of sevrals boards */
1358 /* ui_InterruptChannelValue[i_Count+0]=ui_DummyValue; */
1359 s_BoardInfos[dev->minor].
1360 ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1361 i_Count + 0] = ui_DummyValue;
1362 /* END JK 06.07.04: Management of sevrals boards */
1364 /* Begin JK 25.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1365 i_APCI3200_GetChannelCalibrationValue(dev,
1366 s_BoardInfos[dev->minor].ui_Channel_num,
1367 &s_BoardInfos[dev->minor].
1368 ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1370 &s_BoardInfos[dev->minor].
1371 ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1373 &s_BoardInfos[dev->minor].
1374 ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1378 printk("\n s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count+6] = %lu", s_BoardInfos[dev->minor].ui_InterruptChannelValue[s_BoardInfos[dev->minor].i_Count + 6]);
1380 printk("\n s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count+7] = %lu", s_BoardInfos[dev->minor].ui_InterruptChannelValue[s_BoardInfos[dev->minor].i_Count + 7]);
1382 printk("\n s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count+8] = %lu", s_BoardInfos[dev->minor].ui_InterruptChannelValue[s_BoardInfos[dev->minor].i_Count + 8]);
1385 /* End JK 25.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1387 /* BEGIN JK 06.07.04: Management of sevrals boards */
1388 /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE) && (i_CJCAvailable==1)) */
1389 if ((s_BoardInfos[dev->minor].i_ADDIDATAType == 2)
1390 && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE)
1391 && (s_BoardInfos[dev->minor].i_CJCAvailable == 1))
1392 /* END JK 06.07.04: Management of sevrals boards */
1394 i_APCI3200_ReadCJCValue(dev, &ui_DummyValue);
1395 /* BEGIN JK 06.07.04: Management of sevrals boards */
1396 /* ui_InterruptChannelValue[i_Count + 3]=ui_DummyValue; */
1397 s_BoardInfos[dev->minor].
1398 ui_InterruptChannelValue[s_BoardInfos[dev->
1399 minor].i_Count + 3] = ui_DummyValue;
1400 /* END JK 06.07.04: Management of sevrals boards */
1401 } /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)) */
1403 /* BEGIN JK 06.07.04: Management of sevrals boards */
1404 /* ui_InterruptChannelValue[i_Count + 3]=0; */
1405 s_BoardInfos[dev->minor].
1406 ui_InterruptChannelValue[s_BoardInfos[dev->
1407 minor].i_Count + 3] = 0;
1408 /* END JK 06.07.04: Management of sevrals boards */
1409 } /* elseif((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE) && (i_CJCAvailable==1)) */
1411 /* BEGIN JK 06.07.04: Management of sevrals boards */
1412 /* if (( i_AutoCalibration == FALSE) && (i_InterruptFlag == FALSE)) */
1413 if ((s_BoardInfos[dev->minor].i_AutoCalibration == FALSE)
1414 && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE))
1415 /* END JK 06.07.04: Management of sevrals boards */
1417 i_APCI3200_ReadCalibrationOffsetValue(dev,
1419 /* BEGIN JK 06.07.04: Management of sevrals boards */
1420 /* ui_InterruptChannelValue[i_Count + 1]=ui_DummyValue; */
1421 s_BoardInfos[dev->minor].
1422 ui_InterruptChannelValue[s_BoardInfos[dev->
1423 minor].i_Count + 1] = ui_DummyValue;
1424 /* END JK 06.07.04: Management of sevrals boards */
1425 i_APCI3200_ReadCalibrationGainValue(dev,
1427 /* BEGIN JK 06.07.04: Management of sevrals boards */
1428 /* ui_InterruptChannelValue[i_Count + 2]=ui_DummyValue; */
1429 s_BoardInfos[dev->minor].
1430 ui_InterruptChannelValue[s_BoardInfos[dev->
1431 minor].i_Count + 2] = ui_DummyValue;
1432 /* END JK 06.07.04: Management of sevrals boards */
1433 } /* if (( i_AutoCalibration == FALSE) && (i_InterruptFlag == FALSE)) */
1435 /* BEGIN JK 06.07.04: Management of sevrals boards */
1436 /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)&& (i_CJCAvailable==1)) */
1437 if ((s_BoardInfos[dev->minor].i_ADDIDATAType == 2)
1438 && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE)
1439 && (s_BoardInfos[dev->minor].i_CJCAvailable == 1))
1440 /* END JK 06.07.04: Management of sevrals boards */
1442 /**********************************************************/
1443 /*Test if the Calibration channel must be read for the CJC */
1444 /**********************************************************/
1445 /**********************************/
1446 /*Test if the polarity is the same */
1447 /**********************************/
1448 /* BEGIN JK 06.07.04: Management of sevrals boards */
1449 /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
1450 if (s_BoardInfos[dev->minor].i_CJCPolarity !=
1451 s_BoardInfos[dev->minor].i_ADDIDATAPolarity)
1452 /* END JK 06.07.04: Management of sevrals boards */
1454 i_ConvertCJCCalibration = 1;
1455 } /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
1457 /* BEGIN JK 06.07.04: Management of sevrals boards */
1458 /* if(i_CJCGain==i_ADDIDATAGain) */
1459 if (s_BoardInfos[dev->minor].i_CJCGain ==
1460 s_BoardInfos[dev->minor].i_ADDIDATAGain)
1461 /* END JK 06.07.04: Management of sevrals boards */
1463 i_ConvertCJCCalibration = 0;
1464 } /* if(i_CJCGain==i_ADDIDATAGain) */
1466 i_ConvertCJCCalibration = 1;
1467 } /* elseif(i_CJCGain==i_ADDIDATAGain) */
1468 } /* elseif(i_CJCPolarity!=i_ADDIDATAPolarity) */
1469 if (i_ConvertCJCCalibration == 1) {
1470 i_APCI3200_ReadCJCCalOffset(dev,
1472 /* BEGIN JK 06.07.04: Management of sevrals boards */
1473 /* ui_InterruptChannelValue[i_Count+4]=ui_DummyValue; */
1474 s_BoardInfos[dev->minor].
1475 ui_InterruptChannelValue[s_BoardInfos
1476 [dev->minor].i_Count + 4] =
1478 /* END JK 06.07.04: Management of sevrals boards */
1480 i_APCI3200_ReadCJCCalGain(dev, &ui_DummyValue);
1482 /* BEGIN JK 06.07.04: Management of sevrals boards */
1483 /* ui_InterruptChannelValue[i_Count+5]=ui_DummyValue; */
1484 s_BoardInfos[dev->minor].
1485 ui_InterruptChannelValue[s_BoardInfos
1486 [dev->minor].i_Count + 5] =
1488 /* END JK 06.07.04: Management of sevrals boards */
1489 } /* if(i_ConvertCJCCalibration==1) */
1491 /* BEGIN JK 06.07.04: Management of sevrals boards */
1492 /* ui_InterruptChannelValue[i_Count+4]=0; */
1493 /* ui_InterruptChannelValue[i_Count+5]=0; */
1495 s_BoardInfos[dev->minor].
1496 ui_InterruptChannelValue[s_BoardInfos
1497 [dev->minor].i_Count + 4] = 0;
1498 s_BoardInfos[dev->minor].
1499 ui_InterruptChannelValue[s_BoardInfos
1500 [dev->minor].i_Count + 5] = 0;
1501 /* END JK 06.07.04: Management of sevrals boards */
1502 } /* elseif(i_ConvertCJCCalibration==1) */
1503 } /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)) */
1505 /* BEGIN JK 06.07.04: Management of sevrals boards */
1506 /* if(i_ScanType!=1) */
1507 if (s_BoardInfos[dev->minor].i_ScanType != 1) {
1509 s_BoardInfos[dev->minor].i_Count = 0;
1510 } /* if(i_ScanType!=1) */
1512 /* i_Count=i_Count +6; */
1513 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1514 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count +6; */
1515 s_BoardInfos[dev->minor].i_Count =
1516 s_BoardInfos[dev->minor].i_Count + 9;
1517 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1518 } /* else if(i_ScanType!=1) */
1520 /* if((i_ScanType==1) &&(i_InterruptFlag==1)) */
1521 if ((s_BoardInfos[dev->minor].i_ScanType == 1)
1522 && (s_BoardInfos[dev->minor].i_InterruptFlag == 1)) {
1523 /* i_Count=i_Count-6; */
1524 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1525 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count-6; */
1526 s_BoardInfos[dev->minor].i_Count =
1527 s_BoardInfos[dev->minor].i_Count - 9;
1528 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1530 /* if(i_ScanType==0) */
1531 if (s_BoardInfos[dev->minor].i_ScanType == 0) {
1533 data[0]= ui_InterruptChannelValue[0];
1534 data[1]= ui_InterruptChannelValue[1];
1535 data[2]= ui_InterruptChannelValue[2];
1536 data[3]= ui_InterruptChannelValue[3];
1537 data[4]= ui_InterruptChannelValue[4];
1538 data[5]= ui_InterruptChannelValue[5];
1541 printk("\n data[0]= s_BoardInfos [dev->minor].ui_InterruptChannelValue[0];");
1544 s_BoardInfos[dev->minor].
1545 ui_InterruptChannelValue[0];
1547 s_BoardInfos[dev->minor].
1548 ui_InterruptChannelValue[1];
1550 s_BoardInfos[dev->minor].
1551 ui_InterruptChannelValue[2];
1553 s_BoardInfos[dev->minor].
1554 ui_InterruptChannelValue[3];
1556 s_BoardInfos[dev->minor].
1557 ui_InterruptChannelValue[4];
1559 s_BoardInfos[dev->minor].
1560 ui_InterruptChannelValue[5];
1562 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1563 /* printk("\n 0 - i_APCI3200_GetChannelCalibrationValue data [6] = %lu, data [7] = %lu, data [8] = %lu", data [6], data [7], data [8]); */
1564 i_APCI3200_GetChannelCalibrationValue(dev,
1565 s_BoardInfos[dev->minor].ui_Channel_num,
1566 &data[6], &data[7], &data[8]);
1567 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1572 for (i = 0; i < insn->n; i++) {
1573 /* data[i]=ui_InterruptChannelValue[i]; */
1575 s_BoardInfos[dev->minor].
1576 ui_InterruptChannelValue[i];
1581 /* if(i_ScanType==1) */
1582 s_BoardInfos[dev->minor].i_Count = 0;
1583 s_BoardInfos[dev->minor].i_Sum = 0;
1584 if (s_BoardInfos[dev->minor].i_ScanType == 1) {
1585 /* i_Initialised=0; */
1586 /* i_InterruptFlag=0; */
1587 s_BoardInfos[dev->minor].i_Initialised = 0;
1588 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1589 /* END JK 06.07.04: Management of sevrals boards */
1593 printk("\nThe parameters passed are in error\n");
1594 i_APCI3200_Reset(dev);
1596 } /* switch(insn->unused[0]) */
1602 * Configures The Analog Input Subdevice
1604 * data[0] = 0 Normal AI
1607 * data[1] = Gain To Use
1608 * data[2] = 0 Bipolar
1610 * data[3] = Offset Range
1611 * data[4] = 0 DC Coupling
1613 * data[5] = 0 Single
1615 * data[6] = TimerReloadValue
1616 * data[7] = ConvertingTimeUnit
1617 * data[8] = 0 Analog voltage measurement
1618 * = 1 Resistance measurement
1619 * = 2 Temperature measurement
1620 * data[9] = 0 Interrupt Disable
1621 * = 1 INterrupt Enable
1622 * data[10] = Type of Thermocouple
1623 * data[11] = single channel Module Number
1624 * data[12] = 0 Single Read
1625 * = 1 Read more channel
1627 * = 3 Continuous Scan
1628 * data[13] = Number of channels to read
1629 * data[14] = 0 RTD not used
1630 * = 1 RTD 2 wire connection
1631 * = 2 RTD 3 wire connection
1632 * = 3 RTD 4 wire connection
1634 static int i_APCI3200_ConfigAnalogInput(struct comedi_device *dev,
1635 struct comedi_subdevice *s,
1636 struct comedi_insn *insn,
1639 struct addi_private *devpriv = dev->private;
1640 unsigned int ul_Config = 0, ul_Temp = 0;
1641 unsigned int ui_ChannelNo = 0;
1642 unsigned int ui_Dummy = 0;
1645 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1650 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1652 /* BEGIN JK 06.07.04: Management of sevrals boards */
1653 /* Initialize the structure */
1654 if (s_BoardInfos[dev->minor].b_StructInitialized != 1) {
1655 s_BoardInfos[dev->minor].i_CJCAvailable = 1;
1656 s_BoardInfos[dev->minor].i_CJCPolarity = 0;
1657 s_BoardInfos[dev->minor].i_CJCGain = 2; /* changed from 0 to 2 */
1658 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1659 s_BoardInfos[dev->minor].i_AutoCalibration = 0; /* : auto calibration */
1660 s_BoardInfos[dev->minor].i_ChannelCount = 0;
1661 s_BoardInfos[dev->minor].i_Sum = 0;
1662 s_BoardInfos[dev->minor].ui_Channel_num = 0;
1663 s_BoardInfos[dev->minor].i_Count = 0;
1664 s_BoardInfos[dev->minor].i_Initialised = 0;
1665 s_BoardInfos[dev->minor].b_StructInitialized = 1;
1667 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1668 s_BoardInfos[dev->minor].i_ConnectionType = 0;
1669 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1671 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1672 memset(s_BoardInfos[dev->minor].s_Module, 0,
1673 sizeof(s_BoardInfos[dev->minor].s_Module[MAX_MODULE]));
1675 v_GetAPCI3200EepromCalibrationValue(devpriv->i_IobaseAmcc,
1676 &s_BoardInfos[dev->minor]);
1679 for (i = 0; i < MAX_MODULE; i++) {
1680 printk("\n s_Module[%i].ul_CurrentSourceCJC = %lu", i,
1681 s_BoardInfos[dev->minor].s_Module[i].
1682 ul_CurrentSourceCJC);
1684 for (i2 = 0; i2 < 5; i2++) {
1685 printk("\n s_Module[%i].ul_CurrentSource [%i] = %lu", i, i2, s_BoardInfos[dev->minor].s_Module[i].ul_CurrentSource[i2]);
1688 for (i2 = 0; i2 < 8; i2++) {
1689 printk("\n s_Module[%i].ul_GainFactor [%i] = %lu", i, i2, s_BoardInfos[dev->minor].s_Module[i].ul_GainFactor[i2]);
1692 for (i2 = 0; i2 < 8; i2++) {
1693 printk("\n s_Module[%i].w_GainValue [%i] = %u",
1695 s_BoardInfos[dev->minor].s_Module[i].
1700 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1703 if (data[0] != 0 && data[0] != 1 && data[0] != 2) {
1704 printk("\nThe selection of acquisition type is in error\n");
1706 } /* if(data[0]!=0 && data[0]!=1 && data[0]!=2) */
1708 if (data[14] != 0 && data[14] != 1 && data[14] != 2
1710 printk("\n Error in selection of RTD connection type\n");
1712 } /* if(data[14]!=0 && data[14]!=1 && data[14]!=2 && data[14]!=4) */
1713 } /* if(data[0]==1 ) */
1714 if (data[1] < 0 || data[1] > 7) {
1715 printk("\nThe selection of gain is in error\n");
1717 } /* if(data[1]<0 || data[1]>7) */
1718 if (data[2] != 0 && data[2] != 1) {
1719 printk("\nThe selection of polarity is in error\n");
1721 } /* if(data[2]!=0 && data[2]!=1) */
1723 printk("\nThe selection of offset range is in error\n");
1725 } /* if(data[3]!=0) */
1726 if (data[4] != 0 && data[4] != 1) {
1727 printk("\nThe selection of coupling is in error\n");
1729 } /* if(data[4]!=0 && data[4]!=1) */
1730 if (data[5] != 0 && data[5] != 1) {
1731 printk("\nThe selection of single/differential mode is in error\n");
1733 } /* if(data[5]!=0 && data[5]!=1) */
1734 if (data[8] != 0 && data[8] != 1 && data[2] != 2) {
1735 printk("\nError in selection of functionality\n");
1736 } /* if(data[8]!=0 && data[8]!=1 && data[2]!=2) */
1737 if (data[12] == 0 || data[12] == 1) {
1738 if (data[6] != 20 && data[6] != 40 && data[6] != 80
1739 && data[6] != 160) {
1740 printk("\nThe selection of conversion time reload value is in error\n");
1742 } /* if (data[6]!=20 && data[6]!=40 && data[6]!=80 && data[6]!=160 ) */
1744 printk("\nThe selection of conversion time unit is in error\n");
1746 } /* if(data[7]!=2) */
1748 if (data[9] != 0 && data[9] != 1) {
1749 printk("\nThe selection of interrupt enable is in error\n");
1751 } /* if(data[9]!=0 && data[9]!=1) */
1752 if (data[11] < 0 || data[11] > 4) {
1753 printk("\nThe selection of module is in error\n");
1755 } /* if(data[11] <0 || data[11]>1) */
1756 if (data[12] < 0 || data[12] > 3) {
1757 printk("\nThe selection of singlechannel/scan selection is in error\n");
1759 } /* if(data[12] < 0 || data[12]> 3) */
1760 if (data[13] < 0 || data[13] > 16) {
1761 printk("\nThe selection of number of channels is in error\n");
1763 } /* if(data[13] <0 ||data[13] >15) */
1765 /* BEGIN JK 06.07.04: Management of sevrals boards */
1767 i_ChannelCount=data[13];
1768 i_ScanType=data[12];
1769 i_ADDIDATAPolarity = data[2];
1770 i_ADDIDATAGain=data[1];
1771 i_ADDIDATAConversionTime=data[6];
1772 i_ADDIDATAConversionTimeUnit=data[7];
1773 i_ADDIDATAType=data[0];
1776 /* Save acquisition configuration for the actual board */
1777 s_BoardInfos[dev->minor].i_ChannelCount = data[13];
1778 s_BoardInfos[dev->minor].i_ScanType = data[12];
1779 s_BoardInfos[dev->minor].i_ADDIDATAPolarity = data[2];
1780 s_BoardInfos[dev->minor].i_ADDIDATAGain = data[1];
1781 s_BoardInfos[dev->minor].i_ADDIDATAConversionTime = data[6];
1782 s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit = data[7];
1783 s_BoardInfos[dev->minor].i_ADDIDATAType = data[0];
1784 /* Begin JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1785 s_BoardInfos[dev->minor].i_ConnectionType = data[5];
1786 /* End JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1787 /* END JK 06.07.04: Management of sevrals boards */
1789 /* Begin JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1790 memset(s_BoardInfos[dev->minor].ui_ScanValueArray, 0, (7 + 12) * sizeof(unsigned int)); /* 7 is the maximal number of channels */
1791 /* End JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1793 /* BEGIN JK 02.07.04 : This while can't be do, it block the process when using severals boards */
1794 /* while(i_InterruptFlag==1) */
1795 while (s_BoardInfos[dev->minor].i_InterruptFlag == 1) {
1799 /* In the case where the driver is compiled for the MSX-Box */
1800 /* we used a printk to have a little delay because udelay */
1801 /* seems to be broken under the MSX-Box. */
1802 /* This solution hat to be studied. */
1806 /* END JK 02.07.04 : This while can't be do, it block the process when using severals boards */
1808 ui_ChannelNo = CR_CHAN(insn->chanspec); /* get the channel */
1809 /* BEGIN JK 06.07.04: Management of sevrals boards */
1810 /* i_ChannelNo=ui_ChannelNo; */
1811 /* ui_Channel_num =ui_ChannelNo; */
1813 s_BoardInfos[dev->minor].i_ChannelNo = ui_ChannelNo;
1814 s_BoardInfos[dev->minor].ui_Channel_num = ui_ChannelNo;
1816 /* END JK 06.07.04: Management of sevrals boards */
1819 if (ui_ChannelNo < 0 || ui_ChannelNo > 15) {
1820 printk("\nThe Selection of the channel is in error\n");
1822 } /* if(ui_ChannelNo<0 || ui_ChannelNo>15) */
1823 } /* if(data[5]==0) */
1825 if (data[14] == 2) {
1826 if (ui_ChannelNo < 0 || ui_ChannelNo > 3) {
1827 printk("\nThe Selection of the channel is in error\n");
1829 } /* if(ui_ChannelNo<0 || ui_ChannelNo>3) */
1830 } /* if(data[14]==2) */
1832 if (ui_ChannelNo < 0 || ui_ChannelNo > 7) {
1833 printk("\nThe Selection of the channel is in error\n");
1835 } /* if(ui_ChannelNo<0 || ui_ChannelNo>7) */
1836 } /* elseif(data[14]==2) */
1837 } /* elseif(data[5]==0) */
1838 if (data[12] == 0 || data[12] == 1) {
1841 if (ui_ChannelNo >= 0 && ui_ChannelNo <= 3) {
1842 /* BEGIN JK 06.07.04: Management of sevrals boards */
1844 s_BoardInfos[dev->minor].i_Offset = 0;
1845 /* END JK 06.07.04: Management of sevrals boards */
1846 } /* if(ui_ChannelNo >=0 && ui_ChannelNo <=3) */
1847 if (ui_ChannelNo >= 4 && ui_ChannelNo <= 7) {
1848 /* BEGIN JK 06.07.04: Management of sevrals boards */
1850 s_BoardInfos[dev->minor].i_Offset = 64;
1851 /* END JK 06.07.04: Management of sevrals boards */
1852 } /* if(ui_ChannelNo >=4 && ui_ChannelNo <=7) */
1853 if (ui_ChannelNo >= 8 && ui_ChannelNo <= 11) {
1854 /* BEGIN JK 06.07.04: Management of sevrals boards */
1856 s_BoardInfos[dev->minor].i_Offset = 128;
1857 /* END JK 06.07.04: Management of sevrals boards */
1858 } /* if(ui_ChannelNo >=8 && ui_ChannelNo <=11) */
1859 if (ui_ChannelNo >= 12 && ui_ChannelNo <= 15) {
1860 /* BEGIN JK 06.07.04: Management of sevrals boards */
1862 s_BoardInfos[dev->minor].i_Offset = 192;
1863 /* END JK 06.07.04: Management of sevrals boards */
1864 } /* if(ui_ChannelNo >=12 && ui_ChannelNo <=15) */
1867 if (data[14] == 2) {
1868 if (ui_ChannelNo == 0) {
1869 /* BEGIN JK 06.07.04: Management of sevrals boards */
1871 s_BoardInfos[dev->minor].i_Offset = 0;
1872 /* END JK 06.07.04: Management of sevrals boards */
1873 } /* if(ui_ChannelNo ==0 ) */
1874 if (ui_ChannelNo == 1) {
1875 /* BEGIN JK 06.07.04: Management of sevrals boards */
1877 s_BoardInfos[dev->minor].i_Offset = 64;
1878 /* END JK 06.07.04: Management of sevrals boards */
1879 } /* if(ui_ChannelNo ==1) */
1880 if (ui_ChannelNo == 2) {
1881 /* BEGIN JK 06.07.04: Management of sevrals boards */
1883 s_BoardInfos[dev->minor].i_Offset = 128;
1884 /* END JK 06.07.04: Management of sevrals boards */
1885 } /* if(ui_ChannelNo ==2 ) */
1886 if (ui_ChannelNo == 3) {
1887 /* BEGIN JK 06.07.04: Management of sevrals boards */
1889 s_BoardInfos[dev->minor].i_Offset = 192;
1890 /* END JK 06.07.04: Management of sevrals boards */
1891 } /* if(ui_ChannelNo ==3) */
1893 /* BEGIN JK 06.07.04: Management of sevrals boards */
1894 /* i_ChannelNo=0; */
1895 s_BoardInfos[dev->minor].i_ChannelNo = 0;
1896 /* END JK 06.07.04: Management of sevrals boards */
1899 } /* if(data[14]==2) */
1900 if (ui_ChannelNo >= 0 && ui_ChannelNo <= 1) {
1901 /* BEGIN JK 06.07.04: Management of sevrals boards */
1903 s_BoardInfos[dev->minor].i_Offset = 0;
1904 /* END JK 06.07.04: Management of sevrals boards */
1905 } /* if(ui_ChannelNo >=0 && ui_ChannelNo <=1) */
1906 if (ui_ChannelNo >= 2 && ui_ChannelNo <= 3) {
1907 /* BEGIN JK 06.07.04: Management of sevrals boards */
1908 /* i_ChannelNo=i_ChannelNo-2; */
1910 s_BoardInfos[dev->minor].i_ChannelNo =
1911 s_BoardInfos[dev->minor].i_ChannelNo -
1913 s_BoardInfos[dev->minor].i_Offset = 64;
1914 /* END JK 06.07.04: Management of sevrals boards */
1915 ui_ChannelNo = ui_ChannelNo - 2;
1916 } /* if(ui_ChannelNo >=2 && ui_ChannelNo <=3) */
1917 if (ui_ChannelNo >= 4 && ui_ChannelNo <= 5) {
1918 /* BEGIN JK 06.07.04: Management of sevrals boards */
1919 /* i_ChannelNo=i_ChannelNo-4; */
1921 s_BoardInfos[dev->minor].i_ChannelNo =
1922 s_BoardInfos[dev->minor].i_ChannelNo -
1924 s_BoardInfos[dev->minor].i_Offset = 128;
1925 /* END JK 06.07.04: Management of sevrals boards */
1926 ui_ChannelNo = ui_ChannelNo - 4;
1927 } /* if(ui_ChannelNo >=4 && ui_ChannelNo <=5) */
1928 if (ui_ChannelNo >= 6 && ui_ChannelNo <= 7) {
1929 /* BEGIN JK 06.07.04: Management of sevrals boards */
1930 /* i_ChannelNo=i_ChannelNo-6; */
1932 s_BoardInfos[dev->minor].i_ChannelNo =
1933 s_BoardInfos[dev->minor].i_ChannelNo -
1935 s_BoardInfos[dev->minor].i_Offset = 192;
1936 /* END JK 06.07.04: Management of sevrals boards */
1937 ui_ChannelNo = ui_ChannelNo - 6;
1938 } /* if(ui_ChannelNo >=6 && ui_ChannelNo <=7) */
1942 printk("\n This selection of polarity does not exist\n");
1944 } /* switch(data[2]) */
1945 } /* if(data[12]==0 || data[12]==1) */
1949 /* BEGIN JK 06.07.04: Management of sevrals boards */
1951 s_BoardInfos[dev->minor].i_Offset = 0;
1952 /* END JK 06.07.04: Management of sevrals boards */
1955 /* BEGIN JK 06.07.04: Management of sevrals boards */
1957 s_BoardInfos[dev->minor].i_Offset = 64;
1958 /* END JK 06.07.04: Management of sevrals boards */
1961 /* BEGIN JK 06.07.04: Management of sevrals boards */
1963 s_BoardInfos[dev->minor].i_Offset = 128;
1964 /* END JK 06.07.04: Management of sevrals boards */
1967 /* BEGIN JK 06.07.04: Management of sevrals boards */
1969 s_BoardInfos[dev->minor].i_Offset = 192;
1970 /* END JK 06.07.04: Management of sevrals boards */
1973 printk("\nError in module selection\n");
1975 } /* switch(data[11]) */
1976 } /* elseif(data[12]==0 || data[12]==1) */
1978 i_APCI3200_Reset(dev);
1981 /* if(i_ScanType!=1) */
1982 if (s_BoardInfos[dev->minor].i_ScanType != 1) {
1983 /* BEGIN JK 06.07.04: Management of sevrals boards */
1986 s_BoardInfos[dev->minor].i_Count = 0;
1987 s_BoardInfos[dev->minor].i_Sum = 0;
1988 /* END JK 06.07.04: Management of sevrals boards */
1989 } /* if(i_ScanType!=1) */
1992 data[1] | (data[2] << 6) | (data[5] << 7) | (data[3] << 8) |
1994 /* BEGIN JK 06.07.04: Management of sevrals boards */
1995 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1996 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1997 12) >> 19) & 1) != 1) ;
1998 /* END JK 06.07.04: Management of sevrals boards */
1999 /*********************************/
2000 /* Write the channel to configure */
2001 /*********************************/
2002 /* BEGIN JK 06.07.04: Management of sevrals boards */
2003 /* outl(0 | ui_ChannelNo , devpriv->iobase+i_Offset + 0x4); */
2004 outl(0 | ui_ChannelNo,
2005 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x4);
2006 /* END JK 06.07.04: Management of sevrals boards */
2008 /* BEGIN JK 06.07.04: Management of sevrals boards */
2009 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2010 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2011 12) >> 19) & 1) != 1) ;
2012 /* END JK 06.07.04: Management of sevrals boards */
2013 /**************************/
2014 /* Reset the configuration */
2015 /**************************/
2016 /* BEGIN JK 06.07.04: Management of sevrals boards */
2017 /* outl(0 , devpriv->iobase+i_Offset + 0x0); */
2018 outl(0, devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x0);
2019 /* END JK 06.07.04: Management of sevrals boards */
2021 /* BEGIN JK 06.07.04: Management of sevrals boards */
2022 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2023 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2024 12) >> 19) & 1) != 1) ;
2025 /* END JK 06.07.04: Management of sevrals boards */
2027 /***************************/
2028 /* Write the configuration */
2029 /***************************/
2030 /* BEGIN JK 06.07.04: Management of sevrals boards */
2031 /* outl(ul_Config , devpriv->iobase+i_Offset + 0x0); */
2033 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x0);
2034 /* END JK 06.07.04: Management of sevrals boards */
2036 /***************************/
2037 /*Reset the calibration bit */
2038 /***************************/
2039 /* BEGIN JK 06.07.04: Management of sevrals boards */
2040 /* ul_Temp = inl(devpriv->iobase+i_Offset + 12); */
2041 ul_Temp = inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2042 /* END JK 06.07.04: Management of sevrals boards */
2044 /* BEGIN JK 06.07.04: Management of sevrals boards */
2045 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2046 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2047 12) >> 19) & 1) != 1) ;
2048 /* END JK 06.07.04: Management of sevrals boards */
2050 /* BEGIN JK 06.07.04: Management of sevrals boards */
2051 /* outl((ul_Temp & 0xFFF9FFFF) , devpriv->iobase+.i_Offset + 12); */
2052 outl((ul_Temp & 0xFFF9FFFF),
2053 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2054 /* END JK 06.07.04: Management of sevrals boards */
2057 devpriv->tsk_Current = current;
2058 /* BEGIN JK 06.07.04: Management of sevrals boards */
2059 /* i_InterruptFlag=1; */
2060 s_BoardInfos[dev->minor].i_InterruptFlag = 1;
2061 /* END JK 06.07.04: Management of sevrals boards */
2062 } /* if(data[9]==1) */
2064 /* BEGIN JK 06.07.04: Management of sevrals boards */
2065 /* i_InterruptFlag=0; */
2066 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2067 /* END JK 06.07.04: Management of sevrals boards */
2068 } /* else if(data[9]==1) */
2070 /* BEGIN JK 06.07.04: Management of sevrals boards */
2071 /* i_Initialised=1; */
2072 s_BoardInfos[dev->minor].i_Initialised = 1;
2073 /* END JK 06.07.04: Management of sevrals boards */
2075 /* BEGIN JK 06.07.04: Management of sevrals boards */
2076 /* if(i_ScanType==1) */
2077 if (s_BoardInfos[dev->minor].i_ScanType == 1)
2078 /* END JK 06.07.04: Management of sevrals boards */
2080 /* BEGIN JK 06.07.04: Management of sevrals boards */
2081 /* i_Sum=i_Sum+1; */
2082 s_BoardInfos[dev->minor].i_Sum =
2083 s_BoardInfos[dev->minor].i_Sum + 1;
2084 /* END JK 06.07.04: Management of sevrals boards */
2086 insn->unused[0] = 0;
2087 i_APCI3200_ReadAnalogInput(dev, s, insn, &ui_Dummy);
2094 * Tests the Selected Anlog Input Channel
2096 * data[0] = 0 TestAnalogInputShortCircuit
2097 * = 1 TestAnalogInputConnection
2099 * data[0] : Digital value obtained
2100 * data[1] : calibration offset
2101 * data[2] : calibration gain
2103 static int i_APCI3200_InsnBits_AnalogInput_Test(struct comedi_device *dev,
2104 struct comedi_subdevice *s,
2105 struct comedi_insn *insn,
2108 struct addi_private *devpriv = dev->private;
2109 unsigned int ui_Configuration = 0;
2110 int i_Temp; /* ,i_TimeUnit; */
2112 /* if(i_Initialised==0) */
2114 if (s_BoardInfos[dev->minor].i_Initialised == 0) {
2115 i_APCI3200_Reset(dev);
2117 } /* if(i_Initialised==0); */
2118 if (data[0] != 0 && data[0] != 1) {
2119 printk("\nError in selection of functionality\n");
2120 i_APCI3200_Reset(dev);
2122 } /* if(data[0]!=0 && data[0]!=1) */
2124 if (data[0] == 1) /* Perform Short Circuit TEST */
2126 /**************************/
2127 /*Set the short-cicuit bit */
2128 /**************************/
2129 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2130 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2131 i_Offset + 12) >> 19) & 1) !=
2133 /* outl((0x00001000 |i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2134 outl((0x00001000 | s_BoardInfos[dev->minor].i_ChannelNo),
2135 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2137 /*************************/
2138 /*Set the time unit to ns */
2139 /*************************/
2140 /* i_TimeUnit= i_ADDIDATAConversionTimeUnit;
2141 i_ADDIDATAConversionTimeUnit= 1; */
2142 /* i_Temp= i_InterruptFlag ; */
2143 i_Temp = s_BoardInfos[dev->minor].i_InterruptFlag;
2144 /* i_InterruptFlag = ADDIDATA_DISABLE; */
2145 s_BoardInfos[dev->minor].i_InterruptFlag = ADDIDATA_DISABLE;
2146 i_APCI3200_Read1AnalogInputChannel(dev, s, insn, data);
2147 /* if(i_AutoCalibration == FALSE) */
2148 if (s_BoardInfos[dev->minor].i_AutoCalibration == FALSE) {
2149 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2150 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2152 12) >> 19) & 1) != 1) ;
2154 /* outl((0x00001000 |i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2155 outl((0x00001000 | s_BoardInfos[dev->minor].
2158 s_BoardInfos[dev->minor].i_Offset + 4);
2160 i_APCI3200_ReadCalibrationOffsetValue(dev, data);
2162 i_APCI3200_ReadCalibrationGainValue(dev, data);
2165 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2166 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2167 i_Offset + 12) >> 19) & 1) !=
2169 /* outl((0x00000800|i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2170 outl((0x00000800 | s_BoardInfos[dev->minor].i_ChannelNo),
2171 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2173 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 0); */
2175 inl(devpriv->iobase +
2176 s_BoardInfos[dev->minor].i_Offset + 0);
2177 /*************************/
2178 /*Set the time unit to ns */
2179 /*************************/
2180 /* i_TimeUnit= i_ADDIDATAConversionTimeUnit;
2181 i_ADDIDATAConversionTimeUnit= 1; */
2182 /* i_Temp= i_InterruptFlag ; */
2183 i_Temp = s_BoardInfos[dev->minor].i_InterruptFlag;
2184 /* i_InterruptFlag = ADDIDATA_DISABLE; */
2185 s_BoardInfos[dev->minor].i_InterruptFlag = ADDIDATA_DISABLE;
2186 i_APCI3200_Read1AnalogInputChannel(dev, s, insn, data);
2187 /* if(i_AutoCalibration == FALSE) */
2188 if (s_BoardInfos[dev->minor].i_AutoCalibration == FALSE) {
2189 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2190 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2192 12) >> 19) & 1) != 1) ;
2193 /* outl((0x00000800|i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2194 outl((0x00000800 | s_BoardInfos[dev->minor].
2197 s_BoardInfos[dev->minor].i_Offset + 4);
2199 i_APCI3200_ReadCalibrationOffsetValue(dev, data);
2201 i_APCI3200_ReadCalibrationGainValue(dev, data);
2204 /* i_InterruptFlag=i_Temp ; */
2205 s_BoardInfos[dev->minor].i_InterruptFlag = i_Temp;
2206 /* printk("\ni_InterruptFlag=%d\n",i_InterruptFlag); */
2210 static int i_APCI3200_InsnWriteReleaseAnalogInput(struct comedi_device *dev,
2211 struct comedi_subdevice *s,
2212 struct comedi_insn *insn,
2215 i_APCI3200_Reset(dev);
2219 static int i_APCI3200_CommandTestAnalogInput(struct comedi_device *dev,
2220 struct comedi_subdevice *s,
2221 struct comedi_cmd *cmd)
2225 unsigned int ui_ConvertTime = 0;
2226 unsigned int ui_ConvertTimeBase = 0;
2227 unsigned int ui_DelayTime = 0;
2228 unsigned int ui_DelayTimeBase = 0;
2229 int i_Triggermode = 0;
2230 int i_TriggerEdge = 0;
2231 int i_NbrOfChannel = 0;
2233 double d_ConversionTimeForAllChannels = 0.0;
2234 double d_SCANTimeNewUnit = 0.0;
2236 /* Step 1 : check if triggers are trivially valid */
2238 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
2239 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
2240 TRIG_TIMER | TRIG_FOLLOW);
2241 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
2242 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
2243 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
2245 if (s_BoardInfos[dev->minor].i_InterruptFlag == 0)
2249 i_APCI3200_Reset(dev);
2253 /* Step 2a : make sure trigger sources are unique */
2255 err |= cfc_check_trigger_is_unique(&cmd->start_src);
2256 err |= cfc_check_trigger_is_unique(&cmd->scan_begin_src);
2257 err |= cfc_check_trigger_is_unique(&cmd->stop_src);
2259 /* Step 2b : and mutually compatible */
2261 if (cmd->start_src == TRIG_EXT) {
2262 i_TriggerEdge = cmd->start_arg & 0xFFFF;
2263 i_Triggermode = cmd->start_arg >> 16;
2264 if (i_TriggerEdge < 1 || i_TriggerEdge > 3) {
2266 printk("\nThe trigger edge selection is in error\n");
2268 if (i_Triggermode != 2) {
2270 printk("\nThe trigger mode selection is in error\n");
2275 i_APCI3200_Reset(dev);
2278 /* i_FirstChannel=cmd->chanlist[0]; */
2279 s_BoardInfos[dev->minor].i_FirstChannel = cmd->chanlist[0];
2280 /* i_LastChannel=cmd->chanlist[1]; */
2281 s_BoardInfos[dev->minor].i_LastChannel = cmd->chanlist[1];
2283 if (cmd->convert_src == TRIG_TIMER) {
2284 ui_ConvertTime = cmd->convert_arg & 0xFFFF;
2285 ui_ConvertTimeBase = cmd->convert_arg >> 16;
2286 if (ui_ConvertTime != 20 && ui_ConvertTime != 40
2287 && ui_ConvertTime != 80 && ui_ConvertTime != 160)
2289 printk("\nThe selection of conversion time reload value is in error\n");
2291 } /* if (ui_ConvertTime!=20 && ui_ConvertTime!=40 && ui_ConvertTime!=80 && ui_ConvertTime!=160 ) */
2292 if (ui_ConvertTimeBase != 2) {
2293 printk("\nThe selection of conversion time unit is in error\n");
2295 } /* if(ui_ConvertTimeBase!=2) */
2298 ui_ConvertTimeBase = 0;
2300 if (cmd->scan_begin_src == TRIG_FOLLOW) {
2302 ui_DelayTimeBase = 0;
2303 } /* if(cmd->scan_begin_src==TRIG_FOLLOW) */
2305 ui_DelayTime = cmd->scan_begin_arg & 0xFFFF;
2306 ui_DelayTimeBase = cmd->scan_begin_arg >> 16;
2307 if (ui_DelayTimeBase != 2 && ui_DelayTimeBase != 3) {
2309 printk("\nThe Delay time base selection is in error\n");
2311 if (ui_DelayTime < 1 || ui_DelayTime > 1023) {
2313 printk("\nThe Delay time value is in error\n");
2316 i_APCI3200_Reset(dev);
2320 d_SCANTimeNewUnit = (double)ui_DelayTime;
2321 /* i_NbrOfChannel= i_LastChannel-i_FirstChannel + 4; */
2323 s_BoardInfos[dev->minor].i_LastChannel -
2324 s_BoardInfos[dev->minor].i_FirstChannel + 4;
2325 /**********************************************************/
2326 /*calculate the total conversion time for all the channels */
2327 /**********************************************************/
2328 d_ConversionTimeForAllChannels =
2329 (double)((double)ui_ConvertTime /
2330 (double)i_NbrOfChannel);
2332 /*******************************/
2333 /*Convert the frequence in time */
2334 /*******************************/
2335 d_ConversionTimeForAllChannels =
2336 (double)1.0 / d_ConversionTimeForAllChannels;
2337 ui_ConvertTimeBase = 3;
2338 /***********************************/
2339 /*Test if the time unit is the same */
2340 /***********************************/
2342 if (ui_DelayTimeBase <= ui_ConvertTimeBase) {
2345 i_Cpt < (ui_ConvertTimeBase - ui_DelayTimeBase);
2348 d_ConversionTimeForAllChannels =
2349 d_ConversionTimeForAllChannels * 1000;
2350 d_ConversionTimeForAllChannels =
2351 d_ConversionTimeForAllChannels + 1;
2355 i_Cpt < (ui_DelayTimeBase - ui_ConvertTimeBase);
2357 d_SCANTimeNewUnit = d_SCANTimeNewUnit * 1000;
2362 if (d_ConversionTimeForAllChannels >= d_SCANTimeNewUnit) {
2364 printk("\nSCAN Delay value cannot be used\n");
2365 /*********************************/
2366 /*SCAN Delay value cannot be used */
2367 /*********************************/
2371 } /* else if(cmd->scan_begin_src==TRIG_FOLLOW) */
2374 i_APCI3200_Reset(dev);
2381 static int i_APCI3200_StopCyclicAcquisition(struct comedi_device *dev,
2382 struct comedi_subdevice *s)
2384 struct addi_private *devpriv = dev->private;
2385 unsigned int ui_Configuration = 0;
2387 /* i_InterruptFlag=0; */
2388 /* i_Initialised=0; */
2391 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2392 s_BoardInfos[dev->minor].i_Initialised = 0;
2393 s_BoardInfos[dev->minor].i_Count = 0;
2394 s_BoardInfos[dev->minor].i_Sum = 0;
2396 /*******************/
2397 /*Read the register */
2398 /*******************/
2399 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 8); */
2401 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2402 /*****************************/
2403 /*Reset the START and IRQ bit */
2404 /*****************************/
2405 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2406 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2407 12) >> 19) & 1) != 1) ;
2408 /* outl((ui_Configuration & 0xFFE7FFFF),devpriv->iobase+i_Offset + 8); */
2409 outl((ui_Configuration & 0xFFE7FFFF),
2410 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2415 * Does asynchronous acquisition
2416 * Determines the mode 1 or 2.
2418 static int i_APCI3200_CommandAnalogInput(struct comedi_device *dev,
2419 struct comedi_subdevice *s)
2421 struct addi_private *devpriv = dev->private;
2422 struct comedi_cmd *cmd = &s->async->cmd;
2423 unsigned int ui_Configuration = 0;
2424 /* INT i_CurrentSource = 0; */
2425 unsigned int ui_Trigger = 0;
2426 unsigned int ui_TriggerEdge = 0;
2427 unsigned int ui_Triggermode = 0;
2428 unsigned int ui_ScanMode = 0;
2429 unsigned int ui_ConvertTime = 0;
2430 unsigned int ui_ConvertTimeBase = 0;
2431 unsigned int ui_DelayTime = 0;
2432 unsigned int ui_DelayTimeBase = 0;
2433 unsigned int ui_DelayMode = 0;
2435 /* i_FirstChannel=cmd->chanlist[0]; */
2436 /* i_LastChannel=cmd->chanlist[1]; */
2437 s_BoardInfos[dev->minor].i_FirstChannel = cmd->chanlist[0];
2438 s_BoardInfos[dev->minor].i_LastChannel = cmd->chanlist[1];
2439 if (cmd->start_src == TRIG_EXT) {
2441 ui_TriggerEdge = cmd->start_arg & 0xFFFF;
2442 ui_Triggermode = cmd->start_arg >> 16;
2443 } /* if(cmd->start_src==TRIG_EXT) */
2446 } /* elseif(cmd->start_src==TRIG_EXT) */
2448 if (cmd->stop_src == TRIG_COUNT) {
2450 } /* if (cmd->stop_src==TRIG_COUNT) */
2453 } /* else if (cmd->stop_src==TRIG_COUNT) */
2455 if (cmd->scan_begin_src == TRIG_FOLLOW) {
2457 ui_DelayTimeBase = 0;
2459 } /* if(cmd->scan_begin_src==TRIG_FOLLOW) */
2461 ui_DelayTime = cmd->scan_begin_arg & 0xFFFF;
2462 ui_DelayTimeBase = cmd->scan_begin_arg >> 16;
2464 } /* else if(cmd->scan_begin_src==TRIG_FOLLOW) */
2465 /* printk("\nui_DelayTime=%u\n",ui_DelayTime); */
2466 /* printk("\nui_DelayTimeBase=%u\n",ui_DelayTimeBase); */
2467 if (cmd->convert_src == TRIG_TIMER) {
2468 ui_ConvertTime = cmd->convert_arg & 0xFFFF;
2469 ui_ConvertTimeBase = cmd->convert_arg >> 16;
2472 ui_ConvertTimeBase = 0;
2475 /* if(i_ADDIDATAType ==1 || ((i_ADDIDATAType==2))) */
2477 /**************************************************/
2478 /*Read the old configuration of the current source */
2479 /**************************************************/
2480 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 12); */
2482 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2483 /***********************************************/
2484 /*Write the configuration of the current source */
2485 /***********************************************/
2486 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2487 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2488 12) >> 19) & 1) != 1) ;
2489 /* outl((ui_Configuration & 0xFFC00000 ), devpriv->iobase+i_Offset +12); */
2490 outl((ui_Configuration & 0xFFC00000),
2491 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2493 ui_Configuration = 0;
2494 /* printk("\nfirstchannel=%u\n",i_FirstChannel); */
2495 /* printk("\nlastchannel=%u\n",i_LastChannel); */
2496 /* printk("\nui_Trigger=%u\n",ui_Trigger); */
2497 /* printk("\nui_TriggerEdge=%u\n",ui_TriggerEdge); */
2498 /* printk("\nui_Triggermode=%u\n",ui_Triggermode); */
2499 /* printk("\nui_DelayMode=%u\n",ui_DelayMode); */
2500 /* printk("\nui_ScanMode=%u\n",ui_ScanMode); */
2502 /* ui_Configuration = i_FirstChannel |(i_LastChannel << 8)| 0x00100000 | */
2504 s_BoardInfos[dev->minor].i_FirstChannel | (s_BoardInfos[dev->
2506 i_LastChannel << 8) | 0x00100000 | (ui_Trigger << 24) |
2507 (ui_TriggerEdge << 25) | (ui_Triggermode << 27) | (ui_DelayMode
2508 << 18) | (ui_ScanMode << 16);
2510 /*************************/
2511 /*Write the Configuration */
2512 /*************************/
2513 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2514 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2515 12) >> 19) & 1) != 1) ;
2516 /* outl( ui_Configuration, devpriv->iobase+i_Offset + 0x8); */
2517 outl(ui_Configuration,
2518 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x8);
2519 /***********************/
2520 /*Write the Delay Value */
2521 /***********************/
2522 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2523 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2524 12) >> 19) & 1) != 1) ;
2525 /* outl(ui_DelayTime,devpriv->iobase+i_Offset + 40); */
2527 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 40);
2528 /***************************/
2529 /*Write the Delay time base */
2530 /***************************/
2531 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2532 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2533 12) >> 19) & 1) != 1) ;
2534 /* outl(ui_DelayTimeBase,devpriv->iobase+i_Offset + 44); */
2535 outl(ui_DelayTimeBase,
2536 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 44);
2537 /*********************************/
2538 /*Write the conversion time value */
2539 /*********************************/
2540 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2541 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2542 12) >> 19) & 1) != 1) ;
2543 /* outl(ui_ConvertTime,devpriv->iobase+i_Offset + 32); */
2544 outl(ui_ConvertTime,
2545 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
2547 /********************************/
2548 /*Write the conversion time base */
2549 /********************************/
2550 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2551 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2552 12) >> 19) & 1) != 1) ;
2553 /* outl(ui_ConvertTimeBase,devpriv->iobase+i_Offset + 36); */
2554 outl(ui_ConvertTimeBase,
2555 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
2556 /*******************/
2557 /*Read the register */
2558 /*******************/
2559 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 4); */
2561 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
2562 /******************/
2563 /*Set the SCAN bit */
2564 /******************/
2565 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2566 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2567 12) >> 19) & 1) != 1) ;
2569 /* outl(((ui_Configuration & 0x1E0FF) | 0x00002000),devpriv->iobase+i_Offset + 4); */
2570 outl(((ui_Configuration & 0x1E0FF) | 0x00002000),
2571 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
2572 /*******************/
2573 /*Read the register */
2574 /*******************/
2575 ui_Configuration = 0;
2576 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 8); */
2578 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2580 /*******************/
2581 /*Set the START bit */
2582 /*******************/
2583 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2584 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2585 12) >> 19) & 1) != 1) ;
2586 /* outl((ui_Configuration | 0x00080000),devpriv->iobase+i_Offset + 8); */
2587 outl((ui_Configuration | 0x00080000),
2588 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2593 * This function copies the acquired data(from FIFO) to Comedi buffer.
2595 static int i_APCI3200_InterruptHandleEos(struct comedi_device *dev)
2597 struct addi_private *devpriv = dev->private;
2598 unsigned int ui_StatusRegister = 0;
2599 struct comedi_subdevice *s = &dev->subdevices[0];
2601 /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2602 /* comedi_async *async = s->async; */
2604 /* data=async->data+async->buf_int_ptr;//new samples added from here onwards */
2606 /* END JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2608 /************************************/
2609 /*Read the interrupt status register */
2610 /************************************/
2611 /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2613 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 16);
2615 /*************************/
2616 /*Test if interrupt occur */
2617 /*************************/
2619 if ((ui_StatusRegister & 0x2) == 0x2) {
2620 /*************************/
2621 /*Read the channel number */
2622 /*************************/
2623 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2624 /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2625 /* This value is not used */
2626 /* ui_ChannelNumber = inl(devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 24); */
2627 s->async->events = 0;
2628 /* END JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2630 /*************************************/
2631 /*Read the digital Analog Input value */
2632 /*************************************/
2634 /* data[i_Count] = inl(devpriv->iobase+i_Offset + 28); */
2635 /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2636 /* data[s_BoardInfos [dev->minor].i_Count] = inl(devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 28); */
2637 s_BoardInfos[dev->minor].ui_ScanValueArray[s_BoardInfos[dev->
2639 inl(devpriv->iobase +
2640 s_BoardInfos[dev->minor].i_Offset + 28);
2641 /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2643 /* if((i_Count == (i_LastChannel-i_FirstChannel+3))) */
2644 if ((s_BoardInfos[dev->minor].i_Count ==
2645 (s_BoardInfos[dev->minor].i_LastChannel -
2646 s_BoardInfos[dev->minor].
2647 i_FirstChannel + 3))) {
2649 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2650 s_BoardInfos[dev->minor].i_Count++;
2652 for (i = s_BoardInfos[dev->minor].i_FirstChannel;
2653 i <= s_BoardInfos[dev->minor].i_LastChannel;
2655 i_APCI3200_GetChannelCalibrationValue(dev, i,
2656 &s_BoardInfos[dev->minor].
2657 ui_ScanValueArray[s_BoardInfos[dev->
2658 minor].i_Count + ((i -
2663 &s_BoardInfos[dev->minor].
2664 ui_ScanValueArray[s_BoardInfos[dev->
2665 minor].i_Count + ((i -
2670 &s_BoardInfos[dev->minor].
2671 ui_ScanValueArray[s_BoardInfos[dev->
2672 minor].i_Count + ((i -
2679 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2683 s_BoardInfos[dev->minor].i_Count = -1;
2685 /* async->buf_int_count+=(i_LastChannel-i_FirstChannel+4)*sizeof(unsigned int); */
2686 /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2687 /* async->buf_int_count+=(s_BoardInfos [dev->minor].i_LastChannel-s_BoardInfos [dev->minor].i_FirstChannel+4)*sizeof(unsigned int); */
2688 /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2689 /* async->buf_int_ptr+=(i_LastChannel-i_FirstChannel+4)*sizeof(unsigned int); */
2690 /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2691 /* async->buf_int_ptr+=(s_BoardInfos [dev->minor].i_LastChannel-s_BoardInfos [dev->minor].i_FirstChannel+4)*sizeof(unsigned int); */
2692 /* comedi_eos(dev,s); */
2694 /* Set the event type (Comedi Buffer End Of Scan) */
2695 s->async->events |= COMEDI_CB_EOS;
2697 /* Test if enougth memory is available and allocate it for 7 values */
2698 /* n = comedi_buf_write_alloc(s->async, 7*sizeof(unsigned int)); */
2699 n = comedi_buf_write_alloc(s->async,
2700 (7 + 12) * sizeof(unsigned int));
2702 /* If not enough memory available, event is set to Comedi Buffer Error */
2703 if (n > ((7 + 12) * sizeof(unsigned int))) {
2704 printk("\ncomedi_buf_write_alloc n = %i", n);
2705 s->async->events |= COMEDI_CB_ERROR;
2707 /* Write all 7 scan values in the comedi buffer */
2708 comedi_buf_memcpy_to(s->async, 0,
2709 (unsigned int *) s_BoardInfos[dev->minor].
2710 ui_ScanValueArray, (7 + 12) * sizeof(unsigned int));
2712 /* Update comedi buffer pinters indexes */
2713 comedi_buf_write_free(s->async,
2714 (7 + 12) * sizeof(unsigned int));
2717 comedi_event(dev, s);
2718 /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2720 /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2722 /* if (s->async->buf_int_ptr>=s->async->data_len) // for buffer rool over */
2724 /* /* buffer rollover */ */
2725 /* s->async->buf_int_ptr=0; */
2726 /* comedi_eobuf(dev,s); */
2728 /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2731 s_BoardInfos[dev->minor].i_Count++;
2733 /* i_InterruptFlag=0; */
2734 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2738 static void v_APCI3200_Interrupt(int irq, void *d)
2740 struct comedi_device *dev = d;
2741 struct addi_private *devpriv = dev->private;
2742 unsigned int ui_StatusRegister = 0;
2743 unsigned int ui_ChannelNumber = 0;
2744 int i_CalibrationFlag = 0;
2746 unsigned int ui_DummyValue = 0;
2747 unsigned int ui_DigitalTemperature = 0;
2748 unsigned int ui_DigitalInput = 0;
2749 int i_ConvertCJCCalibration;
2751 int i_ReturnValue = 0;
2754 /* printk ("\n i_ScanType = %i i_ADDIDATAType = %i", s_BoardInfos [dev->minor].i_ScanType, s_BoardInfos [dev->minor].i_ADDIDATAType); */
2756 /* switch(i_ScanType) */
2757 switch (s_BoardInfos[dev->minor].i_ScanType) {
2760 /* switch(i_ADDIDATAType) */
2761 switch (s_BoardInfos[dev->minor].i_ADDIDATAType) {
2765 /************************************/
2766 /*Read the interrupt status register */
2767 /************************************/
2768 /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2770 inl(devpriv->iobase +
2771 s_BoardInfos[dev->minor].i_Offset + 16);
2772 if ((ui_StatusRegister & 0x2) == 0x2) {
2773 /* i_CalibrationFlag = ((inl(devpriv->iobase+i_Offset + 12) & 0x00060000) >> 17); */
2775 ((inl(devpriv->iobase +
2779 12) & 0x00060000) >>
2781 /*************************/
2782 /*Read the channel number */
2783 /*************************/
2784 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2786 /*************************************/
2787 /*Read the digital analog input value */
2788 /*************************************/
2789 /* ui_DigitalInput = inl(devpriv->iobase+i_Offset + 28); */
2791 inl(devpriv->iobase +
2792 s_BoardInfos[dev->minor].i_Offset + 28);
2794 /***********************************************/
2795 /* Test if the value read is the channel value */
2796 /***********************************************/
2797 if (i_CalibrationFlag == 0) {
2798 /* ui_InterruptChannelValue[i_Count + 0] = ui_DigitalInput; */
2799 s_BoardInfos[dev->minor].
2800 ui_InterruptChannelValue
2801 [s_BoardInfos[dev->minor].
2802 i_Count + 0] = ui_DigitalInput;
2804 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2806 printk("\n 1 - i_APCI3200_GetChannelCalibrationValue (dev, s_BoardInfos %i", ui_ChannelNumber);
2807 i_APCI3200_GetChannelCalibrationValue (dev, s_BoardInfos [dev->minor].ui_Channel_num,
2808 &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 6],
2809 &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 7],
2810 &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 8]);
2812 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2814 /******************************************************/
2815 /*Start the conversion of the calibration offset value */
2816 /******************************************************/
2817 i_APCI3200_ReadCalibrationOffsetValue
2818 (dev, &ui_DummyValue);
2819 } /* if (i_CalibrationFlag == 0) */
2820 /**********************************************************/
2821 /* Test if the value read is the calibration offset value */
2822 /**********************************************************/
2824 if (i_CalibrationFlag == 1) {
2826 /******************/
2827 /* Save the value */
2828 /******************/
2830 /* ui_InterruptChannelValue[i_Count + 1] = ui_DigitalInput; */
2831 s_BoardInfos[dev->minor].
2832 ui_InterruptChannelValue
2833 [s_BoardInfos[dev->minor].
2834 i_Count + 1] = ui_DigitalInput;
2836 /******************************************************/
2837 /* Start the conversion of the calibration gain value */
2838 /******************************************************/
2839 i_APCI3200_ReadCalibrationGainValue(dev,
2841 } /* if (i_CalibrationFlag == 1) */
2842 /******************************************************/
2843 /*Test if the value read is the calibration gain value */
2844 /******************************************************/
2846 if (i_CalibrationFlag == 2) {
2851 /* ui_InterruptChannelValue[i_Count + 2] = ui_DigitalInput; */
2852 s_BoardInfos[dev->minor].
2853 ui_InterruptChannelValue
2854 [s_BoardInfos[dev->minor].
2855 i_Count + 2] = ui_DigitalInput;
2856 /* if(i_ScanType==1) */
2857 if (s_BoardInfos[dev->minor].
2860 /* i_InterruptFlag=0; */
2861 s_BoardInfos[dev->minor].
2862 i_InterruptFlag = 0;
2863 /* i_Count=i_Count + 6; */
2864 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2865 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count + 6; */
2866 s_BoardInfos[dev->minor].
2870 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2871 } /* if(i_ScanType==1) */
2874 s_BoardInfos[dev->minor].
2876 } /* elseif(i_ScanType==1) */
2877 /* if(i_ScanType!=1) */
2878 if (s_BoardInfos[dev->minor].
2880 i_ReturnValue = send_sig(SIGIO, devpriv->tsk_Current, 0); /* send signal to the sample */
2881 } /* if(i_ScanType!=1) */
2883 /* if(i_ChannelCount==i_Sum) */
2884 if (s_BoardInfos[dev->minor].
2888 send_sig(SIGIO, devpriv->tsk_Current, 0); /* send signal to the sample */
2890 } /* if(i_ScanType!=1) */
2891 } /* if (i_CalibrationFlag == 2) */
2892 } /* if ((ui_StatusRegister & 0x2) == 0x2) */
2897 /************************************/
2898 /*Read the interrupt status register */
2899 /************************************/
2901 /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2903 inl(devpriv->iobase +
2904 s_BoardInfos[dev->minor].i_Offset + 16);
2905 /*************************/
2906 /*Test if interrupt occur */
2907 /*************************/
2909 if ((ui_StatusRegister & 0x2) == 0x2) {
2911 /* i_CJCFlag = ((inl(devpriv->iobase+i_Offset + 4) & 0x00000400) >> 10); */
2913 ((inl(devpriv->iobase +
2917 4) & 0x00000400) >> 10);
2919 /* i_CalibrationFlag = ((inl(devpriv->iobase+i_Offset + 12) & 0x00060000) >> 17); */
2921 ((inl(devpriv->iobase +
2925 12) & 0x00060000) >>
2928 /*************************/
2929 /*Read the channel number */
2930 /*************************/
2932 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2934 inl(devpriv->iobase +
2935 s_BoardInfos[dev->minor].i_Offset + 24);
2936 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2937 s_BoardInfos[dev->minor].ui_Channel_num =
2939 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2941 /************************************/
2942 /*Read the digital temperature value */
2943 /************************************/
2944 /* ui_DigitalTemperature = inl(devpriv->iobase+i_Offset + 28); */
2945 ui_DigitalTemperature =
2946 inl(devpriv->iobase +
2947 s_BoardInfos[dev->minor].i_Offset + 28);
2949 /*********************************************/
2950 /*Test if the value read is the channel value */
2951 /*********************************************/
2953 if ((i_CalibrationFlag == 0)
2954 && (i_CJCFlag == 0)) {
2955 /* ui_InterruptChannelValue[i_Count + 0]=ui_DigitalTemperature; */
2956 s_BoardInfos[dev->minor].
2957 ui_InterruptChannelValue
2958 [s_BoardInfos[dev->minor].
2960 ui_DigitalTemperature;
2962 /*********************************/
2963 /*Start the conversion of the CJC */
2964 /*********************************/
2965 i_APCI3200_ReadCJCValue(dev,
2968 } /* if ((i_CalibrationFlag == 0) && (i_CJCFlag == 0)) */
2970 /*****************************************/
2971 /*Test if the value read is the CJC value */
2972 /*****************************************/
2974 if ((i_CJCFlag == 1)
2975 && (i_CalibrationFlag == 0)) {
2976 /* ui_InterruptChannelValue[i_Count + 3]=ui_DigitalTemperature; */
2977 s_BoardInfos[dev->minor].
2978 ui_InterruptChannelValue
2979 [s_BoardInfos[dev->minor].
2981 ui_DigitalTemperature;
2983 /******************************************************/
2984 /*Start the conversion of the calibration offset value */
2985 /******************************************************/
2986 i_APCI3200_ReadCalibrationOffsetValue
2987 (dev, &ui_DummyValue);
2988 } /* if ((i_CJCFlag == 1) && (i_CalibrationFlag == 0)) */
2990 /********************************************************/
2991 /*Test if the value read is the calibration offset value */
2992 /********************************************************/
2994 if ((i_CalibrationFlag == 1)
2995 && (i_CJCFlag == 0)) {
2996 /* ui_InterruptChannelValue[i_Count + 1]=ui_DigitalTemperature; */
2997 s_BoardInfos[dev->minor].
2998 ui_InterruptChannelValue
2999 [s_BoardInfos[dev->minor].
3001 ui_DigitalTemperature;
3003 /****************************************************/
3004 /*Start the conversion of the calibration gain value */
3005 /****************************************************/
3006 i_APCI3200_ReadCalibrationGainValue(dev,
3009 } /* if ((i_CalibrationFlag == 1) && (i_CJCFlag == 0)) */
3011 /******************************************************/
3012 /*Test if the value read is the calibration gain value */
3013 /******************************************************/
3015 if ((i_CalibrationFlag == 2)
3016 && (i_CJCFlag == 0)) {
3017 /* ui_InterruptChannelValue[i_Count + 2]=ui_DigitalTemperature; */
3018 s_BoardInfos[dev->minor].
3019 ui_InterruptChannelValue
3020 [s_BoardInfos[dev->minor].
3022 ui_DigitalTemperature;
3024 /**********************************************************/
3025 /*Test if the Calibration channel must be read for the CJC */
3026 /**********************************************************/
3028 /*Test if the polarity is the same */
3029 /**********************************/
3030 /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
3031 if (s_BoardInfos[dev->minor].
3033 s_BoardInfos[dev->minor].
3034 i_ADDIDATAPolarity) {
3035 i_ConvertCJCCalibration = 1;
3036 } /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
3038 /* if(i_CJCGain==i_ADDIDATAGain) */
3039 if (s_BoardInfos[dev->minor].
3044 i_ConvertCJCCalibration
3046 } /* if(i_CJCGain==i_ADDIDATAGain) */
3048 i_ConvertCJCCalibration
3050 } /* elseif(i_CJCGain==i_ADDIDATAGain) */
3051 } /* elseif(i_CJCPolarity!=i_ADDIDATAPolarity) */
3052 if (i_ConvertCJCCalibration == 1) {
3053 /****************************************************************/
3054 /*Start the conversion of the calibration gain value for the CJC */
3055 /****************************************************************/
3056 i_APCI3200_ReadCJCCalOffset(dev,
3059 } /* if(i_ConvertCJCCalibration==1) */
3061 /* ui_InterruptChannelValue[i_Count + 4]=0; */
3062 /* ui_InterruptChannelValue[i_Count + 5]=0; */
3063 s_BoardInfos[dev->minor].
3064 ui_InterruptChannelValue
3068 s_BoardInfos[dev->minor].
3069 ui_InterruptChannelValue
3073 } /* elseif(i_ConvertCJCCalibration==1) */
3074 } /* else if ((i_CalibrationFlag == 2) && (i_CJCFlag == 0)) */
3076 /********************************************************************/
3077 /*Test if the value read is the calibration offset value for the CJC */
3078 /********************************************************************/
3080 if ((i_CalibrationFlag == 1)
3081 && (i_CJCFlag == 1)) {
3082 /* ui_InterruptChannelValue[i_Count + 4]=ui_DigitalTemperature; */
3083 s_BoardInfos[dev->minor].
3084 ui_InterruptChannelValue
3085 [s_BoardInfos[dev->minor].
3087 ui_DigitalTemperature;
3089 /****************************************************************/
3090 /*Start the conversion of the calibration gain value for the CJC */
3091 /****************************************************************/
3092 i_APCI3200_ReadCJCCalGain(dev,
3095 } /* if ((i_CalibrationFlag == 1) && (i_CJCFlag == 1)) */
3097 /******************************************************************/
3098 /*Test if the value read is the calibration gain value for the CJC */
3099 /******************************************************************/
3101 if ((i_CalibrationFlag == 2)
3102 && (i_CJCFlag == 1)) {
3103 /* ui_InterruptChannelValue[i_Count + 5]=ui_DigitalTemperature; */
3104 s_BoardInfos[dev->minor].
3105 ui_InterruptChannelValue
3106 [s_BoardInfos[dev->minor].
3108 ui_DigitalTemperature;
3110 /* if(i_ScanType==1) */
3111 if (s_BoardInfos[dev->minor].
3114 /* i_InterruptFlag=0; */
3115 s_BoardInfos[dev->minor].
3116 i_InterruptFlag = 0;
3117 /* i_Count=i_Count + 6; */
3118 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
3119 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count + 6; */
3120 s_BoardInfos[dev->minor].
3124 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
3125 } /* if(i_ScanType==1) */
3128 s_BoardInfos[dev->minor].
3130 } /* elseif(i_ScanType==1) */
3132 /* if(i_ScanType!=1) */
3133 if (s_BoardInfos[dev->minor].
3135 send_sig(SIGIO, devpriv->tsk_Current, 0); /* send signal to the sample */
3136 } /* if(i_ScanType!=1) */
3138 /* if(i_ChannelCount==i_Sum) */
3139 if (s_BoardInfos[dev->minor].
3143 send_sig(SIGIO, devpriv->tsk_Current, 0); /* send signal to the sample */
3145 } /* if(i_ChannelCount==i_Sum) */
3146 } /* else if(i_ScanType!=1) */
3147 } /* if ((i_CalibrationFlag == 2) && (i_CJCFlag == 1)) */
3149 } /* else if ((ui_StatusRegister & 0x2) == 0x2) */
3151 } /* switch(i_ADDIDATAType) */
3155 i_APCI3200_InterruptHandleEos(dev);
3157 } /* switch(i_ScanType) */