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