drivers/staging/comedi/drivers/addi-data/hwdrv_apci3200.c

   1 /**
   2 @verbatim
   3
   4 Copyright (C) 2004,2005  ADDI-DATA GmbH for the source code of this module.
   5
   6         ADDI-DATA GmbH
   7         Dieselstrasse 3
   8         D-77833 Ottersweier
   9         Tel: +19(0)7223/9493-0
  10         Fax: +49(0)7223/9493-92
  11         http://www.addi-data.com
  12         info@addi-data.com
  13
  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.
  15
  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.
  17
  18 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19
  20 You should also find the complete GPL in the COPYING file accompanying this source code.
  21
  22 @endverbatim
  23 */
  24 /*
  25
  26   +-----------------------------------------------------------------------+
  27   | (C) ADDI-DATA GmbH          Dieselstraße 3       D-77833 Ottersweier  |
  28   +-----------------------------------------------------------------------+
  29   | Tel : +49 (0) 7223/9493-0     | email    : info@addi-data.com         |
  30   | Fax : +49 (0) 7223/9493-92    | Internet : http://www.addi-data.com   |
  31   +-------------------------------+---------------------------------------+
  32   | Project     : APCI-3200       | Compiler   : GCC                      |
  33   | Module name : hwdrv_apci3200.c| Version    : 2.96                     |
  34   +-------------------------------+---------------------------------------+
  35   | Project manager: Eric Stolz   | Date       :  02/12/2002              |
  36   +-------------------------------+---------------------------------------+
  37   | Description :   Hardware Layer Access For APCI-3200                   |
  38   +-----------------------------------------------------------------------+
  39   |                             UPDATES                                   |
  40   +----------+-----------+------------------------------------------------+
  41   |   Date   |   Author  |          Description of updates                |
  42   +----------+-----------+------------------------------------------------+
  43   | 02.07.04 | J. Krauth | Modification from the driver in order to       |
  44   |          |           | correct some errors when using several boards. |
  45   |          |           |                                                |
  46   |          |           |                                                |
  47   +----------+-----------+------------------------------------------------+
  48   | 26.10.04 | J. Krauth | - Update for COMEDI 0.7.68                     |
  49   |          |           | - Read eeprom value                            |
  50   |          |           | - Append APCI-3300                             |
  51   +----------+-----------+------------------------------------------------+
  52 */
  53
  54 /* #define PRINT_INFO */
  55
  56 /* Card Specific information */
  57 /* #define APCI3200_ADDRESS_RANGE       264 */
  58
  59 /* Analog Input related Defines */
  60 #define APCI3200_AI_OFFSET_GAIN         0
  61 #define APCI3200_AI_SC_TEST             4
  62 #define APCI3200_AI_IRQ                 8
  63 #define APCI3200_AI_AUTOCAL             12
  64 #define APCI3200_RELOAD_CONV_TIME_VAL   32
  65 #define APCI3200_CONV_TIME_TIME_BASE    36
  66 #define APCI3200_RELOAD_DELAY_TIME_VAL  40
  67 #define APCI3200_DELAY_TIME_TIME_BASE   44
  68 #define APCI3200_AI_MODULE1             0
  69 #define APCI3200_AI_MODULE2             64
  70 #define APCI3200_AI_MODULE3             128
  71 #define APCI3200_AI_MODULE4             192
  72 #define TRUE                            1
  73 #define FALSE                           0
  74 #define APCI3200_AI_EOSIRQ              16
  75 #define APCI3200_AI_EOS                 20
  76 #define APCI3200_AI_CHAN_ID             24
  77 #define APCI3200_AI_CHAN_VAL            28
  78 #define ANALOG_INPUT                    0
  79 #define TEMPERATURE                     1
  80 #define RESISTANCE                      2
  81
  82 #define ENABLE_EXT_TRIG                 1
  83 #define ENABLE_EXT_GATE                 2
  84 #define ENABLE_EXT_TRIG_GATE            3
  85
  86 #define APCI3200_MAXVOLT                2.5
  87 #define ADDIDATA_GREATER_THAN_TEST      0
  88 #define ADDIDATA_LESS_THAN_TEST         1
  89
  90 #define ADDIDATA_UNIPOLAR               1
  91 #define ADDIDATA_BIPOLAR                2
  92
  93 #define MAX_MODULE                      4
  94
  95 /* ANALOG INPUT RANGE */
  96 static const struct comedi_lrange range_apci3200_ai = {
  97         8, {
  98                 BIP_RANGE(10),
  99                 BIP_RANGE(5),
 100                 BIP_RANGE(2),
 101                 BIP_RANGE(1),
 102                 UNI_RANGE(10),
 103                 UNI_RANGE(5),
 104                 UNI_RANGE(2),
 105                 UNI_RANGE(1)
 106         }
 107 };
 108
 109 static const struct comedi_lrange range_apci3300_ai = {
 110         4, {
 111                 UNI_RANGE(10),
 112                 UNI_RANGE(5),
 113                 UNI_RANGE(2),
 114                 UNI_RANGE(1)
 115         }
 116 };
 117
 118 int MODULE_NO;
 119 struct {
 120         int i_Gain;
 121         int i_Polarity;
 122         int i_OffsetRange;
 123         int i_Coupling;
 124         int i_SingleDiff;
 125         int i_AutoCalibration;
 126         unsigned int ui_ReloadValue;
 127         unsigned int ui_TimeUnitReloadVal;
 128         int i_Interrupt;
 129         int i_ModuleSelection;
 130 } Config_Parameters_Module1, Config_Parameters_Module2,
 131     Config_Parameters_Module3, Config_Parameters_Module4;
 132
 133
 134 struct str_ADDIDATA_RTDStruct {
 135         unsigned int ul_NumberOfValue;
 136         unsigned int *pul_ResistanceValue;
 137         unsigned int *pul_TemperatureValue;
 138 };
 139
 140 struct str_Module {
 141         unsigned long ul_CurrentSourceCJC;
 142         unsigned long ul_CurrentSource[5];
 143         unsigned long ul_GainFactor[8]; /*  Gain Factor */
 144         unsigned int w_GainValue[10];
 145 };
 146
 147 struct str_BoardInfos {
 148
 149         int i_CJCAvailable;
 150         int i_CJCPolarity;
 151         int i_CJCGain;
 152         int i_InterruptFlag;
 153         int i_ADDIDATAPolarity;
 154         int i_ADDIDATAGain;
 155         int i_AutoCalibration;
 156         int i_ADDIDATAConversionTime;
 157         int i_ADDIDATAConversionTimeUnit;
 158         int i_ADDIDATAType;
 159         int i_ChannelNo;
 160         int i_ChannelCount;
 161         int i_ScanType;
 162         int i_FirstChannel;
 163         int i_LastChannel;
 164         int i_Sum;
 165         int i_Offset;
 166         unsigned int ui_Channel_num;
 167         int i_Count;
 168         int i_Initialised;
 169         unsigned int ui_InterruptChannelValue[144];     /* Buffer */
 170         unsigned char b_StructInitialized;
 171         /* 7 is the maximal number of channels */
 172         unsigned int ui_ScanValueArray[7 + 12];
 173
 174         int i_ConnectionType;
 175         int i_NbrOfModule;
 176         struct str_Module s_Module[MAX_MODULE];
 177 };
 178
 179 /* BEGIN JK 06.07.04: Management of sevrals boards */
 180 /*
 181   int i_CJCAvailable=1;
 182   int i_CJCPolarity=0;
 183   int i_CJCGain=2;/* changed from 0 to 2 */
 184   int i_InterruptFlag=0;
 185   int i_ADDIDATAPolarity;
 186   int i_ADDIDATAGain;
 187   int i_AutoCalibration=0;   /* : auto calibration */
 188   int i_ADDIDATAConversionTime;
 189   int i_ADDIDATAConversionTimeUnit;
 190   int i_ADDIDATAType;
 191   int i_ChannelNo;
 192   int i_ChannelCount=0;
 193   int i_ScanType;
 194   int i_FirstChannel;
 195   int i_LastChannel;
 196   int i_Sum=0;
 197   int i_Offset;
 198   unsigned int ui_Channel_num=0;
 199   static int i_Count=0;
 200   int i_Initialised=0;
 201   unsigned int ui_InterruptChannelValue[96]; /* Buffer */
 202 */
 203 struct str_BoardInfos s_BoardInfos[100];        /*  100 will be the max number of boards to be used */
 204 /* END JK 06.07.04: Management of sevrals boards */
 205
 206 #define AMCC_OP_REG_MCSR        0x3c
 207 #define EEPROM_BUSY             0x80000000
 208 #define NVCMD_LOAD_LOW          (0x4 << 5)      /* nvRam load low command */
 209 #define NVCMD_LOAD_HIGH         (0x5 << 5)      /* nvRam load high command */
 210 #define NVCMD_BEGIN_READ        (0x7 << 5)      /* nvRam begin read command */
 211 #define NVCMD_BEGIN_WRITE       (0x6 << 5)      /* EEPROM begin write command */
 212
 213 static int i_AddiHeaderRW_ReadEeprom(int i_NbOfWordsToRead,
 214                                      unsigned int dw_PCIBoardEepromAddress,
 215                                      unsigned short w_EepromStartAddress,
 216                                      unsigned short *pw_DataRead)
 217 {
 218         unsigned int dw_eeprom_busy = 0;
 219         int i_Counter = 0;
 220         int i_WordCounter;
 221         int i;
 222         unsigned char pb_ReadByte[1];
 223         unsigned char b_ReadLowByte = 0;
 224         unsigned char b_ReadHighByte = 0;
 225         unsigned char b_SelectedAddressLow = 0;
 226         unsigned char b_SelectedAddressHigh = 0;
 227         unsigned short w_ReadWord = 0;
 228
 229         for (i_WordCounter = 0; i_WordCounter < i_NbOfWordsToRead;
 230                 i_WordCounter++) {
 231                 do {
 232                         dw_eeprom_busy =
 233                                 inl(dw_PCIBoardEepromAddress +
 234                                 AMCC_OP_REG_MCSR);
 235                         dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 236                 } while (dw_eeprom_busy == EEPROM_BUSY);
 237
 238                 for (i_Counter = 0; i_Counter < 2; i_Counter++) {
 239                         b_SelectedAddressLow = (w_EepromStartAddress + i_Counter) % 256;        /* Read the low 8 bit part */
 240                         b_SelectedAddressHigh = (w_EepromStartAddress + i_Counter) / 256;       /* Read the high 8 bit part */
 241
 242                         /* Select the load low address mode */
 243                         outb(NVCMD_LOAD_LOW,
 244                                 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
 245                                 3);
 246
 247                         /* Wait on busy */
 248                         do {
 249                                 dw_eeprom_busy =
 250                                         inl(dw_PCIBoardEepromAddress +
 251                                         AMCC_OP_REG_MCSR);
 252                                 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 253                         } while (dw_eeprom_busy == EEPROM_BUSY);
 254
 255                         /* Load the low address */
 256                         outb(b_SelectedAddressLow,
 257                                 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
 258                                 2);
 259
 260                         /* Wait on busy */
 261                         do {
 262                                 dw_eeprom_busy =
 263                                         inl(dw_PCIBoardEepromAddress +
 264                                         AMCC_OP_REG_MCSR);
 265                                 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 266                         } while (dw_eeprom_busy == EEPROM_BUSY);
 267
 268                         /* Select the load high address mode */
 269                         outb(NVCMD_LOAD_HIGH,
 270                                 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
 271                                 3);
 272
 273                         /* Wait on busy */
 274                         do {
 275                                 dw_eeprom_busy =
 276                                         inl(dw_PCIBoardEepromAddress +
 277                                         AMCC_OP_REG_MCSR);
 278                                 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 279                         } while (dw_eeprom_busy == EEPROM_BUSY);
 280
 281                         /* Load the high address */
 282                         outb(b_SelectedAddressHigh,
 283                                 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
 284                                 2);
 285
 286                         /* Wait on busy */
 287                         do {
 288                                 dw_eeprom_busy =
 289                                         inl(dw_PCIBoardEepromAddress +
 290                                         AMCC_OP_REG_MCSR);
 291                                 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 292                         } while (dw_eeprom_busy == EEPROM_BUSY);
 293
 294                         /* Select the READ mode */
 295                         outb(NVCMD_BEGIN_READ,
 296                                 dw_PCIBoardEepromAddress + AMCC_OP_REG_MCSR +
 297                                 3);
 298
 299                         /* Wait on busy */
 300                         do {
 301                                 dw_eeprom_busy =
 302                                         inl(dw_PCIBoardEepromAddress +
 303                                         AMCC_OP_REG_MCSR);
 304                                 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 305                         } while (dw_eeprom_busy == EEPROM_BUSY);
 306
 307                         /* Read data into the EEPROM */
 308                         *pb_ReadByte =
 309                                 inb(dw_PCIBoardEepromAddress +
 310                                 AMCC_OP_REG_MCSR + 2);
 311
 312                         /* Wait on busy */
 313                         do {
 314                                 dw_eeprom_busy =
 315                                         inl(dw_PCIBoardEepromAddress +
 316                                         AMCC_OP_REG_MCSR);
 317                                 dw_eeprom_busy = dw_eeprom_busy & EEPROM_BUSY;
 318                         } while (dw_eeprom_busy == EEPROM_BUSY);
 319
 320                         /* Select the upper address part */
 321                         if (i_Counter == 0)
 322                                 b_ReadLowByte = pb_ReadByte[0];
 323                         else
 324                                 b_ReadHighByte = pb_ReadByte[0];
 325
 326
 327                         /* Sleep */
 328                         msleep(1);
 329
 330                 }
 331                 w_ReadWord =
 332                         (b_ReadLowByte | (((unsigned short)b_ReadHighByte) *
 333                                 256));
 334
 335                 pw_DataRead[i_WordCounter] = w_ReadWord;
 336
 337                 w_EepromStartAddress += 2;      /*  to read the next word */
 338
 339         }                       /*  for (...) i_NbOfWordsToRead */
 340         return 0;
 341 }
 342
 343 static void v_GetAPCI3200EepromCalibrationValue(unsigned int dw_PCIBoardEepromAddress,
 344                                                 struct str_BoardInfos *BoardInformations)
 345 {
 346         unsigned short w_AnalogInputMainHeaderAddress;
 347         unsigned short w_AnalogInputComponentAddress;
 348         unsigned short w_NumberOfModuls = 0;
 349         unsigned short w_CurrentSources[2];
 350         unsigned short w_ModulCounter = 0;
 351         unsigned short w_FirstHeaderSize = 0;
 352         unsigned short w_NumberOfInputs = 0;
 353         unsigned short w_CJCFlag = 0;
 354         unsigned short w_NumberOfGainValue = 0;
 355         unsigned short w_SingleHeaderAddress = 0;
 356         unsigned short w_SingleHeaderSize = 0;
 357         unsigned short w_Input = 0;
 358         unsigned short w_GainFactorAddress = 0;
 359         unsigned short w_GainFactorValue[2];
 360         unsigned short w_GainIndex = 0;
 361         unsigned short w_GainValue = 0;
 362
 363   /*****************************************/
 364   /** Get the Analog input header address **/
 365   /*****************************************/
 366         i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 367                 dw_PCIBoardEepromAddress, 0x116,        /* w_EepromStartAddress: Analog input header address */
 368                 &w_AnalogInputMainHeaderAddress);
 369
 370   /*******************************************/
 371   /** Compute the real analog input address **/
 372   /*******************************************/
 373         w_AnalogInputMainHeaderAddress = w_AnalogInputMainHeaderAddress + 0x100;
 374
 375   /******************************/
 376   /** Get the number of moduls **/
 377   /******************************/
 378         i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 379                 dw_PCIBoardEepromAddress, w_AnalogInputMainHeaderAddress + 0x02,        /* w_EepromStartAddress: Number of conponment */
 380                 &w_NumberOfModuls);
 381
 382         for (w_ModulCounter = 0; w_ModulCounter < w_NumberOfModuls;
 383                 w_ModulCounter++) {
 384       /***********************************/
 385       /** Compute the component address **/
 386       /***********************************/
 387                 w_AnalogInputComponentAddress =
 388                         w_AnalogInputMainHeaderAddress +
 389                         (w_FirstHeaderSize * w_ModulCounter) + 0x04;
 390
 391       /****************************/
 392       /** Read first header size **/
 393       /****************************/
 394                 i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 395                         dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress,        /*  Address of the first header */
 396                         &w_FirstHeaderSize);
 397
 398                 w_FirstHeaderSize = w_FirstHeaderSize >> 4;
 399
 400       /***************************/
 401       /** Read number of inputs **/
 402       /***************************/
 403                 i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 404                         dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 0x06, /*  Number of inputs for the first modul */
 405                         &w_NumberOfInputs);
 406
 407                 w_NumberOfInputs = w_NumberOfInputs >> 4;
 408
 409       /***********************/
 410       /** Read the CJC flag **/
 411       /***********************/
 412                 i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 413                         dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 0x08, /*  CJC flag */
 414                         &w_CJCFlag);
 415
 416                 w_CJCFlag = (w_CJCFlag >> 3) & 0x1;     /*  Get only the CJC flag */
 417
 418       /*******************************/
 419       /** Read number of gain value **/
 420       /*******************************/
 421                 i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 422                         dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 0x44, /*  Number of gain value */
 423                         &w_NumberOfGainValue);
 424
 425                 w_NumberOfGainValue = w_NumberOfGainValue & 0xFF;
 426
 427       /***********************************/
 428       /** Compute single header address **/
 429       /***********************************/
 430                 w_SingleHeaderAddress =
 431                         w_AnalogInputComponentAddress + 0x46 +
 432                         (((w_NumberOfGainValue / 16) + 1) * 2) +
 433                         (6 * w_NumberOfGainValue) +
 434                         (4 * (((w_NumberOfGainValue / 16) + 1) * 2));
 435
 436       /********************************************/
 437       /** Read current sources value for input 1 **/
 438       /********************************************/
 439                 i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 440                         dw_PCIBoardEepromAddress, w_SingleHeaderAddress,        /* w_EepromStartAddress: Single header address */
 441                         &w_SingleHeaderSize);
 442
 443                 w_SingleHeaderSize = w_SingleHeaderSize >> 4;
 444
 445       /*************************************/
 446       /** Read gain factor for the module **/
 447       /*************************************/
 448                 w_GainFactorAddress = w_AnalogInputComponentAddress;
 449
 450                 for (w_GainIndex = 0; w_GainIndex < w_NumberOfGainValue;
 451                         w_GainIndex++) {
 452           /************************************/
 453           /** Read gain value for the module **/
 454           /************************************/
 455                         i_AddiHeaderRW_ReadEeprom(1,    /* i_NbOfWordsToRead */
 456                                 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 70 + (2 * (1 + (w_NumberOfGainValue / 16))) + (0x02 * w_GainIndex),   /*  Gain value */
 457                                 &w_GainValue);
 458
 459                         BoardInformations->s_Module[w_ModulCounter].
 460                                 w_GainValue[w_GainIndex] = w_GainValue;
 461
 462 #             ifdef PRINT_INFO
 463                         printk("\n Gain value = %d",
 464                                 BoardInformations->s_Module[w_ModulCounter].
 465                                 w_GainValue[w_GainIndex]);
 466 #             endif
 467
 468           /*************************************/
 469           /** Read gain factor for the module **/
 470           /*************************************/
 471                         i_AddiHeaderRW_ReadEeprom(2,    /* i_NbOfWordsToRead */
 472                                 dw_PCIBoardEepromAddress, w_AnalogInputComponentAddress + 70 + ((2 * w_NumberOfGainValue) + (2 * (1 + (w_NumberOfGainValue / 16)))) + (0x04 * w_GainIndex),     /*  Gain factor */
 473                                 w_GainFactorValue);
 474
 475                         BoardInformations->s_Module[w_ModulCounter].
 476                                 ul_GainFactor[w_GainIndex] =
 477                                 (w_GainFactorValue[1] << 16) +
 478                                 w_GainFactorValue[0];
 479
 480 #             ifdef PRINT_INFO
 481                         printk("\n w_GainFactorValue [%d] = %lu", w_GainIndex,
 482                                 BoardInformations->s_Module[w_ModulCounter].
 483                                 ul_GainFactor[w_GainIndex]);
 484 #             endif
 485                 }
 486
 487       /***************************************************************/
 488       /** Read current source value for each channels of the module **/
 489       /***************************************************************/
 490                 for (w_Input = 0; w_Input < w_NumberOfInputs; w_Input++) {
 491           /********************************************/
 492           /** Read current sources value for input 1 **/
 493           /********************************************/
 494                         i_AddiHeaderRW_ReadEeprom(2,    /* i_NbOfWordsToRead */
 495                                 dw_PCIBoardEepromAddress,
 496                                 (w_Input * w_SingleHeaderSize) +
 497                                 w_SingleHeaderAddress + 0x0C, w_CurrentSources);
 498
 499           /************************************/
 500           /** Save the current sources value **/
 501           /************************************/
 502                         BoardInformations->s_Module[w_ModulCounter].
 503                                 ul_CurrentSource[w_Input] =
 504                                 (w_CurrentSources[0] +
 505                                 ((w_CurrentSources[1] & 0xFFF) << 16));
 506
 507 #             ifdef PRINT_INFO
 508                         printk("\n Current sources [%d] = %lu", w_Input,
 509                                 BoardInformations->s_Module[w_ModulCounter].
 510                                 ul_CurrentSource[w_Input]);
 511 #             endif
 512                 }
 513
 514       /***************************************/
 515       /** Read the CJC current source value **/
 516       /***************************************/
 517                 i_AddiHeaderRW_ReadEeprom(2,    /* i_NbOfWordsToRead */
 518                         dw_PCIBoardEepromAddress,
 519                         (w_Input * w_SingleHeaderSize) + w_SingleHeaderAddress +
 520                         0x0C, w_CurrentSources);
 521
 522       /************************************/
 523       /** Save the current sources value **/
 524       /************************************/
 525                 BoardInformations->s_Module[w_ModulCounter].
 526                         ul_CurrentSourceCJC =
 527                         (w_CurrentSources[0] +
 528                         ((w_CurrentSources[1] & 0xFFF) << 16));
 529
 530 #          ifdef PRINT_INFO
 531                 printk("\n Current sources CJC = %lu",
 532                         BoardInformations->s_Module[w_ModulCounter].
 533                         ul_CurrentSourceCJC);
 534 #          endif
 535         }
 536 }
 537
 538 static int i_APCI3200_GetChannelCalibrationValue(struct comedi_device *dev,
 539                                                  unsigned int ui_Channel_num,
 540                                                  unsigned int *CJCCurrentSource,
 541                                                  unsigned int *ChannelCurrentSource,
 542                                                  unsigned int *ChannelGainFactor)
 543 {
 544         int i_DiffChannel = 0;
 545         int i_Module = 0;
 546
 547 #ifdef PRINT_INFO
 548         printk("\n Channel = %u", ui_Channel_num);
 549 #endif
 550
 551         /* Test if single or differential mode */
 552         if (s_BoardInfos[dev->minor].i_ConnectionType == 1) {
 553                 /* if diff */
 554
 555                 if (ui_Channel_num <= 1)
 556                         i_DiffChannel = ui_Channel_num, i_Module = 0;
 557                 else if ((ui_Channel_num >= 2) && (ui_Channel_num <= 3))
 558                         i_DiffChannel = ui_Channel_num - 2, i_Module = 1;
 559                 else if ((ui_Channel_num >= 4) && (ui_Channel_num <= 5))
 560                         i_DiffChannel = ui_Channel_num - 4, i_Module = 2;
 561                 else if ((ui_Channel_num >= 6) && (ui_Channel_num <= 7))
 562                         i_DiffChannel = ui_Channel_num - 6, i_Module = 3;
 563
 564         } else {
 565                 /*  if single */
 566                 if ((ui_Channel_num == 0) || (ui_Channel_num == 1))
 567                         i_DiffChannel = 0, i_Module = 0;
 568                 else if ((ui_Channel_num == 2) || (ui_Channel_num == 3))
 569                         i_DiffChannel = 1, i_Module = 0;
 570                 else if ((ui_Channel_num == 4) || (ui_Channel_num == 5))
 571                         i_DiffChannel = 0, i_Module = 1;
 572                 else if ((ui_Channel_num == 6) || (ui_Channel_num == 7))
 573                         i_DiffChannel = 1, i_Module = 1;
 574                 else if ((ui_Channel_num == 8) || (ui_Channel_num == 9))
 575                         i_DiffChannel = 0, i_Module = 2;
 576                 else if ((ui_Channel_num == 10) || (ui_Channel_num == 11))
 577                         i_DiffChannel = 1, i_Module = 2;
 578                 else if ((ui_Channel_num == 12) || (ui_Channel_num == 13))
 579                         i_DiffChannel = 0, i_Module = 3;
 580                 else if ((ui_Channel_num == 14) || (ui_Channel_num == 15))
 581                         i_DiffChannel = 1, i_Module = 3;
 582         }
 583
 584         /* Test if thermocouple or RTD mode */
 585         *CJCCurrentSource =
 586                 s_BoardInfos[dev->minor].s_Module[i_Module].ul_CurrentSourceCJC;
 587 #ifdef PRINT_INFO
 588         printk("\n CJCCurrentSource = %lu", *CJCCurrentSource);
 589 #endif
 590
 591         *ChannelCurrentSource =
 592                 s_BoardInfos[dev->minor].s_Module[i_Module].
 593                 ul_CurrentSource[i_DiffChannel];
 594 #ifdef PRINT_INFO
 595         printk("\n ChannelCurrentSource = %lu", *ChannelCurrentSource);
 596 #endif
 597         /*       } */
 598         /*    } */
 599
 600         /* Channle gain factor */
 601         *ChannelGainFactor =
 602                 s_BoardInfos[dev->minor].s_Module[i_Module].
 603                 ul_GainFactor[s_BoardInfos[dev->minor].i_ADDIDATAGain];
 604 #ifdef PRINT_INFO
 605         printk("\n ChannelGainFactor = %lu", *ChannelGainFactor);
 606 #endif
 607         /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
 608
 609         return 0;
 610 }
 611
 612 static int apci3200_di_insn_bits(struct comedi_device *dev,
 613                                  struct comedi_subdevice *s,
 614                                  struct comedi_insn *insn,
 615                                  unsigned int *data)
 616 {
 617         struct addi_private *devpriv = dev->private;
 618
 619         data[1] = inl(devpriv->i_IobaseReserved) & 0xf;
 620
 621         return insn->n;
 622 }
 623
 624 static int apci3200_do_insn_bits(struct comedi_device *dev,
 625                                  struct comedi_subdevice *s,
 626                                  struct comedi_insn *insn,
 627                                  unsigned int *data)
 628 {
 629         struct addi_private *devpriv = dev->private;
 630         unsigned int mask = data[0];
 631         unsigned int bits = data[1];
 632
 633         s->state = inl(devpriv->i_IobaseAddon) & 0xf;
 634         if (mask) {
 635                 s->state &= ~mask;
 636                 s->state |= (bits & mask);
 637
 638                 outl(s->state, devpriv->i_IobaseAddon);
 639         }
 640
 641         data[1] = s->state;
 642
 643         return insn->n;
 644 }
 645
 646 static int i_APCI3200_Read1AnalogInputChannel(struct comedi_device *dev,
 647                                               struct comedi_subdevice *s,
 648                                               struct comedi_insn *insn,
 649                                               unsigned int *data)
 650 {
 651         struct addi_private *devpriv = dev->private;
 652         unsigned int ui_EOC = 0;
 653         unsigned int ui_ChannelNo = 0;
 654         unsigned int ui_CommandRegister = 0;
 655
 656         /* BEGIN JK 06.07.04: Management of sevrals boards */
 657         /* ui_ChannelNo=i_ChannelNo; */
 658         ui_ChannelNo = s_BoardInfos[dev->minor].i_ChannelNo;
 659
 660         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 661         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 662                                         12) >> 19) & 1) != 1) ;
 663   /*********************************/
 664         /* Write the channel to configure */
 665   /*********************************/
 666         /* Begin JK 20.10.2004: Bad channel value is used when using differential mode */
 667         /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
 668         /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
 669         outl(0 | s_BoardInfos[dev->minor].i_ChannelNo,
 670                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x4);
 671         /* End JK 20.10.2004: Bad channel value is used when using differential mode */
 672
 673   /*******************************/
 674         /* Set the convert timing unit */
 675   /*******************************/
 676         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 677         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 678                                         12) >> 19) & 1) != 1) ;
 679
 680         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
 681         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
 682                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
 683
 684   /**************************/
 685         /* Set the convert timing */
 686   /**************************/
 687         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 688         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 689                                         12) >> 19) & 1) != 1) ;
 690
 691         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
 692         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
 693                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
 694
 695   /**************************************************************************/
 696         /* Set the start end stop index to the selected channel and set the start */
 697   /**************************************************************************/
 698
 699         ui_CommandRegister = ui_ChannelNo | (ui_ChannelNo << 8) | 0x80000;
 700
 701   /*********************************/
 702         /*Test if the interrupt is enable */
 703   /*********************************/
 704
 705         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 706         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
 707       /************************/
 708                 /* Enable the interrupt */
 709       /************************/
 710                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
 711         }                       /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 712
 713   /******************************/
 714         /* Write the command register */
 715   /******************************/
 716         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 717         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 718                                         12) >> 19) & 1) != 1) ;
 719
 720         /* outl(ui_CommandRegister, devpriv->iobase+i_Offset + 8); */
 721         outl(ui_CommandRegister,
 722                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
 723
 724   /*****************************/
 725         /*Test if interrupt is enable */
 726   /*****************************/
 727         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 728         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
 729                 do {
 730           /*************************/
 731                         /*Read the EOC Status bit */
 732           /*************************/
 733
 734                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
 735                         ui_EOC = inl(devpriv->iobase +
 736                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
 737
 738                 } while (ui_EOC != 1);
 739
 740       /***************************************/
 741                 /* Read the digital value of the input */
 742       /***************************************/
 743
 744                 /* data[0] = inl (devpriv->iobase+i_Offset + 28); */
 745                 data[0] =
 746                         inl(devpriv->iobase +
 747                         s_BoardInfos[dev->minor].i_Offset + 28);
 748                 /* END JK 06.07.04: Management of sevrals boards */
 749
 750         }                       /*  if (i_InterruptFlag == ADDIDATA_DISABLE) */
 751         return 0;
 752 }
 753
 754 static int i_APCI3200_ReadCalibrationOffsetValue(struct comedi_device *dev,
 755                                                  unsigned int *data)
 756 {
 757         struct addi_private *devpriv = dev->private;
 758         unsigned int ui_Temp = 0, ui_EOC = 0;
 759         unsigned int ui_CommandRegister = 0;
 760
 761         /* BEGIN JK 06.07.04: Management of sevrals boards */
 762         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 763         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 764                                         12) >> 19) & 1) != 1) ;
 765   /*********************************/
 766         /* Write the channel to configure */
 767   /*********************************/
 768         /* Begin JK 20.10.2004: This seems not necessary ! */
 769         /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
 770         /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
 771         /* End JK 20.10.2004: This seems not necessary ! */
 772
 773   /*******************************/
 774         /* Set the convert timing unit */
 775   /*******************************/
 776         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 777         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 778                                         12) >> 19) & 1) != 1) ;
 779         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
 780         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
 781                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
 782   /**************************/
 783         /* Set the convert timing */
 784   /**************************/
 785         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 786         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 787                                         12) >> 19) & 1) != 1) ;
 788         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
 789         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
 790                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
 791   /*****************************/
 792         /*Read the calibration offset */
 793   /*****************************/
 794         /* ui_Temp = inl(devpriv->iobase+i_Offset + 12); */
 795         ui_Temp = inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
 796
 797   /*********************************/
 798         /*Configure the Offset Conversion */
 799   /*********************************/
 800         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 801         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 802                                         12) >> 19) & 1) != 1) ;
 803         /* outl((ui_Temp | 0x00020000), devpriv->iobase+i_Offset + 12); */
 804         outl((ui_Temp | 0x00020000),
 805                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
 806   /*******************************/
 807         /*Initialise ui_CommandRegister */
 808   /*******************************/
 809
 810         ui_CommandRegister = 0;
 811
 812   /*********************************/
 813         /*Test if the interrupt is enable */
 814   /*********************************/
 815
 816         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 817         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
 818
 819       /**********************/
 820                 /*Enable the interrupt */
 821       /**********************/
 822
 823                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
 824
 825         }                       /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 826
 827   /**********************/
 828         /*Start the conversion */
 829   /**********************/
 830         ui_CommandRegister = ui_CommandRegister | 0x00080000;
 831
 832   /***************************/
 833         /*Write the command regiter */
 834   /***************************/
 835         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 836         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 837                                         12) >> 19) & 1) != 1) ;
 838         /* outl(ui_CommandRegister, devpriv->iobase+i_Offset + 8); */
 839         outl(ui_CommandRegister,
 840                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
 841
 842   /*****************************/
 843         /*Test if interrupt is enable */
 844   /*****************************/
 845
 846         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 847         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
 848
 849                 do {
 850           /*******************/
 851                         /*Read the EOC flag */
 852           /*******************/
 853
 854                         /* ui_EOC = inl (devpriv->iobase+i_Offset + 20) & 1; */
 855                         ui_EOC = inl(devpriv->iobase +
 856                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
 857
 858                 } while (ui_EOC != 1);
 859
 860       /**************************************************/
 861                 /*Read the digital value of the calibration Offset */
 862       /**************************************************/
 863
 864                 /* data[0] = inl(devpriv->iobase+i_Offset+ 28); */
 865                 data[0] =
 866                         inl(devpriv->iobase +
 867                         s_BoardInfos[dev->minor].i_Offset + 28);
 868         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 869         return 0;
 870 }
 871
 872 static int i_APCI3200_ReadCalibrationGainValue(struct comedi_device *dev,
 873                                                unsigned int *data)
 874 {
 875         struct addi_private *devpriv = dev->private;
 876         unsigned int ui_EOC = 0;
 877         int ui_CommandRegister = 0;
 878
 879         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 880         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 881                                         12) >> 19) & 1) != 1) ;
 882   /*********************************/
 883         /* Write the channel to configure */
 884   /*********************************/
 885         /* Begin JK 20.10.2004: This seems not necessary ! */
 886         /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
 887         /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
 888         /* End JK 20.10.2004: This seems not necessary ! */
 889
 890   /***************************/
 891         /*Read the calibration gain */
 892   /***************************/
 893   /*******************************/
 894         /* Set the convert timing unit */
 895   /*******************************/
 896         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 897         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 898                                         12) >> 19) & 1) != 1) ;
 899         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
 900         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
 901                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
 902   /**************************/
 903         /* Set the convert timing */
 904   /**************************/
 905         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 906         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 907                                         12) >> 19) & 1) != 1) ;
 908         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
 909         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
 910                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
 911   /*******************************/
 912         /*Configure the Gain Conversion */
 913   /*******************************/
 914         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 915         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 916                                         12) >> 19) & 1) != 1) ;
 917         /* outl(0x00040000 , devpriv->iobase+i_Offset + 12); */
 918         outl(0x00040000,
 919                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
 920
 921   /*******************************/
 922         /*Initialise ui_CommandRegister */
 923   /*******************************/
 924
 925         ui_CommandRegister = 0;
 926
 927   /*********************************/
 928         /*Test if the interrupt is enable */
 929   /*********************************/
 930
 931         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 932         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
 933
 934       /**********************/
 935                 /*Enable the interrupt */
 936       /**********************/
 937
 938                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
 939
 940         }                       /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 941
 942   /**********************/
 943         /*Start the conversion */
 944   /**********************/
 945
 946         ui_CommandRegister = ui_CommandRegister | 0x00080000;
 947   /***************************/
 948         /*Write the command regiter */
 949   /***************************/
 950         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 951         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 952                                         12) >> 19) & 1) != 1) ;
 953         /* outl(ui_CommandRegister , devpriv->iobase+i_Offset + 8); */
 954         outl(ui_CommandRegister,
 955                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
 956
 957   /*****************************/
 958         /*Test if interrupt is enable */
 959   /*****************************/
 960
 961         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 962         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
 963
 964                 do {
 965
 966           /*******************/
 967                         /*Read the EOC flag */
 968           /*******************/
 969
 970                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
 971                         ui_EOC = inl(devpriv->iobase +
 972                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
 973
 974                 } while (ui_EOC != 1);
 975
 976       /************************************************/
 977                 /*Read the digital value of the calibration Gain */
 978       /************************************************/
 979
 980                 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
 981                 data[0] =
 982                         inl(devpriv->iobase +
 983                         s_BoardInfos[dev->minor].i_Offset + 28);
 984
 985         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 986         return 0;
 987 }
 988
 989 static int i_APCI3200_ReadCJCValue(struct comedi_device *dev,
 990                                    unsigned int *data)
 991 {
 992         struct addi_private *devpriv = dev->private;
 993         unsigned int ui_EOC = 0;
 994         int ui_CommandRegister = 0;
 995
 996   /******************************/
 997         /*Set the converting time unit */
 998   /******************************/
 999
1000         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1001         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1002                                         12) >> 19) & 1) != 1) ;
1003
1004         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1005         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1006                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1007   /**************************/
1008         /* Set the convert timing */
1009   /**************************/
1010         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1011         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1012                                         12) >> 19) & 1) != 1) ;
1013
1014         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1015         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1016                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1017
1018   /******************************/
1019         /*Configure the CJC Conversion */
1020   /******************************/
1021         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1022         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1023                                         12) >> 19) & 1) != 1) ;
1024
1025         /* outl( 0x00000400 , devpriv->iobase+i_Offset + 4); */
1026         outl(0x00000400,
1027                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1028   /*******************************/
1029         /*Initialise dw_CommandRegister */
1030   /*******************************/
1031         ui_CommandRegister = 0;
1032   /*********************************/
1033         /*Test if the interrupt is enable */
1034   /*********************************/
1035         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1036         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1037       /**********************/
1038                 /*Enable the interrupt */
1039       /**********************/
1040                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1041         }
1042
1043   /**********************/
1044         /*Start the conversion */
1045   /**********************/
1046
1047         ui_CommandRegister = ui_CommandRegister | 0x00080000;
1048
1049   /***************************/
1050         /*Write the command regiter */
1051   /***************************/
1052         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1053         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1054                                         12) >> 19) & 1) != 1) ;
1055         /* outl(ui_CommandRegister , devpriv->iobase+i_Offset + 8); */
1056         outl(ui_CommandRegister,
1057                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1058
1059   /*****************************/
1060         /*Test if interrupt is enable */
1061   /*****************************/
1062
1063         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1064         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1065                 do {
1066
1067           /*******************/
1068                         /*Read the EOC flag */
1069           /*******************/
1070
1071                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1072                         ui_EOC = inl(devpriv->iobase +
1073                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1074
1075                 } while (ui_EOC != 1);
1076
1077       /***********************************/
1078                 /*Read the digital value of the CJC */
1079       /***********************************/
1080
1081                 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
1082                 data[0] =
1083                         inl(devpriv->iobase +
1084                         s_BoardInfos[dev->minor].i_Offset + 28);
1085
1086         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1087         return 0;
1088 }
1089
1090 static int i_APCI3200_ReadCJCCalOffset(struct comedi_device *dev,
1091                                        unsigned int *data)
1092 {
1093         struct addi_private *devpriv = dev->private;
1094         unsigned int ui_EOC = 0;
1095         int ui_CommandRegister = 0;
1096
1097   /*******************************************/
1098         /*Read calibration offset value for the CJC */
1099   /*******************************************/
1100   /*******************************/
1101         /* Set the convert timing unit */
1102   /*******************************/
1103         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1104         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1105                                         12) >> 19) & 1) != 1) ;
1106         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1107         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1108                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1109   /**************************/
1110         /* Set the convert timing */
1111   /**************************/
1112         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1113         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1114                                         12) >> 19) & 1) != 1) ;
1115         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1116         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1117                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1118   /******************************/
1119         /*Configure the CJC Conversion */
1120   /******************************/
1121         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1122         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1123                                         12) >> 19) & 1) != 1) ;
1124         /* outl(0x00000400 , devpriv->iobase+i_Offset + 4); */
1125         outl(0x00000400,
1126                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1127   /*********************************/
1128         /*Configure the Offset Conversion */
1129   /*********************************/
1130         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1131         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1132                                         12) >> 19) & 1) != 1) ;
1133         /* outl(0x00020000, devpriv->iobase+i_Offset + 12); */
1134         outl(0x00020000,
1135                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
1136   /*******************************/
1137         /*Initialise ui_CommandRegister */
1138   /*******************************/
1139         ui_CommandRegister = 0;
1140   /*********************************/
1141         /*Test if the interrupt is enable */
1142   /*********************************/
1143
1144         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1145         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1146       /**********************/
1147                 /*Enable the interrupt */
1148       /**********************/
1149                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1150
1151         }
1152
1153   /**********************/
1154         /*Start the conversion */
1155   /**********************/
1156         ui_CommandRegister = ui_CommandRegister | 0x00080000;
1157   /***************************/
1158         /*Write the command regiter */
1159   /***************************/
1160         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1161         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1162                                         12) >> 19) & 1) != 1) ;
1163         /* outl(ui_CommandRegister,devpriv->iobase+i_Offset + 8); */
1164         outl(ui_CommandRegister,
1165                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1166         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1167         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1168                 do {
1169           /*******************/
1170                         /*Read the EOC flag */
1171           /*******************/
1172                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1173                         ui_EOC = inl(devpriv->iobase +
1174                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1175                 } while (ui_EOC != 1);
1176
1177       /**************************************************/
1178                 /*Read the digital value of the calibration Offset */
1179       /**************************************************/
1180                 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
1181                 data[0] =
1182                         inl(devpriv->iobase +
1183                         s_BoardInfos[dev->minor].i_Offset + 28);
1184         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1185         return 0;
1186 }
1187
1188 static int i_APCI3200_ReadCJCCalGain(struct comedi_device *dev,
1189                                      unsigned int *data)
1190 {
1191         struct addi_private *devpriv = dev->private;
1192         unsigned int ui_EOC = 0;
1193         int ui_CommandRegister = 0;
1194
1195   /*******************************/
1196         /* Set the convert timing unit */
1197   /*******************************/
1198         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1199         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1200                                         12) >> 19) & 1) != 1) ;
1201         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1202         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1203                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1204   /**************************/
1205         /* Set the convert timing */
1206   /**************************/
1207         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1208         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1209                                         12) >> 19) & 1) != 1) ;
1210         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1211         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1212                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1213   /******************************/
1214         /*Configure the CJC Conversion */
1215   /******************************/
1216         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1217         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1218                                         12) >> 19) & 1) != 1) ;
1219         /* outl(0x00000400,devpriv->iobase+i_Offset + 4); */
1220         outl(0x00000400,
1221                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1222   /*******************************/
1223         /*Configure the Gain Conversion */
1224   /*******************************/
1225         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1226         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1227                                         12) >> 19) & 1) != 1) ;
1228         /* outl(0x00040000,devpriv->iobase+i_Offset + 12); */
1229         outl(0x00040000,
1230                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
1231
1232   /*******************************/
1233         /*Initialise dw_CommandRegister */
1234   /*******************************/
1235         ui_CommandRegister = 0;
1236   /*********************************/
1237         /*Test if the interrupt is enable */
1238   /*********************************/
1239         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1240         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1241       /**********************/
1242                 /*Enable the interrupt */
1243       /**********************/
1244                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1245         }
1246   /**********************/
1247         /*Start the conversion */
1248   /**********************/
1249         ui_CommandRegister = ui_CommandRegister | 0x00080000;
1250   /***************************/
1251         /*Write the command regiter */
1252   /***************************/
1253         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1254         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1255                                         12) >> 19) & 1) != 1) ;
1256         /* outl(ui_CommandRegister ,devpriv->iobase+i_Offset + 8); */
1257         outl(ui_CommandRegister,
1258                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1259         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1260         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1261                 do {
1262           /*******************/
1263                         /*Read the EOC flag */
1264           /*******************/
1265                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1266                         ui_EOC = inl(devpriv->iobase +
1267                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1268                 } while (ui_EOC != 1);
1269       /************************************************/
1270                 /*Read the digital value of the calibration Gain */
1271       /************************************************/
1272                 /* data[0] = inl (devpriv->iobase+i_Offset + 28); */
1273                 data[0] =
1274                         inl(devpriv->iobase +
1275                         s_BoardInfos[dev->minor].i_Offset + 28);
1276         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1277         return 0;
1278 }
1279
1280 static int i_APCI3200_Reset(struct comedi_device *dev)
1281 {
1282         struct addi_private *devpriv = dev->private;
1283         int i_Temp;
1284         unsigned int dw_Dummy;
1285
1286         /* i_InterruptFlag=0; */
1287         /* i_Initialised==0; */
1288         /* i_Count=0; */
1289         /* i_Sum=0; */
1290
1291         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1292         s_BoardInfos[dev->minor].i_Initialised = 0;
1293         s_BoardInfos[dev->minor].i_Count = 0;
1294         s_BoardInfos[dev->minor].i_Sum = 0;
1295         s_BoardInfos[dev->minor].b_StructInitialized = 0;
1296
1297         outl(0x83838383, devpriv->i_IobaseAmcc + 0x60);
1298
1299         /*  Enable the interrupt for the controller */
1300         dw_Dummy = inl(devpriv->i_IobaseAmcc + 0x38);
1301         outl(dw_Dummy | 0x2000, devpriv->i_IobaseAmcc + 0x38);
1302         outl(0, devpriv->i_IobaseAddon);        /* Resets the output */
1303   /***************/
1304         /*Empty the buffer */
1305   /**************/
1306         for (i_Temp = 0; i_Temp <= 95; i_Temp++) {
1307                 /* ui_InterruptChannelValue[i_Temp]=0; */
1308                 s_BoardInfos[dev->minor].ui_InterruptChannelValue[i_Temp] = 0;
1309         }                       /* for(i_Temp=0;i_Temp<=95;i_Temp++) */
1310   /*****************************/
1311         /*Reset the START and IRQ bit */
1312   /*****************************/
1313         for (i_Temp = 0; i_Temp <= 192;) {
1314                 while (((inl(devpriv->iobase + i_Temp + 12) >> 19) & 1) != 1) ;
1315                 outl(0, devpriv->iobase + i_Temp + 8);
1316                 i_Temp = i_Temp + 64;
1317         }                       /* for(i_Temp=0;i_Temp<=192;i_Temp+64) */
1318         return 0;
1319 }
1320
1321 /*
1322  * Read value of the selected channel
1323  *
1324  * data[0]  : Digital Value Of Input
1325  * data[1]  : Calibration Offset Value
1326  * data[2]  : Calibration Gain Value
1327  * data[3]  : CJC value
1328  * data[4]  : CJC offset value
1329  * data[5]  : CJC gain value
1330  * data[6] : CJC current source from eeprom
1331  * data[7] : Channel current source from eeprom
1332  * data[8] : Channle gain factor from eeprom
1333  */
1334 static int i_APCI3200_ReadAnalogInput(struct comedi_device *dev,
1335                                       struct comedi_subdevice *s,
1336                                       struct comedi_insn *insn,
1337                                       unsigned int *data)
1338 {
1339         unsigned int ui_DummyValue = 0;
1340         int i_ConvertCJCCalibration;
1341         int i = 0;
1342
1343         /* BEGIN JK 06.07.04: Management of sevrals boards */
1344         /* if(i_Initialised==0) */
1345         if (s_BoardInfos[dev->minor].i_Initialised == 0)
1346                 /* END JK 06.07.04: Management of sevrals boards */
1347         {
1348                 i_APCI3200_Reset(dev);
1349                 return -EINVAL;
1350         }                       /* if(i_Initialised==0); */
1351
1352 #ifdef PRINT_INFO
1353         printk("\n insn->unused[0] = %i", insn->unused[0]);
1354 #endif
1355
1356         switch (insn->unused[0]) {
1357         case 0:
1358
1359                 i_APCI3200_Read1AnalogInputChannel(dev, s, insn,
1360                         &ui_DummyValue);
1361                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1362                 /* ui_InterruptChannelValue[i_Count+0]=ui_DummyValue; */
1363                 s_BoardInfos[dev->minor].
1364                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1365                         i_Count + 0] = ui_DummyValue;
1366                 /* END JK 06.07.04: Management of sevrals boards */
1367
1368                 /* Begin JK 25.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1369                 i_APCI3200_GetChannelCalibrationValue(dev,
1370                         s_BoardInfos[dev->minor].ui_Channel_num,
1371                         &s_BoardInfos[dev->minor].
1372                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1373                                 i_Count + 6],
1374                         &s_BoardInfos[dev->minor].
1375                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1376                                 i_Count + 7],
1377                         &s_BoardInfos[dev->minor].
1378                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1379                                 i_Count + 8]);
1380
1381 #ifdef PRINT_INFO
1382                 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]);
1383
1384                 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]);
1385
1386                 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]);
1387 #endif
1388
1389                 /* End JK 25.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1390
1391                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1392                 /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE) && (i_CJCAvailable==1)) */
1393                 if ((s_BoardInfos[dev->minor].i_ADDIDATAType == 2)
1394                         && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE)
1395                         && (s_BoardInfos[dev->minor].i_CJCAvailable == 1))
1396                         /* END JK 06.07.04: Management of sevrals boards */
1397                 {
1398                         i_APCI3200_ReadCJCValue(dev, &ui_DummyValue);
1399                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1400                         /* ui_InterruptChannelValue[i_Count + 3]=ui_DummyValue; */
1401                         s_BoardInfos[dev->minor].
1402                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1403                                         minor].i_Count + 3] = ui_DummyValue;
1404                         /* END JK 06.07.04: Management of sevrals boards */
1405                 }               /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)) */
1406                 else {
1407                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1408                         /* ui_InterruptChannelValue[i_Count + 3]=0; */
1409                         s_BoardInfos[dev->minor].
1410                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1411                                         minor].i_Count + 3] = 0;
1412                         /* END JK 06.07.04: Management of sevrals boards */
1413                 }               /* elseif((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE) && (i_CJCAvailable==1)) */
1414
1415                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1416                 /* if (( i_AutoCalibration == FALSE) && (i_InterruptFlag == FALSE)) */
1417                 if ((s_BoardInfos[dev->minor].i_AutoCalibration == FALSE)
1418                         && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE))
1419                         /* END JK 06.07.04: Management of sevrals boards */
1420                 {
1421                         i_APCI3200_ReadCalibrationOffsetValue(dev,
1422                                 &ui_DummyValue);
1423                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1424                         /* ui_InterruptChannelValue[i_Count + 1]=ui_DummyValue; */
1425                         s_BoardInfos[dev->minor].
1426                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1427                                         minor].i_Count + 1] = ui_DummyValue;
1428                         /* END JK 06.07.04: Management of sevrals boards */
1429                         i_APCI3200_ReadCalibrationGainValue(dev,
1430                                 &ui_DummyValue);
1431                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1432                         /* ui_InterruptChannelValue[i_Count + 2]=ui_DummyValue; */
1433                         s_BoardInfos[dev->minor].
1434                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1435                                         minor].i_Count + 2] = ui_DummyValue;
1436                         /* END JK 06.07.04: Management of sevrals boards */
1437                 }               /* if (( i_AutoCalibration == FALSE) && (i_InterruptFlag == FALSE)) */
1438
1439                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1440                 /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)&& (i_CJCAvailable==1)) */
1441                 if ((s_BoardInfos[dev->minor].i_ADDIDATAType == 2)
1442                         && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE)
1443                         && (s_BoardInfos[dev->minor].i_CJCAvailable == 1))
1444                         /* END JK 06.07.04: Management of sevrals boards */
1445                 {
1446           /**********************************************************/
1447                         /*Test if the Calibration channel must be read for the CJC */
1448           /**********************************************************/
1449           /**********************************/
1450                         /*Test if the polarity is the same */
1451           /**********************************/
1452                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1453                         /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
1454                         if (s_BoardInfos[dev->minor].i_CJCPolarity !=
1455                                 s_BoardInfos[dev->minor].i_ADDIDATAPolarity)
1456                                 /* END JK 06.07.04: Management of sevrals boards */
1457                         {
1458                                 i_ConvertCJCCalibration = 1;
1459                         }       /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
1460                         else {
1461                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1462                                 /* if(i_CJCGain==i_ADDIDATAGain) */
1463                                 if (s_BoardInfos[dev->minor].i_CJCGain ==
1464                                         s_BoardInfos[dev->minor].i_ADDIDATAGain)
1465                                         /* END JK 06.07.04: Management of sevrals boards */
1466                                 {
1467                                         i_ConvertCJCCalibration = 0;
1468                                 }       /* if(i_CJCGain==i_ADDIDATAGain) */
1469                                 else {
1470                                         i_ConvertCJCCalibration = 1;
1471                                 }       /* elseif(i_CJCGain==i_ADDIDATAGain) */
1472                         }       /* elseif(i_CJCPolarity!=i_ADDIDATAPolarity) */
1473                         if (i_ConvertCJCCalibration == 1) {
1474                                 i_APCI3200_ReadCJCCalOffset(dev,
1475                                         &ui_DummyValue);
1476                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1477                                 /* ui_InterruptChannelValue[i_Count+4]=ui_DummyValue; */
1478                                 s_BoardInfos[dev->minor].
1479                                         ui_InterruptChannelValue[s_BoardInfos
1480                                         [dev->minor].i_Count + 4] =
1481                                         ui_DummyValue;
1482                                 /* END JK 06.07.04: Management of sevrals boards */
1483
1484                                 i_APCI3200_ReadCJCCalGain(dev, &ui_DummyValue);
1485
1486                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1487                                 /* ui_InterruptChannelValue[i_Count+5]=ui_DummyValue; */
1488                                 s_BoardInfos[dev->minor].
1489                                         ui_InterruptChannelValue[s_BoardInfos
1490                                         [dev->minor].i_Count + 5] =
1491                                         ui_DummyValue;
1492                                 /* END JK 06.07.04: Management of sevrals boards */
1493                         }       /* if(i_ConvertCJCCalibration==1) */
1494                         else {
1495                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1496                                 /* ui_InterruptChannelValue[i_Count+4]=0; */
1497                                 /* ui_InterruptChannelValue[i_Count+5]=0; */
1498
1499                                 s_BoardInfos[dev->minor].
1500                                         ui_InterruptChannelValue[s_BoardInfos
1501                                         [dev->minor].i_Count + 4] = 0;
1502                                 s_BoardInfos[dev->minor].
1503                                         ui_InterruptChannelValue[s_BoardInfos
1504                                         [dev->minor].i_Count + 5] = 0;
1505                                 /* END JK 06.07.04: Management of sevrals boards */
1506                         }       /* elseif(i_ConvertCJCCalibration==1) */
1507                 }               /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)) */
1508
1509                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1510                 /* if(i_ScanType!=1) */
1511                 if (s_BoardInfos[dev->minor].i_ScanType != 1) {
1512                         /* i_Count=0; */
1513                         s_BoardInfos[dev->minor].i_Count = 0;
1514                 }               /* if(i_ScanType!=1) */
1515                 else {
1516                         /* i_Count=i_Count +6; */
1517                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1518                         /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count +6; */
1519                         s_BoardInfos[dev->minor].i_Count =
1520                                 s_BoardInfos[dev->minor].i_Count + 9;
1521                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1522                 }               /* else if(i_ScanType!=1) */
1523
1524                 /* if((i_ScanType==1) &&(i_InterruptFlag==1)) */
1525                 if ((s_BoardInfos[dev->minor].i_ScanType == 1)
1526                         && (s_BoardInfos[dev->minor].i_InterruptFlag == 1)) {
1527                         /* i_Count=i_Count-6; */
1528                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1529                         /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count-6; */
1530                         s_BoardInfos[dev->minor].i_Count =
1531                                 s_BoardInfos[dev->minor].i_Count - 9;
1532                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1533                 }
1534                 /* if(i_ScanType==0) */
1535                 if (s_BoardInfos[dev->minor].i_ScanType == 0) {
1536                         /*
1537                            data[0]= ui_InterruptChannelValue[0];
1538                            data[1]= ui_InterruptChannelValue[1];
1539                            data[2]= ui_InterruptChannelValue[2];
1540                            data[3]= ui_InterruptChannelValue[3];
1541                            data[4]= ui_InterruptChannelValue[4];
1542                            data[5]= ui_InterruptChannelValue[5];
1543                          */
1544 #ifdef PRINT_INFO
1545                         printk("\n data[0]= s_BoardInfos [dev->minor].ui_InterruptChannelValue[0];");
1546 #endif
1547                         data[0] =
1548                                 s_BoardInfos[dev->minor].
1549                                 ui_InterruptChannelValue[0];
1550                         data[1] =
1551                                 s_BoardInfos[dev->minor].
1552                                 ui_InterruptChannelValue[1];
1553                         data[2] =
1554                                 s_BoardInfos[dev->minor].
1555                                 ui_InterruptChannelValue[2];
1556                         data[3] =
1557                                 s_BoardInfos[dev->minor].
1558                                 ui_InterruptChannelValue[3];
1559                         data[4] =
1560                                 s_BoardInfos[dev->minor].
1561                                 ui_InterruptChannelValue[4];
1562                         data[5] =
1563                                 s_BoardInfos[dev->minor].
1564                                 ui_InterruptChannelValue[5];
1565
1566                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1567                         /* printk("\n 0 - i_APCI3200_GetChannelCalibrationValue data [6] = %lu, data [7] = %lu, data [8] = %lu", data [6], data [7], data [8]); */
1568                         i_APCI3200_GetChannelCalibrationValue(dev,
1569                                 s_BoardInfos[dev->minor].ui_Channel_num,
1570                                 &data[6], &data[7], &data[8]);
1571                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1572                 }
1573                 break;
1574         case 1:
1575
1576                 for (i = 0; i < insn->n; i++) {
1577                         /* data[i]=ui_InterruptChannelValue[i]; */
1578                         data[i] =
1579                                 s_BoardInfos[dev->minor].
1580                                 ui_InterruptChannelValue[i];
1581                 }
1582
1583                 /* i_Count=0; */
1584                 /* i_Sum=0; */
1585                 /* if(i_ScanType==1) */
1586                 s_BoardInfos[dev->minor].i_Count = 0;
1587                 s_BoardInfos[dev->minor].i_Sum = 0;
1588                 if (s_BoardInfos[dev->minor].i_ScanType == 1) {
1589                         /* i_Initialised=0; */
1590                         /* i_InterruptFlag=0; */
1591                         s_BoardInfos[dev->minor].i_Initialised = 0;
1592                         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1593                         /* END JK 06.07.04: Management of sevrals boards */
1594                 }
1595                 break;
1596         default:
1597                 printk("\nThe parameters passed are in error\n");
1598                 i_APCI3200_Reset(dev);
1599                 return -EINVAL;
1600         }                       /* switch(insn->unused[0]) */
1601
1602         return insn->n;
1603 }
1604
1605 /*
1606  * Configures The Analog Input Subdevice
1607  *
1608  * data[0]  = 0  Normal AI
1609  *          = 1  RTD
1610  *          = 2  THERMOCOUPLE
1611  * data[1]  = Gain To Use
1612  * data[2]  = 0  Bipolar
1613  *          = 1  Unipolar
1614  * data[3]  = Offset Range
1615  * data[4]  = 0  DC Coupling
1616  *          = 1  AC Coupling
1617  * data[5]  = 0  Single
1618  *          = 1  Differential
1619  * data[6]  = TimerReloadValue
1620  * data[7]  = ConvertingTimeUnit
1621  * data[8]  = 0  Analog voltage measurement
1622  *          = 1  Resistance measurement
1623  *          = 2  Temperature measurement
1624  * data[9]  = 0  Interrupt Disable
1625  *          = 1  INterrupt Enable
1626  * data[10] = Type of Thermocouple
1627  * data[11] = single channel Module Number
1628  * data[12] = 0  Single Read
1629  *          = 1  Read more channel
1630  *          = 2  Single scan
1631  *          = 3  Continuous Scan
1632  * data[13] = Number of channels to read
1633  * data[14] = 0  RTD not used
1634  *          = 1  RTD 2 wire connection
1635  *          = 2  RTD 3 wire connection
1636  *          = 3  RTD 4 wire connection
1637  */
1638 static int i_APCI3200_ConfigAnalogInput(struct comedi_device *dev,
1639                                         struct comedi_subdevice *s,
1640                                         struct comedi_insn *insn,
1641                                         unsigned int *data)
1642 {
1643         struct addi_private *devpriv = dev->private;
1644         unsigned int ul_Config = 0, ul_Temp = 0;
1645         unsigned int ui_ChannelNo = 0;
1646         unsigned int ui_Dummy = 0;
1647         int i_err = 0;
1648
1649         /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1650
1651 #ifdef PRINT_INFO
1652         int i = 0, i2 = 0;
1653 #endif
1654         /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1655
1656         /* BEGIN JK 06.07.04: Management of sevrals boards */
1657         /*  Initialize the structure */
1658         if (s_BoardInfos[dev->minor].b_StructInitialized != 1) {
1659                 s_BoardInfos[dev->minor].i_CJCAvailable = 1;
1660                 s_BoardInfos[dev->minor].i_CJCPolarity = 0;
1661                 s_BoardInfos[dev->minor].i_CJCGain = 2; /* changed from 0 to 2 */
1662                 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1663                 s_BoardInfos[dev->minor].i_AutoCalibration = 0; /* : auto calibration */
1664                 s_BoardInfos[dev->minor].i_ChannelCount = 0;
1665                 s_BoardInfos[dev->minor].i_Sum = 0;
1666                 s_BoardInfos[dev->minor].ui_Channel_num = 0;
1667                 s_BoardInfos[dev->minor].i_Count = 0;
1668                 s_BoardInfos[dev->minor].i_Initialised = 0;
1669                 s_BoardInfos[dev->minor].b_StructInitialized = 1;
1670
1671                 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1672                 s_BoardInfos[dev->minor].i_ConnectionType = 0;
1673                 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1674
1675                 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1676                 memset(s_BoardInfos[dev->minor].s_Module, 0,
1677                         sizeof(s_BoardInfos[dev->minor].s_Module[MAX_MODULE]));
1678
1679                 v_GetAPCI3200EepromCalibrationValue(devpriv->i_IobaseAmcc,
1680                         &s_BoardInfos[dev->minor]);
1681
1682 #ifdef PRINT_INFO
1683                 for (i = 0; i < MAX_MODULE; i++) {
1684                         printk("\n s_Module[%i].ul_CurrentSourceCJC = %lu", i,
1685                                 s_BoardInfos[dev->minor].s_Module[i].
1686                                 ul_CurrentSourceCJC);
1687
1688                         for (i2 = 0; i2 < 5; i2++) {
1689                                 printk("\n s_Module[%i].ul_CurrentSource [%i] = %lu", i, i2, s_BoardInfos[dev->minor].s_Module[i].ul_CurrentSource[i2]);
1690                         }
1691
1692                         for (i2 = 0; i2 < 8; i2++) {
1693                                 printk("\n s_Module[%i].ul_GainFactor [%i] = %lu", i, i2, s_BoardInfos[dev->minor].s_Module[i].ul_GainFactor[i2]);
1694                         }
1695
1696                         for (i2 = 0; i2 < 8; i2++) {
1697                                 printk("\n s_Module[%i].w_GainValue [%i] = %u",
1698                                         i, i2,
1699                                         s_BoardInfos[dev->minor].s_Module[i].
1700                                         w_GainValue[i2]);
1701                         }
1702                 }
1703 #endif
1704                 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1705         }
1706
1707         if (data[0] != 0 && data[0] != 1 && data[0] != 2) {
1708                 printk("\nThe selection of acquisition type is in error\n");
1709                 i_err++;
1710         }                       /* if(data[0]!=0 && data[0]!=1 && data[0]!=2) */
1711         if (data[0] == 1) {
1712                 if (data[14] != 0 && data[14] != 1 && data[14] != 2
1713                         && data[14] != 4) {
1714                         printk("\n Error in selection of RTD connection type\n");
1715                         i_err++;
1716                 }               /* if(data[14]!=0 && data[14]!=1 && data[14]!=2 && data[14]!=4) */
1717         }                       /* if(data[0]==1 ) */
1718         if (data[1] < 0 || data[1] > 7) {
1719                 printk("\nThe selection of gain is in error\n");
1720                 i_err++;
1721         }                       /*  if(data[1]<0 || data[1]>7) */
1722         if (data[2] != 0 && data[2] != 1) {
1723                 printk("\nThe selection of polarity is in error\n");
1724                 i_err++;
1725         }                       /* if(data[2]!=0 &&  data[2]!=1) */
1726         if (data[3] != 0) {
1727                 printk("\nThe selection of offset range  is in error\n");
1728                 i_err++;
1729         }                       /*  if(data[3]!=0) */
1730         if (data[4] != 0 && data[4] != 1) {
1731                 printk("\nThe selection of coupling is in error\n");
1732                 i_err++;
1733         }                       /* if(data[4]!=0 &&  data[4]!=1) */
1734         if (data[5] != 0 && data[5] != 1) {
1735                 printk("\nThe selection of single/differential mode is in error\n");
1736                 i_err++;
1737         }                       /* if(data[5]!=0 &&  data[5]!=1) */
1738         if (data[8] != 0 && data[8] != 1 && data[2] != 2) {
1739                 printk("\nError in selection of functionality\n");
1740         }                       /* if(data[8]!=0 && data[8]!=1 && data[2]!=2) */
1741         if (data[12] == 0 || data[12] == 1) {
1742                 if (data[6] != 20 && data[6] != 40 && data[6] != 80
1743                         && data[6] != 160) {
1744                         printk("\nThe selection of conversion time reload value is in error\n");
1745                         i_err++;
1746                 }               /*  if (data[6]!=20 && data[6]!=40 && data[6]!=80 && data[6]!=160 ) */
1747                 if (data[7] != 2) {
1748                         printk("\nThe selection of conversion time unit  is in error\n");
1749                         i_err++;
1750                 }               /*  if(data[7]!=2) */
1751         }
1752         if (data[9] != 0 && data[9] != 1) {
1753                 printk("\nThe selection of interrupt enable is in error\n");
1754                 i_err++;
1755         }                       /* if(data[9]!=0 &&  data[9]!=1) */
1756         if (data[11] < 0 || data[11] > 4) {
1757                 printk("\nThe selection of module is in error\n");
1758                 i_err++;
1759         }                       /* if(data[11] <0 ||  data[11]>1) */
1760         if (data[12] < 0 || data[12] > 3) {
1761                 printk("\nThe selection of singlechannel/scan selection is in error\n");
1762                 i_err++;
1763         }                       /* if(data[12] < 0 ||  data[12]> 3) */
1764         if (data[13] < 0 || data[13] > 16) {
1765                 printk("\nThe selection of number of channels is in error\n");
1766                 i_err++;
1767         }                       /*  if(data[13] <0 ||data[13] >15) */
1768
1769         /* BEGIN JK 06.07.04: Management of sevrals boards */
1770         /*
1771            i_ChannelCount=data[13];
1772            i_ScanType=data[12];
1773            i_ADDIDATAPolarity = data[2];
1774            i_ADDIDATAGain=data[1];
1775            i_ADDIDATAConversionTime=data[6];
1776            i_ADDIDATAConversionTimeUnit=data[7];
1777            i_ADDIDATAType=data[0];
1778          */
1779
1780         /*  Save acquisition configuration for the actual board */
1781         s_BoardInfos[dev->minor].i_ChannelCount = data[13];
1782         s_BoardInfos[dev->minor].i_ScanType = data[12];
1783         s_BoardInfos[dev->minor].i_ADDIDATAPolarity = data[2];
1784         s_BoardInfos[dev->minor].i_ADDIDATAGain = data[1];
1785         s_BoardInfos[dev->minor].i_ADDIDATAConversionTime = data[6];
1786         s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit = data[7];
1787         s_BoardInfos[dev->minor].i_ADDIDATAType = data[0];
1788         /* Begin JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1789         s_BoardInfos[dev->minor].i_ConnectionType = data[5];
1790         /* End JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1791         /* END JK 06.07.04: Management of sevrals boards */
1792
1793         /* Begin JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1794         memset(s_BoardInfos[dev->minor].ui_ScanValueArray, 0, (7 + 12) * sizeof(unsigned int)); /*  7 is the maximal number of channels */
1795         /* End JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1796
1797         /* BEGIN JK 02.07.04 : This while can't be do, it block the process when using severals boards */
1798         /* while(i_InterruptFlag==1) */
1799         while (s_BoardInfos[dev->minor].i_InterruptFlag == 1) {
1800 #ifndef MSXBOX
1801                 udelay(1);
1802 #else
1803                 /*  In the case where the driver is compiled for the MSX-Box */
1804                 /*  we used a printk to have a little delay because udelay */
1805                 /*  seems to be broken under the MSX-Box. */
1806                 /*  This solution hat to be studied. */
1807                 printk("");
1808 #endif
1809         }
1810         /* END JK 02.07.04 : This while can't be do, it block the process when using severals boards */
1811
1812         ui_ChannelNo = CR_CHAN(insn->chanspec); /*  get the channel */
1813         /* BEGIN JK 06.07.04: Management of sevrals boards */
1814         /* i_ChannelNo=ui_ChannelNo; */
1815         /* ui_Channel_num =ui_ChannelNo; */
1816
1817         s_BoardInfos[dev->minor].i_ChannelNo = ui_ChannelNo;
1818         s_BoardInfos[dev->minor].ui_Channel_num = ui_ChannelNo;
1819
1820         /* END JK 06.07.04: Management of sevrals boards */
1821
1822         if (data[5] == 0) {
1823                 if (ui_ChannelNo < 0 || ui_ChannelNo > 15) {
1824                         printk("\nThe Selection of the channel is in error\n");
1825                         i_err++;
1826                 }               /*  if(ui_ChannelNo<0 || ui_ChannelNo>15) */
1827         }                       /* if(data[5]==0) */
1828         else {
1829                 if (data[14] == 2) {
1830                         if (ui_ChannelNo < 0 || ui_ChannelNo > 3) {
1831                                 printk("\nThe Selection of the channel is in error\n");
1832                                 i_err++;
1833                         }       /*  if(ui_ChannelNo<0 || ui_ChannelNo>3) */
1834                 }               /* if(data[14]==2) */
1835                 else {
1836                         if (ui_ChannelNo < 0 || ui_ChannelNo > 7) {
1837                                 printk("\nThe Selection of the channel is in error\n");
1838                                 i_err++;
1839                         }       /*  if(ui_ChannelNo<0 || ui_ChannelNo>7) */
1840                 }               /* elseif(data[14]==2) */
1841         }                       /* elseif(data[5]==0) */
1842         if (data[12] == 0 || data[12] == 1) {
1843                 switch (data[5]) {
1844                 case 0:
1845                         if (ui_ChannelNo >= 0 && ui_ChannelNo <= 3) {
1846                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1847                                 /* i_Offset=0; */
1848                                 s_BoardInfos[dev->minor].i_Offset = 0;
1849                                 /* END JK 06.07.04: Management of sevrals boards */
1850                         }       /* if(ui_ChannelNo >=0 && ui_ChannelNo <=3) */
1851                         if (ui_ChannelNo >= 4 && ui_ChannelNo <= 7) {
1852                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1853                                 /* i_Offset=64; */
1854                                 s_BoardInfos[dev->minor].i_Offset = 64;
1855                                 /* END JK 06.07.04: Management of sevrals boards */
1856                         }       /* if(ui_ChannelNo >=4 && ui_ChannelNo <=7) */
1857                         if (ui_ChannelNo >= 8 && ui_ChannelNo <= 11) {
1858                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1859                                 /* i_Offset=128; */
1860                                 s_BoardInfos[dev->minor].i_Offset = 128;
1861                                 /* END JK 06.07.04: Management of sevrals boards */
1862                         }       /* if(ui_ChannelNo >=8 && ui_ChannelNo <=11) */
1863                         if (ui_ChannelNo >= 12 && ui_ChannelNo <= 15) {
1864                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1865                                 /* i_Offset=192; */
1866                                 s_BoardInfos[dev->minor].i_Offset = 192;
1867                                 /* END JK 06.07.04: Management of sevrals boards */
1868                         }       /* if(ui_ChannelNo >=12 && ui_ChannelNo <=15) */
1869                         break;
1870                 case 1:
1871                         if (data[14] == 2) {
1872                                 if (ui_ChannelNo == 0) {
1873                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1874                                         /* i_Offset=0; */
1875                                         s_BoardInfos[dev->minor].i_Offset = 0;
1876                                         /* END JK 06.07.04: Management of sevrals boards */
1877                                 }       /* if(ui_ChannelNo ==0 ) */
1878                                 if (ui_ChannelNo == 1) {
1879                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1880                                         /* i_Offset=0; */
1881                                         s_BoardInfos[dev->minor].i_Offset = 64;
1882                                         /* END JK 06.07.04: Management of sevrals boards */
1883                                 }       /*  if(ui_ChannelNo ==1) */
1884                                 if (ui_ChannelNo == 2) {
1885                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1886                                         /* i_Offset=128; */
1887                                         s_BoardInfos[dev->minor].i_Offset = 128;
1888                                         /* END JK 06.07.04: Management of sevrals boards */
1889                                 }       /* if(ui_ChannelNo ==2 ) */
1890                                 if (ui_ChannelNo == 3) {
1891                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1892                                         /* i_Offset=192; */
1893                                         s_BoardInfos[dev->minor].i_Offset = 192;
1894                                         /* END JK 06.07.04: Management of sevrals boards */
1895                                 }       /* if(ui_ChannelNo ==3) */
1896
1897                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1898                                 /* i_ChannelNo=0; */
1899                                 s_BoardInfos[dev->minor].i_ChannelNo = 0;
1900                                 /* END JK 06.07.04: Management of sevrals boards */
1901                                 ui_ChannelNo = 0;
1902                                 break;
1903                         }       /* if(data[14]==2) */
1904                         if (ui_ChannelNo >= 0 && ui_ChannelNo <= 1) {
1905                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1906                                 /* i_Offset=0; */
1907                                 s_BoardInfos[dev->minor].i_Offset = 0;
1908                                 /* END JK 06.07.04: Management of sevrals boards */
1909                         }       /* if(ui_ChannelNo >=0 && ui_ChannelNo <=1) */
1910                         if (ui_ChannelNo >= 2 && ui_ChannelNo <= 3) {
1911                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1912                                 /* i_ChannelNo=i_ChannelNo-2; */
1913                                 /* i_Offset=64; */
1914                                 s_BoardInfos[dev->minor].i_ChannelNo =
1915                                         s_BoardInfos[dev->minor].i_ChannelNo -
1916                                         2;
1917                                 s_BoardInfos[dev->minor].i_Offset = 64;
1918                                 /* END JK 06.07.04: Management of sevrals boards */
1919                                 ui_ChannelNo = ui_ChannelNo - 2;
1920                         }       /* if(ui_ChannelNo >=2 && ui_ChannelNo <=3) */
1921                         if (ui_ChannelNo >= 4 && ui_ChannelNo <= 5) {
1922                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1923                                 /* i_ChannelNo=i_ChannelNo-4; */
1924                                 /* i_Offset=128; */
1925                                 s_BoardInfos[dev->minor].i_ChannelNo =
1926                                         s_BoardInfos[dev->minor].i_ChannelNo -
1927                                         4;
1928                                 s_BoardInfos[dev->minor].i_Offset = 128;
1929                                 /* END JK 06.07.04: Management of sevrals boards */
1930                                 ui_ChannelNo = ui_ChannelNo - 4;
1931                         }       /* if(ui_ChannelNo >=4 && ui_ChannelNo <=5) */
1932                         if (ui_ChannelNo >= 6 && ui_ChannelNo <= 7) {
1933                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1934                                 /* i_ChannelNo=i_ChannelNo-6; */
1935                                 /* i_Offset=192; */
1936                                 s_BoardInfos[dev->minor].i_ChannelNo =
1937                                         s_BoardInfos[dev->minor].i_ChannelNo -
1938                                         6;
1939                                 s_BoardInfos[dev->minor].i_Offset = 192;
1940                                 /* END JK 06.07.04: Management of sevrals boards */
1941                                 ui_ChannelNo = ui_ChannelNo - 6;
1942                         }       /* if(ui_ChannelNo >=6 && ui_ChannelNo <=7) */
1943                         break;
1944
1945                 default:
1946                         printk("\n This selection of polarity does not exist\n");
1947                         i_err++;
1948                 }               /* switch(data[2]) */
1949         }                       /* if(data[12]==0 || data[12]==1) */
1950         else {
1951                 switch (data[11]) {
1952                 case 1:
1953                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1954                         /* i_Offset=0; */
1955                         s_BoardInfos[dev->minor].i_Offset = 0;
1956                         /* END JK 06.07.04: Management of sevrals boards */
1957                         break;
1958                 case 2:
1959                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1960                         /* i_Offset=64; */
1961                         s_BoardInfos[dev->minor].i_Offset = 64;
1962                         /* END JK 06.07.04: Management of sevrals boards */
1963                         break;
1964                 case 3:
1965                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1966                         /* i_Offset=128; */
1967                         s_BoardInfos[dev->minor].i_Offset = 128;
1968                         /* END JK 06.07.04: Management of sevrals boards */
1969                         break;
1970                 case 4:
1971                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1972                         /* i_Offset=192; */
1973                         s_BoardInfos[dev->minor].i_Offset = 192;
1974                         /* END JK 06.07.04: Management of sevrals boards */
1975                         break;
1976                 default:
1977                         printk("\nError in module selection\n");
1978                         i_err++;
1979                 }               /*  switch(data[11]) */
1980         }                       /*  elseif(data[12]==0 || data[12]==1) */
1981         if (i_err) {
1982                 i_APCI3200_Reset(dev);
1983                 return -EINVAL;
1984         }
1985         /* if(i_ScanType!=1) */
1986         if (s_BoardInfos[dev->minor].i_ScanType != 1) {
1987                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1988                 /* i_Count=0; */
1989                 /* i_Sum=0; */
1990                 s_BoardInfos[dev->minor].i_Count = 0;
1991                 s_BoardInfos[dev->minor].i_Sum = 0;
1992                 /* END JK 06.07.04: Management of sevrals boards */
1993         }                       /* if(i_ScanType!=1) */
1994
1995         ul_Config =
1996                 data[1] | (data[2] << 6) | (data[5] << 7) | (data[3] << 8) |
1997                 (data[4] << 9);
1998         /* BEGIN JK 06.07.04: Management of sevrals boards */
1999         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2000         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2001                                         12) >> 19) & 1) != 1) ;
2002         /* END JK 06.07.04: Management of sevrals boards */
2003   /*********************************/
2004         /* Write the channel to configure */
2005   /*********************************/
2006         /* BEGIN JK 06.07.04: Management of sevrals boards */
2007         /* outl(0 | ui_ChannelNo , devpriv->iobase+i_Offset + 0x4); */
2008         outl(0 | ui_ChannelNo,
2009                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x4);
2010         /* END JK 06.07.04: Management of sevrals boards */
2011
2012         /* BEGIN JK 06.07.04: Management of sevrals boards */
2013         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2014         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2015                                         12) >> 19) & 1) != 1) ;
2016         /* END JK 06.07.04: Management of sevrals boards */
2017   /**************************/
2018         /* Reset the configuration */
2019   /**************************/
2020         /* BEGIN JK 06.07.04: Management of sevrals boards */
2021         /* outl(0 , devpriv->iobase+i_Offset + 0x0); */
2022         outl(0, devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x0);
2023         /* END JK 06.07.04: Management of sevrals boards */
2024
2025         /* BEGIN JK 06.07.04: Management of sevrals boards */
2026         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2027         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2028                                         12) >> 19) & 1) != 1) ;
2029         /* END JK 06.07.04: Management of sevrals boards */
2030
2031   /***************************/
2032         /* Write the configuration */
2033   /***************************/
2034         /* BEGIN JK 06.07.04: Management of sevrals boards */
2035         /* outl(ul_Config , devpriv->iobase+i_Offset + 0x0); */
2036         outl(ul_Config,
2037                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x0);
2038         /* END JK 06.07.04: Management of sevrals boards */
2039
2040   /***************************/
2041         /*Reset the calibration bit */
2042   /***************************/
2043         /* BEGIN JK 06.07.04: Management of sevrals boards */
2044         /* ul_Temp = inl(devpriv->iobase+i_Offset + 12); */
2045         ul_Temp = inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2046         /* END JK 06.07.04: Management of sevrals boards */
2047
2048         /* BEGIN JK 06.07.04: Management of sevrals boards */
2049         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2050         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2051                                         12) >> 19) & 1) != 1) ;
2052         /* END JK 06.07.04: Management of sevrals boards */
2053
2054         /* BEGIN JK 06.07.04: Management of sevrals boards */
2055         /* outl((ul_Temp & 0xFFF9FFFF) , devpriv->iobase+.i_Offset + 12); */
2056         outl((ul_Temp & 0xFFF9FFFF),
2057                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2058         /* END JK 06.07.04: Management of sevrals boards */
2059
2060         if (data[9] == 1) {
2061                 devpriv->tsk_Current = current;
2062                 /* BEGIN JK 06.07.04: Management of sevrals boards */
2063                 /* i_InterruptFlag=1; */
2064                 s_BoardInfos[dev->minor].i_InterruptFlag = 1;
2065                 /* END JK 06.07.04: Management of sevrals boards */
2066         }                       /*  if(data[9]==1) */
2067         else {
2068                 /* BEGIN JK 06.07.04: Management of sevrals boards */
2069                 /* i_InterruptFlag=0; */
2070                 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2071                 /* END JK 06.07.04: Management of sevrals boards */
2072         }                       /* else  if(data[9]==1) */
2073
2074         /* BEGIN JK 06.07.04: Management of sevrals boards */
2075         /* i_Initialised=1; */
2076         s_BoardInfos[dev->minor].i_Initialised = 1;
2077         /* END JK 06.07.04: Management of sevrals boards */
2078
2079         /* BEGIN JK 06.07.04: Management of sevrals boards */
2080         /* if(i_ScanType==1) */
2081         if (s_BoardInfos[dev->minor].i_ScanType == 1)
2082                 /* END JK 06.07.04: Management of sevrals boards */
2083         {
2084                 /* BEGIN JK 06.07.04: Management of sevrals boards */
2085                 /* i_Sum=i_Sum+1; */
2086                 s_BoardInfos[dev->minor].i_Sum =
2087                         s_BoardInfos[dev->minor].i_Sum + 1;
2088                 /* END JK 06.07.04: Management of sevrals boards */
2089
2090                 insn->unused[0] = 0;
2091                 i_APCI3200_ReadAnalogInput(dev, s, insn, &ui_Dummy);
2092         }
2093
2094         return insn->n;
2095 }
2096
2097 /*
2098  * Tests the Selected Anlog Input Channel
2099  *
2100  * data[0] = 0  TestAnalogInputShortCircuit
2101  *         = 1  TestAnalogInputConnection
2102  *
2103  * data[0] : Digital value obtained
2104  * data[1] : calibration offset
2105  * data[2] : calibration gain
2106  */
2107 static int i_APCI3200_InsnBits_AnalogInput_Test(struct comedi_device *dev,
2108                                                 struct comedi_subdevice *s,
2109                                                 struct comedi_insn *insn,
2110                                                 unsigned int *data)
2111 {
2112         struct addi_private *devpriv = dev->private;
2113         unsigned int ui_Configuration = 0;
2114         int i_Temp;             /* ,i_TimeUnit; */
2115
2116         /* if(i_Initialised==0) */
2117
2118         if (s_BoardInfos[dev->minor].i_Initialised == 0) {
2119                 i_APCI3200_Reset(dev);
2120                 return -EINVAL;
2121         }                       /* if(i_Initialised==0); */
2122         if (data[0] != 0 && data[0] != 1) {
2123                 printk("\nError in selection of functionality\n");
2124                 i_APCI3200_Reset(dev);
2125                 return -EINVAL;
2126         }                       /* if(data[0]!=0 && data[0]!=1) */
2127
2128         if (data[0] == 1)       /* Perform Short Circuit TEST */
2129         {
2130       /**************************/
2131                 /*Set the short-cicuit bit */
2132       /**************************/
2133                 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2134                 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2135                                                 i_Offset + 12) >> 19) & 1) !=
2136                         1) ;
2137                 /* outl((0x00001000 |i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2138                 outl((0x00001000 | s_BoardInfos[dev->minor].i_ChannelNo),
2139                         devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2140                         4);
2141       /*************************/
2142                 /*Set the time unit to ns */
2143       /*************************/
2144                 /* i_TimeUnit= i_ADDIDATAConversionTimeUnit;
2145                    i_ADDIDATAConversionTimeUnit= 1; */
2146                 /* i_Temp= i_InterruptFlag ; */
2147                 i_Temp = s_BoardInfos[dev->minor].i_InterruptFlag;
2148                 /* i_InterruptFlag = ADDIDATA_DISABLE; */
2149                 s_BoardInfos[dev->minor].i_InterruptFlag = ADDIDATA_DISABLE;
2150                 i_APCI3200_Read1AnalogInputChannel(dev, s, insn, data);
2151                 /* if(i_AutoCalibration == FALSE) */
2152                 if (s_BoardInfos[dev->minor].i_AutoCalibration == FALSE) {
2153                         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2154                         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2155                                                         i_Offset +
2156                                                         12) >> 19) & 1) != 1) ;
2157
2158                         /* outl((0x00001000 |i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2159                         outl((0x00001000 | s_BoardInfos[dev->minor].
2160                                         i_ChannelNo),
2161                                 devpriv->iobase +
2162                                 s_BoardInfos[dev->minor].i_Offset + 4);
2163                         data++;
2164                         i_APCI3200_ReadCalibrationOffsetValue(dev, data);
2165                         data++;
2166                         i_APCI3200_ReadCalibrationGainValue(dev, data);
2167                 }
2168         } else {
2169                 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2170                 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2171                                                 i_Offset + 12) >> 19) & 1) !=
2172                         1) ;
2173                 /* outl((0x00000800|i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2174                 outl((0x00000800 | s_BoardInfos[dev->minor].i_ChannelNo),
2175                         devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2176                         4);
2177                 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 0); */
2178                 ui_Configuration =
2179                         inl(devpriv->iobase +
2180                         s_BoardInfos[dev->minor].i_Offset + 0);
2181       /*************************/
2182                 /*Set the time unit to ns */
2183       /*************************/
2184                 /* i_TimeUnit= i_ADDIDATAConversionTimeUnit;
2185                    i_ADDIDATAConversionTimeUnit= 1; */
2186                 /* i_Temp= i_InterruptFlag ; */
2187                 i_Temp = s_BoardInfos[dev->minor].i_InterruptFlag;
2188                 /* i_InterruptFlag = ADDIDATA_DISABLE; */
2189                 s_BoardInfos[dev->minor].i_InterruptFlag = ADDIDATA_DISABLE;
2190                 i_APCI3200_Read1AnalogInputChannel(dev, s, insn, data);
2191                 /* if(i_AutoCalibration == FALSE) */
2192                 if (s_BoardInfos[dev->minor].i_AutoCalibration == FALSE) {
2193                         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2194                         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2195                                                         i_Offset +
2196                                                         12) >> 19) & 1) != 1) ;
2197                         /* outl((0x00000800|i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2198                         outl((0x00000800 | s_BoardInfos[dev->minor].
2199                                         i_ChannelNo),
2200                                 devpriv->iobase +
2201                                 s_BoardInfos[dev->minor].i_Offset + 4);
2202                         data++;
2203                         i_APCI3200_ReadCalibrationOffsetValue(dev, data);
2204                         data++;
2205                         i_APCI3200_ReadCalibrationGainValue(dev, data);
2206                 }
2207         }
2208         /* i_InterruptFlag=i_Temp ; */
2209         s_BoardInfos[dev->minor].i_InterruptFlag = i_Temp;
2210         /* printk("\ni_InterruptFlag=%d\n",i_InterruptFlag); */
2211         return insn->n;
2212 }
2213
2214 static int i_APCI3200_InsnWriteReleaseAnalogInput(struct comedi_device *dev,
2215                                                   struct comedi_subdevice *s,
2216                                                   struct comedi_insn *insn,
2217                                                   unsigned int *data)
2218 {
2219         i_APCI3200_Reset(dev);
2220         return insn->n;
2221 }
2222
2223 static int i_APCI3200_CommandTestAnalogInput(struct comedi_device *dev,
2224                                              struct comedi_subdevice *s,
2225                                              struct comedi_cmd *cmd)
2226 {
2227
2228         int err = 0;
2229         unsigned int ui_ConvertTime = 0;
2230         unsigned int ui_ConvertTimeBase = 0;
2231         unsigned int ui_DelayTime = 0;
2232         unsigned int ui_DelayTimeBase = 0;
2233         int i_Triggermode = 0;
2234         int i_TriggerEdge = 0;
2235         int i_NbrOfChannel = 0;
2236         int i_Cpt = 0;
2237         double d_ConversionTimeForAllChannels = 0.0;
2238         double d_SCANTimeNewUnit = 0.0;
2239
2240         /* Step 1 : check if triggers are trivially valid */
2241
2242         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
2243         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
2244                                         TRIG_TIMER | TRIG_FOLLOW);
2245         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
2246         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
2247         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
2248
2249         if (s_BoardInfos[dev->minor].i_InterruptFlag == 0)
2250                 err |= -EINVAL;
2251
2252         if (err) {
2253                 i_APCI3200_Reset(dev);
2254                 return 1;
2255         }
2256
2257         /* Step 2a : make sure trigger sources are unique */
2258
2259         err |= cfc_check_trigger_is_unique(&cmd->start_src);
2260         err |= cfc_check_trigger_is_unique(&cmd->scan_begin_src);
2261         err |= cfc_check_trigger_is_unique(&cmd->stop_src);
2262
2263         /* Step 2b : and mutually compatible */
2264
2265         if (cmd->start_src == TRIG_EXT) {
2266                 i_TriggerEdge = cmd->start_arg & 0xFFFF;
2267                 i_Triggermode = cmd->start_arg >> 16;
2268                 if (i_TriggerEdge < 1 || i_TriggerEdge > 3) {
2269                         err++;
2270                         printk("\nThe trigger edge selection is in error\n");
2271                 }
2272                 if (i_Triggermode != 2) {
2273                         err++;
2274                         printk("\nThe trigger mode selection is in error\n");
2275                 }
2276         }
2277
2278         if (err) {
2279                 i_APCI3200_Reset(dev);
2280                 return 2;
2281         }
2282         /* i_FirstChannel=cmd->chanlist[0]; */
2283         s_BoardInfos[dev->minor].i_FirstChannel = cmd->chanlist[0];
2284         /* i_LastChannel=cmd->chanlist[1]; */
2285         s_BoardInfos[dev->minor].i_LastChannel = cmd->chanlist[1];
2286
2287         if (cmd->convert_src == TRIG_TIMER) {
2288                 ui_ConvertTime = cmd->convert_arg & 0xFFFF;
2289                 ui_ConvertTimeBase = cmd->convert_arg >> 16;
2290                 if (ui_ConvertTime != 20 && ui_ConvertTime != 40
2291                         && ui_ConvertTime != 80 && ui_ConvertTime != 160)
2292                 {
2293                         printk("\nThe selection of conversion time reload value is in error\n");
2294                         err++;
2295                 }               /*  if (ui_ConvertTime!=20 && ui_ConvertTime!=40 && ui_ConvertTime!=80 && ui_ConvertTime!=160 ) */
2296                 if (ui_ConvertTimeBase != 2) {
2297                         printk("\nThe selection of conversion time unit  is in error\n");
2298                         err++;
2299                 }               /* if(ui_ConvertTimeBase!=2) */
2300         } else {
2301                 ui_ConvertTime = 0;
2302                 ui_ConvertTimeBase = 0;
2303         }
2304         if (cmd->scan_begin_src == TRIG_FOLLOW) {
2305                 ui_DelayTime = 0;
2306                 ui_DelayTimeBase = 0;
2307         }                       /* if(cmd->scan_begin_src==TRIG_FOLLOW) */
2308         else {
2309                 ui_DelayTime = cmd->scan_begin_arg & 0xFFFF;
2310                 ui_DelayTimeBase = cmd->scan_begin_arg >> 16;
2311                 if (ui_DelayTimeBase != 2 && ui_DelayTimeBase != 3) {
2312                         err++;
2313                         printk("\nThe Delay time base selection is in error\n");
2314                 }
2315                 if (ui_DelayTime < 1 || ui_DelayTime > 1023) {
2316                         err++;
2317                         printk("\nThe Delay time value is in error\n");
2318                 }
2319                 if (err) {
2320                         i_APCI3200_Reset(dev);
2321                         return 3;
2322                 }
2323                 fpu_begin();
2324                 d_SCANTimeNewUnit = (double)ui_DelayTime;
2325                 /* i_NbrOfChannel= i_LastChannel-i_FirstChannel + 4; */
2326                 i_NbrOfChannel =
2327                         s_BoardInfos[dev->minor].i_LastChannel -
2328                         s_BoardInfos[dev->minor].i_FirstChannel + 4;
2329       /**********************************************************/
2330                 /*calculate the total conversion time for all the channels */
2331       /**********************************************************/
2332                 d_ConversionTimeForAllChannels =
2333                         (double)((double)ui_ConvertTime /
2334                         (double)i_NbrOfChannel);
2335
2336       /*******************************/
2337                 /*Convert the frequence in time */
2338       /*******************************/
2339                 d_ConversionTimeForAllChannels =
2340                         (double)1.0 / d_ConversionTimeForAllChannels;
2341                 ui_ConvertTimeBase = 3;
2342       /***********************************/
2343                 /*Test if the time unit is the same */
2344       /***********************************/
2345
2346                 if (ui_DelayTimeBase <= ui_ConvertTimeBase) {
2347
2348                         for (i_Cpt = 0;
2349                                 i_Cpt < (ui_ConvertTimeBase - ui_DelayTimeBase);
2350                                 i_Cpt++) {
2351
2352                                 d_ConversionTimeForAllChannels =
2353                                         d_ConversionTimeForAllChannels * 1000;
2354                                 d_ConversionTimeForAllChannels =
2355                                         d_ConversionTimeForAllChannels + 1;
2356                         }
2357                 } else {
2358                         for (i_Cpt = 0;
2359                                 i_Cpt < (ui_DelayTimeBase - ui_ConvertTimeBase);
2360                                 i_Cpt++) {
2361                                 d_SCANTimeNewUnit = d_SCANTimeNewUnit * 1000;
2362
2363                         }
2364                 }
2365
2366                 if (d_ConversionTimeForAllChannels >= d_SCANTimeNewUnit) {
2367
2368                         printk("\nSCAN Delay value cannot be used\n");
2369           /*********************************/
2370                         /*SCAN Delay value cannot be used */
2371           /*********************************/
2372                         err++;
2373                 }
2374                 fpu_end();
2375         }                       /* else if(cmd->scan_begin_src==TRIG_FOLLOW) */
2376
2377         if (err) {
2378                 i_APCI3200_Reset(dev);
2379                 return 4;
2380         }
2381
2382         return 0;
2383 }
2384
2385 static int i_APCI3200_StopCyclicAcquisition(struct comedi_device *dev,
2386                                             struct comedi_subdevice *s)
2387 {
2388         struct addi_private *devpriv = dev->private;
2389         unsigned int ui_Configuration = 0;
2390
2391         /* i_InterruptFlag=0; */
2392         /* i_Initialised=0; */
2393         /* i_Count=0; */
2394         /* i_Sum=0; */
2395         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2396         s_BoardInfos[dev->minor].i_Initialised = 0;
2397         s_BoardInfos[dev->minor].i_Count = 0;
2398         s_BoardInfos[dev->minor].i_Sum = 0;
2399
2400   /*******************/
2401         /*Read the register */
2402   /*******************/
2403         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 8); */
2404         ui_Configuration =
2405                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2406   /*****************************/
2407         /*Reset the START and IRQ bit */
2408   /*****************************/
2409         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2410         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2411                                         12) >> 19) & 1) != 1) ;
2412         /* outl((ui_Configuration & 0xFFE7FFFF),devpriv->iobase+i_Offset + 8); */
2413         outl((ui_Configuration & 0xFFE7FFFF),
2414                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2415         return 0;
2416 }
2417
2418 /*
2419  * Does asynchronous acquisition
2420  * Determines the mode 1 or 2.
2421  */
2422 static int i_APCI3200_CommandAnalogInput(struct comedi_device *dev,
2423                                          struct comedi_subdevice *s)
2424 {
2425         struct addi_private *devpriv = dev->private;
2426         struct comedi_cmd *cmd = &s->async->cmd;
2427         unsigned int ui_Configuration = 0;
2428         /* INT  i_CurrentSource = 0; */
2429         unsigned int ui_Trigger = 0;
2430         unsigned int ui_TriggerEdge = 0;
2431         unsigned int ui_Triggermode = 0;
2432         unsigned int ui_ScanMode = 0;
2433         unsigned int ui_ConvertTime = 0;
2434         unsigned int ui_ConvertTimeBase = 0;
2435         unsigned int ui_DelayTime = 0;
2436         unsigned int ui_DelayTimeBase = 0;
2437         unsigned int ui_DelayMode = 0;
2438
2439         /* i_FirstChannel=cmd->chanlist[0]; */
2440         /* i_LastChannel=cmd->chanlist[1]; */
2441         s_BoardInfos[dev->minor].i_FirstChannel = cmd->chanlist[0];
2442         s_BoardInfos[dev->minor].i_LastChannel = cmd->chanlist[1];
2443         if (cmd->start_src == TRIG_EXT) {
2444                 ui_Trigger = 1;
2445                 ui_TriggerEdge = cmd->start_arg & 0xFFFF;
2446                 ui_Triggermode = cmd->start_arg >> 16;
2447         }                       /* if(cmd->start_src==TRIG_EXT) */
2448         else {
2449                 ui_Trigger = 0;
2450         }                       /* elseif(cmd->start_src==TRIG_EXT) */
2451
2452         if (cmd->stop_src == TRIG_COUNT) {
2453                 ui_ScanMode = 0;
2454         }                       /*  if (cmd->stop_src==TRIG_COUNT) */
2455         else {
2456                 ui_ScanMode = 2;
2457         }                       /* else if (cmd->stop_src==TRIG_COUNT) */
2458
2459         if (cmd->scan_begin_src == TRIG_FOLLOW) {
2460                 ui_DelayTime = 0;
2461                 ui_DelayTimeBase = 0;
2462                 ui_DelayMode = 0;
2463         }                       /* if(cmd->scan_begin_src==TRIG_FOLLOW) */
2464         else {
2465                 ui_DelayTime = cmd->scan_begin_arg & 0xFFFF;
2466                 ui_DelayTimeBase = cmd->scan_begin_arg >> 16;
2467                 ui_DelayMode = 1;
2468         }                       /* else if(cmd->scan_begin_src==TRIG_FOLLOW) */
2469         /*         printk("\nui_DelayTime=%u\n",ui_DelayTime); */
2470         /*         printk("\nui_DelayTimeBase=%u\n",ui_DelayTimeBase); */
2471         if (cmd->convert_src == TRIG_TIMER) {
2472                 ui_ConvertTime = cmd->convert_arg & 0xFFFF;
2473                 ui_ConvertTimeBase = cmd->convert_arg >> 16;
2474         } else {
2475                 ui_ConvertTime = 0;
2476                 ui_ConvertTimeBase = 0;
2477         }
2478
2479         /*  if(i_ADDIDATAType ==1 || ((i_ADDIDATAType==2))) */
2480         /*    { */
2481   /**************************************************/
2482         /*Read the old configuration of the current source */
2483   /**************************************************/
2484         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 12); */
2485         ui_Configuration =
2486                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2487   /***********************************************/
2488         /*Write the configuration of the current source */
2489   /***********************************************/
2490         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2491         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2492                                         12) >> 19) & 1) != 1) ;
2493         /* outl((ui_Configuration & 0xFFC00000 ), devpriv->iobase+i_Offset +12); */
2494         outl((ui_Configuration & 0xFFC00000),
2495                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2496         /*  } */
2497         ui_Configuration = 0;
2498         /*      printk("\nfirstchannel=%u\n",i_FirstChannel); */
2499         /*      printk("\nlastchannel=%u\n",i_LastChannel); */
2500         /*      printk("\nui_Trigger=%u\n",ui_Trigger); */
2501         /*      printk("\nui_TriggerEdge=%u\n",ui_TriggerEdge); */
2502         /*      printk("\nui_Triggermode=%u\n",ui_Triggermode); */
2503         /*       printk("\nui_DelayMode=%u\n",ui_DelayMode); */
2504         /*      printk("\nui_ScanMode=%u\n",ui_ScanMode); */
2505
2506         /* ui_Configuration = i_FirstChannel |(i_LastChannel << 8)| 0x00100000 | */
2507         ui_Configuration =
2508                 s_BoardInfos[dev->minor].i_FirstChannel | (s_BoardInfos[dev->
2509                         minor].
2510                 i_LastChannel << 8) | 0x00100000 | (ui_Trigger << 24) |
2511                 (ui_TriggerEdge << 25) | (ui_Triggermode << 27) | (ui_DelayMode
2512                 << 18) | (ui_ScanMode << 16);
2513
2514   /*************************/
2515         /*Write the Configuration */
2516   /*************************/
2517         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2518         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2519                                         12) >> 19) & 1) != 1) ;
2520         /* outl( ui_Configuration, devpriv->iobase+i_Offset + 0x8); */
2521         outl(ui_Configuration,
2522                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x8);
2523   /***********************/
2524         /*Write the Delay Value */
2525   /***********************/
2526         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2527         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2528                                         12) >> 19) & 1) != 1) ;
2529         /* outl(ui_DelayTime,devpriv->iobase+i_Offset + 40); */
2530         outl(ui_DelayTime,
2531                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 40);
2532   /***************************/
2533         /*Write the Delay time base */
2534   /***************************/
2535         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2536         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2537                                         12) >> 19) & 1) != 1) ;
2538         /* outl(ui_DelayTimeBase,devpriv->iobase+i_Offset + 44); */
2539         outl(ui_DelayTimeBase,
2540                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 44);
2541   /*********************************/
2542         /*Write the conversion time value */
2543   /*********************************/
2544         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2545         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2546                                         12) >> 19) & 1) != 1) ;
2547         /* outl(ui_ConvertTime,devpriv->iobase+i_Offset + 32); */
2548         outl(ui_ConvertTime,
2549                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
2550
2551   /********************************/
2552         /*Write the conversion time base */
2553   /********************************/
2554         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2555         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2556                                         12) >> 19) & 1) != 1) ;
2557         /* outl(ui_ConvertTimeBase,devpriv->iobase+i_Offset + 36); */
2558         outl(ui_ConvertTimeBase,
2559                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
2560   /*******************/
2561         /*Read the register */
2562   /*******************/
2563         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 4); */
2564         ui_Configuration =
2565                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
2566   /******************/
2567         /*Set the SCAN bit */
2568   /******************/
2569         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2570         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2571                                         12) >> 19) & 1) != 1) ;
2572
2573         /* outl(((ui_Configuration & 0x1E0FF) | 0x00002000),devpriv->iobase+i_Offset + 4); */
2574         outl(((ui_Configuration & 0x1E0FF) | 0x00002000),
2575                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
2576   /*******************/
2577         /*Read the register */
2578   /*******************/
2579         ui_Configuration = 0;
2580         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 8); */
2581         ui_Configuration =
2582                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2583
2584   /*******************/
2585         /*Set the START bit */
2586   /*******************/
2587         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2588         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2589                                         12) >> 19) & 1) != 1) ;
2590         /* outl((ui_Configuration | 0x00080000),devpriv->iobase+i_Offset + 8); */
2591         outl((ui_Configuration | 0x00080000),
2592                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2593         return 0;
2594 }
2595
2596 /*
2597  * This function copies the acquired data(from FIFO) to Comedi buffer.
2598  */
2599 static int i_APCI3200_InterruptHandleEos(struct comedi_device *dev)
2600 {
2601         struct addi_private *devpriv = dev->private;
2602         unsigned int ui_StatusRegister = 0;
2603         struct comedi_subdevice *s = &dev->subdevices[0];
2604
2605         /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2606         /* comedi_async *async = s->async; */
2607         /* UINT *data; */
2608         /* data=async->data+async->buf_int_ptr;//new samples added from here onwards */
2609         int n = 0, i = 0;
2610         /* END JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2611
2612   /************************************/
2613         /*Read the interrupt status register */
2614   /************************************/
2615         /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2616         ui_StatusRegister =
2617                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 16);
2618
2619   /*************************/
2620         /*Test if interrupt occur */
2621   /*************************/
2622
2623         if ((ui_StatusRegister & 0x2) == 0x2) {
2624       /*************************/
2625                 /*Read the channel number */
2626       /*************************/
2627                 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2628                 /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2629                 /* This value is not used */
2630                 /* ui_ChannelNumber = inl(devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 24); */
2631                 s->async->events = 0;
2632                 /* END JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2633
2634       /*************************************/
2635                 /*Read the digital Analog Input value */
2636       /*************************************/
2637
2638                 /* data[i_Count] = inl(devpriv->iobase+i_Offset + 28); */
2639                 /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2640                 /* data[s_BoardInfos [dev->minor].i_Count] = inl(devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 28); */
2641                 s_BoardInfos[dev->minor].ui_ScanValueArray[s_BoardInfos[dev->
2642                                 minor].i_Count] =
2643                         inl(devpriv->iobase +
2644                         s_BoardInfos[dev->minor].i_Offset + 28);
2645                 /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2646
2647                 /* if((i_Count == (i_LastChannel-i_FirstChannel+3))) */
2648                 if ((s_BoardInfos[dev->minor].i_Count ==
2649                                 (s_BoardInfos[dev->minor].i_LastChannel -
2650                                         s_BoardInfos[dev->minor].
2651                                         i_FirstChannel + 3))) {
2652
2653                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2654                         s_BoardInfos[dev->minor].i_Count++;
2655
2656                         for (i = s_BoardInfos[dev->minor].i_FirstChannel;
2657                                 i <= s_BoardInfos[dev->minor].i_LastChannel;
2658                                 i++) {
2659                                 i_APCI3200_GetChannelCalibrationValue(dev, i,
2660                                         &s_BoardInfos[dev->minor].
2661                                         ui_ScanValueArray[s_BoardInfos[dev->
2662                                                         minor].i_Count + ((i -
2663                                                                 s_BoardInfos
2664                                                                 [dev->minor].
2665                                                                 i_FirstChannel)
2666                                                         * 3)],
2667                                         &s_BoardInfos[dev->minor].
2668                                         ui_ScanValueArray[s_BoardInfos[dev->
2669                                                         minor].i_Count + ((i -
2670                                                                 s_BoardInfos
2671                                                                 [dev->minor].
2672                                                                 i_FirstChannel)
2673                                                         * 3) + 1],
2674                                         &s_BoardInfos[dev->minor].
2675                                         ui_ScanValueArray[s_BoardInfos[dev->
2676                                                         minor].i_Count + ((i -
2677                                                                 s_BoardInfos
2678                                                                 [dev->minor].
2679                                                                 i_FirstChannel)
2680                                                         * 3) + 2]);
2681                         }
2682
2683                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2684
2685                         /* i_Count=-1; */
2686
2687                         s_BoardInfos[dev->minor].i_Count = -1;
2688
2689                         /* async->buf_int_count+=(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_count+=(s_BoardInfos [dev->minor].i_LastChannel-s_BoardInfos [dev->minor].i_FirstChannel+4)*sizeof(unsigned int); */
2692                         /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2693                         /* async->buf_int_ptr+=(i_LastChannel-i_FirstChannel+4)*sizeof(unsigned int); */
2694                         /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2695                         /* async->buf_int_ptr+=(s_BoardInfos [dev->minor].i_LastChannel-s_BoardInfos [dev->minor].i_FirstChannel+4)*sizeof(unsigned int); */
2696                         /* comedi_eos(dev,s); */
2697
2698                         /*  Set the event type (Comedi Buffer End Of Scan) */
2699                         s->async->events |= COMEDI_CB_EOS;
2700
2701                         /*  Test if enougth memory is available and allocate it for 7 values */
2702                         /* n = comedi_buf_write_alloc(s->async, 7*sizeof(unsigned int)); */
2703                         n = comedi_buf_write_alloc(s->async,
2704                                 (7 + 12) * sizeof(unsigned int));
2705
2706                         /*  If not enough memory available, event is set to Comedi Buffer Error */
2707                         if (n > ((7 + 12) * sizeof(unsigned int))) {
2708                                 printk("\ncomedi_buf_write_alloc n = %i", n);
2709                                 s->async->events |= COMEDI_CB_ERROR;
2710                         }
2711                         /*  Write all 7 scan values in the comedi buffer */
2712                         comedi_buf_memcpy_to(s->async, 0,
2713                                 (unsigned int *) s_BoardInfos[dev->minor].
2714                                 ui_ScanValueArray, (7 + 12) * sizeof(unsigned int));
2715
2716                         /*  Update comedi buffer pinters indexes */
2717                         comedi_buf_write_free(s->async,
2718                                 (7 + 12) * sizeof(unsigned int));
2719
2720                         /*  Send events */
2721                         comedi_event(dev, s);
2722                         /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2723
2724                         /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2725                         /*  */
2726                         /* if (s->async->buf_int_ptr>=s->async->data_len) //  for buffer rool over */
2727                         /*   { */
2728                         /*     /* buffer rollover */ */
2729                         /*     s->async->buf_int_ptr=0; */
2730                         /*     comedi_eobuf(dev,s); */
2731                         /*   } */
2732                         /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2733                 }
2734                 /* i_Count++; */
2735                 s_BoardInfos[dev->minor].i_Count++;
2736         }
2737         /* i_InterruptFlag=0; */
2738         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2739         return 0;
2740 }
2741
2742 static void v_APCI3200_Interrupt(int irq, void *d)
2743 {
2744         struct comedi_device *dev = d;
2745         struct addi_private *devpriv = dev->private;
2746         unsigned int ui_StatusRegister = 0;
2747         unsigned int ui_ChannelNumber = 0;
2748         int i_CalibrationFlag = 0;
2749         int i_CJCFlag = 0;
2750         unsigned int ui_DummyValue = 0;
2751         unsigned int ui_DigitalTemperature = 0;
2752         unsigned int ui_DigitalInput = 0;
2753         int i_ConvertCJCCalibration;
2754         /* BEGIN JK TEST */
2755         int i_ReturnValue = 0;
2756         /* END JK TEST */
2757
2758         /* printk ("\n i_ScanType = %i i_ADDIDATAType = %i", s_BoardInfos [dev->minor].i_ScanType, s_BoardInfos [dev->minor].i_ADDIDATAType); */
2759
2760         /* switch(i_ScanType) */
2761         switch (s_BoardInfos[dev->minor].i_ScanType) {
2762         case 0:
2763         case 1:
2764                 /* switch(i_ADDIDATAType) */
2765                 switch (s_BoardInfos[dev->minor].i_ADDIDATAType) {
2766                 case 0:
2767                 case 1:
2768
2769           /************************************/
2770                         /*Read the interrupt status register */
2771           /************************************/
2772                         /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2773                         ui_StatusRegister =
2774                                 inl(devpriv->iobase +
2775                                 s_BoardInfos[dev->minor].i_Offset + 16);
2776                         if ((ui_StatusRegister & 0x2) == 0x2) {
2777                                 /* i_CalibrationFlag = ((inl(devpriv->iobase+i_Offset + 12) & 0x00060000) >> 17); */
2778                                 i_CalibrationFlag =
2779                                         ((inl(devpriv->iobase +
2780                                                         s_BoardInfos[dev->
2781                                                                 minor].
2782                                                         i_Offset +
2783                                                         12) & 0x00060000) >>
2784                                         17);
2785               /*************************/
2786                                 /*Read the channel number */
2787               /*************************/
2788                                 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2789
2790               /*************************************/
2791                                 /*Read the digital analog input value */
2792               /*************************************/
2793                                 /* ui_DigitalInput = inl(devpriv->iobase+i_Offset + 28); */
2794                                 ui_DigitalInput =
2795                                         inl(devpriv->iobase +
2796                                         s_BoardInfos[dev->minor].i_Offset + 28);
2797
2798               /***********************************************/
2799                                 /* Test if the value read is the channel value */
2800               /***********************************************/
2801                                 if (i_CalibrationFlag == 0) {
2802                                         /* ui_InterruptChannelValue[i_Count + 0] = ui_DigitalInput; */
2803                                         s_BoardInfos[dev->minor].
2804                                                 ui_InterruptChannelValue
2805                                                 [s_BoardInfos[dev->minor].
2806                                                 i_Count + 0] = ui_DigitalInput;
2807
2808                                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2809                                         /*
2810                                            printk("\n 1 - i_APCI3200_GetChannelCalibrationValue (dev, s_BoardInfos %i", ui_ChannelNumber);
2811                                            i_APCI3200_GetChannelCalibrationValue (dev, s_BoardInfos [dev->minor].ui_Channel_num,
2812                                            &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 6],
2813                                            &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 7],
2814                                            &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 8]);
2815                                          */
2816                                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2817
2818                   /******************************************************/
2819                                         /*Start the conversion of the calibration offset value */
2820                   /******************************************************/
2821                                         i_APCI3200_ReadCalibrationOffsetValue
2822                                                 (dev, &ui_DummyValue);
2823                                 }       /* if (i_CalibrationFlag == 0) */
2824               /**********************************************************/
2825                                 /* Test if the value read is the calibration offset value */
2826               /**********************************************************/
2827
2828                                 if (i_CalibrationFlag == 1) {
2829
2830                   /******************/
2831                                         /* Save the value */
2832                   /******************/
2833
2834                                         /* ui_InterruptChannelValue[i_Count + 1] = ui_DigitalInput; */
2835                                         s_BoardInfos[dev->minor].
2836                                                 ui_InterruptChannelValue
2837                                                 [s_BoardInfos[dev->minor].
2838                                                 i_Count + 1] = ui_DigitalInput;
2839
2840                   /******************************************************/
2841                                         /* Start the conversion of the calibration gain value */
2842                   /******************************************************/
2843                                         i_APCI3200_ReadCalibrationGainValue(dev,
2844                                                 &ui_DummyValue);
2845                                 }       /* if (i_CalibrationFlag == 1) */
2846               /******************************************************/
2847                                 /*Test if the value read is the calibration gain value */
2848               /******************************************************/
2849
2850                                 if (i_CalibrationFlag == 2) {
2851
2852                   /****************/
2853                                         /*Save the value */
2854                   /****************/
2855                                         /* ui_InterruptChannelValue[i_Count + 2] = ui_DigitalInput; */
2856                                         s_BoardInfos[dev->minor].
2857                                                 ui_InterruptChannelValue
2858                                                 [s_BoardInfos[dev->minor].
2859                                                 i_Count + 2] = ui_DigitalInput;
2860                                         /* if(i_ScanType==1) */
2861                                         if (s_BoardInfos[dev->minor].
2862                                                 i_ScanType == 1) {
2863
2864                                                 /* i_InterruptFlag=0; */
2865                                                 s_BoardInfos[dev->minor].
2866                                                         i_InterruptFlag = 0;
2867                                                 /* i_Count=i_Count + 6; */
2868                                                 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2869                                                 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count + 6; */
2870                                                 s_BoardInfos[dev->minor].
2871                                                         i_Count =
2872                                                         s_BoardInfos[dev->
2873                                                         minor].i_Count + 9;
2874                                                 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2875                                         }       /* if(i_ScanType==1) */
2876                                         else {
2877                                                 /* i_Count=0; */
2878                                                 s_BoardInfos[dev->minor].
2879                                                         i_Count = 0;
2880                                         }       /* elseif(i_ScanType==1) */
2881                                         /* if(i_ScanType!=1) */
2882                                         if (s_BoardInfos[dev->minor].
2883                                                 i_ScanType != 1) {
2884                                                 i_ReturnValue = send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
2885                                         }       /* if(i_ScanType!=1) */
2886                                         else {
2887                                                 /* if(i_ChannelCount==i_Sum) */
2888                                                 if (s_BoardInfos[dev->minor].
2889                                                         i_ChannelCount ==
2890                                                         s_BoardInfos[dev->
2891                                                                 minor].i_Sum) {
2892                                                         send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
2893                                                 }
2894                                         }       /* if(i_ScanType!=1) */
2895                                 }       /* if (i_CalibrationFlag == 2) */
2896                         }       /*  if ((ui_StatusRegister & 0x2) == 0x2) */
2897
2898                         break;
2899
2900                 case 2:
2901           /************************************/
2902                         /*Read the interrupt status register */
2903           /************************************/
2904
2905                         /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2906                         ui_StatusRegister =
2907                                 inl(devpriv->iobase +
2908                                 s_BoardInfos[dev->minor].i_Offset + 16);
2909           /*************************/
2910                         /*Test if interrupt occur */
2911           /*************************/
2912
2913                         if ((ui_StatusRegister & 0x2) == 0x2) {
2914
2915                                 /* i_CJCFlag = ((inl(devpriv->iobase+i_Offset + 4) & 0x00000400) >> 10); */
2916                                 i_CJCFlag =
2917                                         ((inl(devpriv->iobase +
2918                                                         s_BoardInfos[dev->
2919                                                                 minor].
2920                                                         i_Offset +
2921                                                         4) & 0x00000400) >> 10);
2922
2923                                 /* i_CalibrationFlag = ((inl(devpriv->iobase+i_Offset + 12) & 0x00060000) >> 17); */
2924                                 i_CalibrationFlag =
2925                                         ((inl(devpriv->iobase +
2926                                                         s_BoardInfos[dev->
2927                                                                 minor].
2928                                                         i_Offset +
2929                                                         12) & 0x00060000) >>
2930                                         17);
2931
2932               /*************************/
2933                                 /*Read the channel number */
2934               /*************************/
2935
2936                                 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2937                                 ui_ChannelNumber =
2938                                         inl(devpriv->iobase +
2939                                         s_BoardInfos[dev->minor].i_Offset + 24);
2940                                 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2941                                 s_BoardInfos[dev->minor].ui_Channel_num =
2942                                         ui_ChannelNumber;
2943                                 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2944
2945               /************************************/
2946                                 /*Read the digital temperature value */
2947               /************************************/
2948                                 /* ui_DigitalTemperature = inl(devpriv->iobase+i_Offset + 28); */
2949                                 ui_DigitalTemperature =
2950                                         inl(devpriv->iobase +
2951                                         s_BoardInfos[dev->minor].i_Offset + 28);
2952
2953               /*********************************************/
2954                                 /*Test if the value read is the channel value */
2955               /*********************************************/
2956
2957                                 if ((i_CalibrationFlag == 0)
2958                                         && (i_CJCFlag == 0)) {
2959                                         /* ui_InterruptChannelValue[i_Count + 0]=ui_DigitalTemperature; */
2960                                         s_BoardInfos[dev->minor].
2961                                                 ui_InterruptChannelValue
2962                                                 [s_BoardInfos[dev->minor].
2963                                                 i_Count + 0] =
2964                                                 ui_DigitalTemperature;
2965
2966                   /*********************************/
2967                                         /*Start the conversion of the CJC */
2968                   /*********************************/
2969                                         i_APCI3200_ReadCJCValue(dev,
2970                                                 &ui_DummyValue);
2971
2972                                 }       /* if ((i_CalibrationFlag == 0) && (i_CJCFlag == 0)) */
2973
2974                  /*****************************************/
2975                                 /*Test if the value read is the CJC value */
2976                  /*****************************************/
2977
2978                                 if ((i_CJCFlag == 1)
2979                                         && (i_CalibrationFlag == 0)) {
2980                                         /* ui_InterruptChannelValue[i_Count + 3]=ui_DigitalTemperature; */
2981                                         s_BoardInfos[dev->minor].
2982                                                 ui_InterruptChannelValue
2983                                                 [s_BoardInfos[dev->minor].
2984                                                 i_Count + 3] =
2985                                                 ui_DigitalTemperature;
2986
2987                   /******************************************************/
2988                                         /*Start the conversion of the calibration offset value */
2989                   /******************************************************/
2990                                         i_APCI3200_ReadCalibrationOffsetValue
2991                                                 (dev, &ui_DummyValue);
2992                                 }       /*  if ((i_CJCFlag == 1) && (i_CalibrationFlag == 0)) */
2993
2994                  /********************************************************/
2995                                 /*Test if the value read is the calibration offset value */
2996                  /********************************************************/
2997
2998                                 if ((i_CalibrationFlag == 1)
2999                                         && (i_CJCFlag == 0)) {
3000                                         /* ui_InterruptChannelValue[i_Count + 1]=ui_DigitalTemperature; */
3001                                         s_BoardInfos[dev->minor].
3002                                                 ui_InterruptChannelValue
3003                                                 [s_BoardInfos[dev->minor].
3004                                                 i_Count + 1] =
3005                                                 ui_DigitalTemperature;
3006
3007                   /****************************************************/
3008                                         /*Start the conversion of the calibration gain value */
3009                   /****************************************************/
3010                                         i_APCI3200_ReadCalibrationGainValue(dev,
3011                                                 &ui_DummyValue);
3012
3013                                 }       /* if ((i_CalibrationFlag == 1) && (i_CJCFlag == 0)) */
3014
3015               /******************************************************/
3016                                 /*Test if the value read is the calibration gain value */
3017               /******************************************************/
3018
3019                                 if ((i_CalibrationFlag == 2)
3020                                         && (i_CJCFlag == 0)) {
3021                                         /* ui_InterruptChannelValue[i_Count + 2]=ui_DigitalTemperature; */
3022                                         s_BoardInfos[dev->minor].
3023                                                 ui_InterruptChannelValue
3024                                                 [s_BoardInfos[dev->minor].
3025                                                 i_Count + 2] =
3026                                                 ui_DigitalTemperature;
3027
3028                   /**********************************************************/
3029                                         /*Test if the Calibration channel must be read for the CJC */
3030                   /**********************************************************/
3031
3032                                         /*Test if the polarity is the same */
3033                   /**********************************/
3034                                         /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
3035                                         if (s_BoardInfos[dev->minor].
3036                                                 i_CJCPolarity !=
3037                                                 s_BoardInfos[dev->minor].
3038                                                 i_ADDIDATAPolarity) {
3039                                                 i_ConvertCJCCalibration = 1;
3040                                         }       /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
3041                                         else {
3042                                                 /* if(i_CJCGain==i_ADDIDATAGain) */
3043                                                 if (s_BoardInfos[dev->minor].
3044                                                         i_CJCGain ==
3045                                                         s_BoardInfos[dev->
3046                                                                 minor].
3047                                                         i_ADDIDATAGain) {
3048                                                         i_ConvertCJCCalibration
3049                                                                 = 0;
3050                                                 }       /* if(i_CJCGain==i_ADDIDATAGain) */
3051                                                 else {
3052                                                         i_ConvertCJCCalibration
3053                                                                 = 1;
3054                                                 }       /* elseif(i_CJCGain==i_ADDIDATAGain) */
3055                                         }       /* elseif(i_CJCPolarity!=i_ADDIDATAPolarity) */
3056                                         if (i_ConvertCJCCalibration == 1) {
3057                       /****************************************************************/
3058                                                 /*Start the conversion of the calibration gain value for the CJC */
3059                       /****************************************************************/
3060                                                 i_APCI3200_ReadCJCCalOffset(dev,
3061                                                         &ui_DummyValue);
3062
3063                                         }       /* if(i_ConvertCJCCalibration==1) */
3064                                         else {
3065                                                 /* ui_InterruptChannelValue[i_Count + 4]=0; */
3066                                                 /* ui_InterruptChannelValue[i_Count + 5]=0; */
3067                                                 s_BoardInfos[dev->minor].
3068                                                         ui_InterruptChannelValue
3069                                                         [s_BoardInfos[dev->
3070                                                                 minor].i_Count +
3071                                                         4] = 0;
3072                                                 s_BoardInfos[dev->minor].
3073                                                         ui_InterruptChannelValue
3074                                                         [s_BoardInfos[dev->
3075                                                                 minor].i_Count +
3076                                                         5] = 0;
3077                                         }       /* elseif(i_ConvertCJCCalibration==1) */
3078                                 }       /* else if ((i_CalibrationFlag == 2) && (i_CJCFlag == 0)) */
3079
3080                  /********************************************************************/
3081                                 /*Test if the value read is the calibration offset value for the CJC */
3082                  /********************************************************************/
3083
3084                                 if ((i_CalibrationFlag == 1)
3085                                         && (i_CJCFlag == 1)) {
3086                                         /* ui_InterruptChannelValue[i_Count + 4]=ui_DigitalTemperature; */
3087                                         s_BoardInfos[dev->minor].
3088                                                 ui_InterruptChannelValue
3089                                                 [s_BoardInfos[dev->minor].
3090                                                 i_Count + 4] =
3091                                                 ui_DigitalTemperature;
3092
3093                   /****************************************************************/
3094                                         /*Start the conversion of the calibration gain value for the CJC */
3095                   /****************************************************************/
3096                                         i_APCI3200_ReadCJCCalGain(dev,
3097                                                 &ui_DummyValue);
3098
3099                                 }       /* if ((i_CalibrationFlag == 1) && (i_CJCFlag == 1)) */
3100
3101               /******************************************************************/
3102                                 /*Test if the value read is the calibration gain value for the CJC */
3103               /******************************************************************/
3104
3105                                 if ((i_CalibrationFlag == 2)
3106                                         && (i_CJCFlag == 1)) {
3107                                         /* ui_InterruptChannelValue[i_Count + 5]=ui_DigitalTemperature; */
3108                                         s_BoardInfos[dev->minor].
3109                                                 ui_InterruptChannelValue
3110                                                 [s_BoardInfos[dev->minor].
3111                                                 i_Count + 5] =
3112                                                 ui_DigitalTemperature;
3113
3114                                         /* if(i_ScanType==1) */
3115                                         if (s_BoardInfos[dev->minor].
3116                                                 i_ScanType == 1) {
3117
3118                                                 /* i_InterruptFlag=0; */
3119                                                 s_BoardInfos[dev->minor].
3120                                                         i_InterruptFlag = 0;
3121                                                 /* i_Count=i_Count + 6; */
3122                                                 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
3123                                                 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count + 6; */
3124                                                 s_BoardInfos[dev->minor].
3125                                                         i_Count =
3126                                                         s_BoardInfos[dev->
3127                                                         minor].i_Count + 9;
3128                                                 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
3129                                         }       /* if(i_ScanType==1) */
3130                                         else {
3131                                                 /* i_Count=0; */
3132                                                 s_BoardInfos[dev->minor].
3133                                                         i_Count = 0;
3134                                         }       /* elseif(i_ScanType==1) */
3135
3136                                         /* if(i_ScanType!=1) */
3137                                         if (s_BoardInfos[dev->minor].
3138                                                 i_ScanType != 1) {
3139                                                 send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
3140                                         }       /* if(i_ScanType!=1) */
3141                                         else {
3142                                                 /* if(i_ChannelCount==i_Sum) */
3143                                                 if (s_BoardInfos[dev->minor].
3144                                                         i_ChannelCount ==
3145                                                         s_BoardInfos[dev->
3146                                                                 minor].i_Sum) {
3147                                                         send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
3148
3149                                                 }       /* if(i_ChannelCount==i_Sum) */
3150                                         }       /* else if(i_ScanType!=1) */
3151                                 }       /* if ((i_CalibrationFlag == 2) && (i_CJCFlag == 1)) */
3152
3153                         }       /* else if ((ui_StatusRegister & 0x2) == 0x2) */
3154                         break;
3155                 }               /* switch(i_ADDIDATAType) */
3156                 break;
3157         case 2:
3158         case 3:
3159                 i_APCI3200_InterruptHandleEos(dev);
3160                 break;
3161         }                       /* switch(i_ScanType) */
3162         return;
3163 }