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         unsigned int mask = data[0];
 627         unsigned int bits = data[1];
 628
 629         s->state = inl(devpriv->i_IobaseAddon) & 0xf;
 630         if (mask) {
 631                 s->state &= ~mask;
 632                 s->state |= (bits & mask);
 633
 634                 outl(s->state, devpriv->i_IobaseAddon);
 635         }
 636
 637         data[1] = s->state;
 638
 639         return insn->n;
 640 }
 641
 642 static int i_APCI3200_Read1AnalogInputChannel(struct comedi_device *dev,
 643                                               struct comedi_subdevice *s,
 644                                               struct comedi_insn *insn,
 645                                               unsigned int *data)
 646 {
 647         struct addi_private *devpriv = dev->private;
 648         unsigned int ui_EOC = 0;
 649         unsigned int ui_ChannelNo = 0;
 650         unsigned int ui_CommandRegister = 0;
 651
 652         /* BEGIN JK 06.07.04: Management of sevrals boards */
 653         /* ui_ChannelNo=i_ChannelNo; */
 654         ui_ChannelNo = s_BoardInfos[dev->minor].i_ChannelNo;
 655
 656         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 657         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 658                                         12) >> 19) & 1) != 1) ;
 659   /*********************************/
 660         /* Write the channel to configure */
 661   /*********************************/
 662         /* Begin JK 20.10.2004: Bad channel value is used when using differential mode */
 663         /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
 664         /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
 665         outl(0 | s_BoardInfos[dev->minor].i_ChannelNo,
 666                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x4);
 667         /* End JK 20.10.2004: Bad channel value is used when using differential mode */
 668
 669   /*******************************/
 670         /* Set the convert timing unit */
 671   /*******************************/
 672         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 673         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 674                                         12) >> 19) & 1) != 1) ;
 675
 676         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
 677         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
 678                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
 679
 680   /**************************/
 681         /* Set the convert timing */
 682   /**************************/
 683         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 684         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 685                                         12) >> 19) & 1) != 1) ;
 686
 687         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
 688         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
 689                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
 690
 691   /**************************************************************************/
 692         /* Set the start end stop index to the selected channel and set the start */
 693   /**************************************************************************/
 694
 695         ui_CommandRegister = ui_ChannelNo | (ui_ChannelNo << 8) | 0x80000;
 696
 697   /*********************************/
 698         /*Test if the interrupt is enable */
 699   /*********************************/
 700
 701         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 702         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
 703       /************************/
 704                 /* Enable the interrupt */
 705       /************************/
 706                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
 707         }                       /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 708
 709   /******************************/
 710         /* Write the command register */
 711   /******************************/
 712         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 713         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 714                                         12) >> 19) & 1) != 1) ;
 715
 716         /* outl(ui_CommandRegister, devpriv->iobase+i_Offset + 8); */
 717         outl(ui_CommandRegister,
 718                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
 719
 720   /*****************************/
 721         /*Test if interrupt is enable */
 722   /*****************************/
 723         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 724         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
 725                 do {
 726           /*************************/
 727                         /*Read the EOC Status bit */
 728           /*************************/
 729
 730                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
 731                         ui_EOC = inl(devpriv->iobase +
 732                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
 733
 734                 } while (ui_EOC != 1);
 735
 736       /***************************************/
 737                 /* Read the digital value of the input */
 738       /***************************************/
 739
 740                 /* data[0] = inl (devpriv->iobase+i_Offset + 28); */
 741                 data[0] =
 742                         inl(devpriv->iobase +
 743                         s_BoardInfos[dev->minor].i_Offset + 28);
 744                 /* END JK 06.07.04: Management of sevrals boards */
 745
 746         }                       /*  if (i_InterruptFlag == ADDIDATA_DISABLE) */
 747         return 0;
 748 }
 749
 750 static int i_APCI3200_ReadCalibrationOffsetValue(struct comedi_device *dev,
 751                                                  unsigned int *data)
 752 {
 753         struct addi_private *devpriv = dev->private;
 754         unsigned int ui_Temp = 0, ui_EOC = 0;
 755         unsigned int ui_CommandRegister = 0;
 756
 757         /* BEGIN JK 06.07.04: Management of sevrals boards */
 758         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 759         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 760                                         12) >> 19) & 1) != 1) ;
 761   /*********************************/
 762         /* Write the channel to configure */
 763   /*********************************/
 764         /* Begin JK 20.10.2004: This seems not necessary ! */
 765         /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
 766         /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
 767         /* End JK 20.10.2004: This seems not necessary ! */
 768
 769   /*******************************/
 770         /* Set the convert timing unit */
 771   /*******************************/
 772         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 773         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 774                                         12) >> 19) & 1) != 1) ;
 775         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
 776         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
 777                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
 778   /**************************/
 779         /* Set the convert timing */
 780   /**************************/
 781         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 782         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 783                                         12) >> 19) & 1) != 1) ;
 784         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
 785         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
 786                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
 787   /*****************************/
 788         /*Read the calibration offset */
 789   /*****************************/
 790         /* ui_Temp = inl(devpriv->iobase+i_Offset + 12); */
 791         ui_Temp = inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
 792
 793   /*********************************/
 794         /*Configure the Offset Conversion */
 795   /*********************************/
 796         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 797         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 798                                         12) >> 19) & 1) != 1) ;
 799         /* outl((ui_Temp | 0x00020000), devpriv->iobase+i_Offset + 12); */
 800         outl((ui_Temp | 0x00020000),
 801                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
 802   /*******************************/
 803         /*Initialise ui_CommandRegister */
 804   /*******************************/
 805
 806         ui_CommandRegister = 0;
 807
 808   /*********************************/
 809         /*Test if the interrupt is enable */
 810   /*********************************/
 811
 812         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 813         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
 814
 815       /**********************/
 816                 /*Enable the interrupt */
 817       /**********************/
 818
 819                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
 820
 821         }                       /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 822
 823   /**********************/
 824         /*Start the conversion */
 825   /**********************/
 826         ui_CommandRegister = ui_CommandRegister | 0x00080000;
 827
 828   /***************************/
 829         /*Write the command regiter */
 830   /***************************/
 831         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 832         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 833                                         12) >> 19) & 1) != 1) ;
 834         /* outl(ui_CommandRegister, devpriv->iobase+i_Offset + 8); */
 835         outl(ui_CommandRegister,
 836                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
 837
 838   /*****************************/
 839         /*Test if interrupt is enable */
 840   /*****************************/
 841
 842         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 843         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
 844
 845                 do {
 846           /*******************/
 847                         /*Read the EOC flag */
 848           /*******************/
 849
 850                         /* ui_EOC = inl (devpriv->iobase+i_Offset + 20) & 1; */
 851                         ui_EOC = inl(devpriv->iobase +
 852                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
 853
 854                 } while (ui_EOC != 1);
 855
 856       /**************************************************/
 857                 /*Read the digital value of the calibration Offset */
 858       /**************************************************/
 859
 860                 /* data[0] = inl(devpriv->iobase+i_Offset+ 28); */
 861                 data[0] =
 862                         inl(devpriv->iobase +
 863                         s_BoardInfos[dev->minor].i_Offset + 28);
 864         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 865         return 0;
 866 }
 867
 868 static int i_APCI3200_ReadCalibrationGainValue(struct comedi_device *dev,
 869                                                unsigned int *data)
 870 {
 871         struct addi_private *devpriv = dev->private;
 872         unsigned int ui_EOC = 0;
 873         int ui_CommandRegister = 0;
 874
 875         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 876         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 877                                         12) >> 19) & 1) != 1) ;
 878   /*********************************/
 879         /* Write the channel to configure */
 880   /*********************************/
 881         /* Begin JK 20.10.2004: This seems not necessary ! */
 882         /* outl(0 | ui_Channel_num , devpriv->iobase+i_Offset + 0x4); */
 883         /* outl(0 | s_BoardInfos [dev->minor].ui_Channel_num , devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 0x4); */
 884         /* End JK 20.10.2004: This seems not necessary ! */
 885
 886   /***************************/
 887         /*Read the calibration gain */
 888   /***************************/
 889   /*******************************/
 890         /* Set the convert timing unit */
 891   /*******************************/
 892         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 893         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 894                                         12) >> 19) & 1) != 1) ;
 895         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
 896         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
 897                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
 898   /**************************/
 899         /* Set the convert timing */
 900   /**************************/
 901         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 902         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 903                                         12) >> 19) & 1) != 1) ;
 904         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
 905         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
 906                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
 907   /*******************************/
 908         /*Configure the Gain Conversion */
 909   /*******************************/
 910         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 911         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 912                                         12) >> 19) & 1) != 1) ;
 913         /* outl(0x00040000 , devpriv->iobase+i_Offset + 12); */
 914         outl(0x00040000,
 915                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
 916
 917   /*******************************/
 918         /*Initialise ui_CommandRegister */
 919   /*******************************/
 920
 921         ui_CommandRegister = 0;
 922
 923   /*********************************/
 924         /*Test if the interrupt is enable */
 925   /*********************************/
 926
 927         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 928         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
 929
 930       /**********************/
 931                 /*Enable the interrupt */
 932       /**********************/
 933
 934                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
 935
 936         }                       /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
 937
 938   /**********************/
 939         /*Start the conversion */
 940   /**********************/
 941
 942         ui_CommandRegister = ui_CommandRegister | 0x00080000;
 943   /***************************/
 944         /*Write the command regiter */
 945   /***************************/
 946         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 947         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 948                                         12) >> 19) & 1) != 1) ;
 949         /* outl(ui_CommandRegister , devpriv->iobase+i_Offset + 8); */
 950         outl(ui_CommandRegister,
 951                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
 952
 953   /*****************************/
 954         /*Test if interrupt is enable */
 955   /*****************************/
 956
 957         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 958         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
 959
 960                 do {
 961
 962           /*******************/
 963                         /*Read the EOC flag */
 964           /*******************/
 965
 966                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
 967                         ui_EOC = inl(devpriv->iobase +
 968                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
 969
 970                 } while (ui_EOC != 1);
 971
 972       /************************************************/
 973                 /*Read the digital value of the calibration Gain */
 974       /************************************************/
 975
 976                 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
 977                 data[0] =
 978                         inl(devpriv->iobase +
 979                         s_BoardInfos[dev->minor].i_Offset + 28);
 980
 981         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
 982         return 0;
 983 }
 984
 985 static int i_APCI3200_ReadCJCValue(struct comedi_device *dev,
 986                                    unsigned int *data)
 987 {
 988         struct addi_private *devpriv = dev->private;
 989         unsigned int ui_EOC = 0;
 990         int ui_CommandRegister = 0;
 991
 992   /******************************/
 993         /*Set the converting time unit */
 994   /******************************/
 995
 996         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
 997         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
 998                                         12) >> 19) & 1) != 1) ;
 999
1000         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1001         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1002                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1003   /**************************/
1004         /* Set the convert timing */
1005   /**************************/
1006         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1007         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1008                                         12) >> 19) & 1) != 1) ;
1009
1010         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1011         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1012                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1013
1014   /******************************/
1015         /*Configure the CJC Conversion */
1016   /******************************/
1017         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1018         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1019                                         12) >> 19) & 1) != 1) ;
1020
1021         /* outl( 0x00000400 , devpriv->iobase+i_Offset + 4); */
1022         outl(0x00000400,
1023                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1024   /*******************************/
1025         /*Initialise dw_CommandRegister */
1026   /*******************************/
1027         ui_CommandRegister = 0;
1028   /*********************************/
1029         /*Test if the interrupt is enable */
1030   /*********************************/
1031         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1032         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1033       /**********************/
1034                 /*Enable the interrupt */
1035       /**********************/
1036                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1037         }
1038
1039   /**********************/
1040         /*Start the conversion */
1041   /**********************/
1042
1043         ui_CommandRegister = ui_CommandRegister | 0x00080000;
1044
1045   /***************************/
1046         /*Write the command regiter */
1047   /***************************/
1048         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1049         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1050                                         12) >> 19) & 1) != 1) ;
1051         /* outl(ui_CommandRegister , devpriv->iobase+i_Offset + 8); */
1052         outl(ui_CommandRegister,
1053                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1054
1055   /*****************************/
1056         /*Test if interrupt is enable */
1057   /*****************************/
1058
1059         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1060         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1061                 do {
1062
1063           /*******************/
1064                         /*Read the EOC flag */
1065           /*******************/
1066
1067                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1068                         ui_EOC = inl(devpriv->iobase +
1069                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1070
1071                 } while (ui_EOC != 1);
1072
1073       /***********************************/
1074                 /*Read the digital value of the CJC */
1075       /***********************************/
1076
1077                 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
1078                 data[0] =
1079                         inl(devpriv->iobase +
1080                         s_BoardInfos[dev->minor].i_Offset + 28);
1081
1082         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1083         return 0;
1084 }
1085
1086 static int i_APCI3200_ReadCJCCalOffset(struct comedi_device *dev,
1087                                        unsigned int *data)
1088 {
1089         struct addi_private *devpriv = dev->private;
1090         unsigned int ui_EOC = 0;
1091         int ui_CommandRegister = 0;
1092
1093   /*******************************************/
1094         /*Read calibration offset value for the CJC */
1095   /*******************************************/
1096   /*******************************/
1097         /* Set the convert timing unit */
1098   /*******************************/
1099         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1100         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1101                                         12) >> 19) & 1) != 1) ;
1102         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1103         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1104                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1105   /**************************/
1106         /* Set the convert timing */
1107   /**************************/
1108         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1109         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1110                                         12) >> 19) & 1) != 1) ;
1111         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1112         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1113                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1114   /******************************/
1115         /*Configure the CJC Conversion */
1116   /******************************/
1117         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1118         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1119                                         12) >> 19) & 1) != 1) ;
1120         /* outl(0x00000400 , devpriv->iobase+i_Offset + 4); */
1121         outl(0x00000400,
1122                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1123   /*********************************/
1124         /*Configure the Offset Conversion */
1125   /*********************************/
1126         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1127         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1128                                         12) >> 19) & 1) != 1) ;
1129         /* outl(0x00020000, devpriv->iobase+i_Offset + 12); */
1130         outl(0x00020000,
1131                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
1132   /*******************************/
1133         /*Initialise ui_CommandRegister */
1134   /*******************************/
1135         ui_CommandRegister = 0;
1136   /*********************************/
1137         /*Test if the interrupt is enable */
1138   /*********************************/
1139
1140         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1141         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1142       /**********************/
1143                 /*Enable the interrupt */
1144       /**********************/
1145                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1146
1147         }
1148
1149   /**********************/
1150         /*Start the conversion */
1151   /**********************/
1152         ui_CommandRegister = ui_CommandRegister | 0x00080000;
1153   /***************************/
1154         /*Write the command regiter */
1155   /***************************/
1156         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1157         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1158                                         12) >> 19) & 1) != 1) ;
1159         /* outl(ui_CommandRegister,devpriv->iobase+i_Offset + 8); */
1160         outl(ui_CommandRegister,
1161                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1162         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1163         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1164                 do {
1165           /*******************/
1166                         /*Read the EOC flag */
1167           /*******************/
1168                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1169                         ui_EOC = inl(devpriv->iobase +
1170                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1171                 } while (ui_EOC != 1);
1172
1173       /**************************************************/
1174                 /*Read the digital value of the calibration Offset */
1175       /**************************************************/
1176                 /* data[0] = inl(devpriv->iobase+i_Offset + 28); */
1177                 data[0] =
1178                         inl(devpriv->iobase +
1179                         s_BoardInfos[dev->minor].i_Offset + 28);
1180         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1181         return 0;
1182 }
1183
1184 static int i_APCI3200_ReadCJCCalGain(struct comedi_device *dev,
1185                                      unsigned int *data)
1186 {
1187         struct addi_private *devpriv = dev->private;
1188         unsigned int ui_EOC = 0;
1189         int ui_CommandRegister = 0;
1190
1191   /*******************************/
1192         /* Set the convert timing unit */
1193   /*******************************/
1194         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1195         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1196                                         12) >> 19) & 1) != 1) ;
1197         /* outl(i_ADDIDATAConversionTimeUnit , devpriv->iobase+i_Offset + 36); */
1198         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit,
1199                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
1200   /**************************/
1201         /* Set the convert timing */
1202   /**************************/
1203         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1204         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1205                                         12) >> 19) & 1) != 1) ;
1206         /* outl(i_ADDIDATAConversionTime , devpriv->iobase+i_Offset + 32); */
1207         outl(s_BoardInfos[dev->minor].i_ADDIDATAConversionTime,
1208                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
1209   /******************************/
1210         /*Configure the CJC Conversion */
1211   /******************************/
1212         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1213         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1214                                         12) >> 19) & 1) != 1) ;
1215         /* outl(0x00000400,devpriv->iobase+i_Offset + 4); */
1216         outl(0x00000400,
1217                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
1218   /*******************************/
1219         /*Configure the Gain Conversion */
1220   /*******************************/
1221         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1222         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1223                                         12) >> 19) & 1) != 1) ;
1224         /* outl(0x00040000,devpriv->iobase+i_Offset + 12); */
1225         outl(0x00040000,
1226                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
1227
1228   /*******************************/
1229         /*Initialise dw_CommandRegister */
1230   /*******************************/
1231         ui_CommandRegister = 0;
1232   /*********************************/
1233         /*Test if the interrupt is enable */
1234   /*********************************/
1235         /* if (i_InterruptFlag == ADDIDATA_ENABLE) */
1236         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_ENABLE) {
1237       /**********************/
1238                 /*Enable the interrupt */
1239       /**********************/
1240                 ui_CommandRegister = ui_CommandRegister | 0x00100000;
1241         }
1242   /**********************/
1243         /*Start the conversion */
1244   /**********************/
1245         ui_CommandRegister = ui_CommandRegister | 0x00080000;
1246   /***************************/
1247         /*Write the command regiter */
1248   /***************************/
1249         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1250         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1251                                         12) >> 19) & 1) != 1) ;
1252         /* outl(ui_CommandRegister ,devpriv->iobase+i_Offset + 8); */
1253         outl(ui_CommandRegister,
1254                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
1255         /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1256         if (s_BoardInfos[dev->minor].i_InterruptFlag == ADDIDATA_DISABLE) {
1257                 do {
1258           /*******************/
1259                         /*Read the EOC flag */
1260           /*******************/
1261                         /* ui_EOC = inl(devpriv->iobase+i_Offset + 20) & 1; */
1262                         ui_EOC = inl(devpriv->iobase +
1263                                 s_BoardInfos[dev->minor].i_Offset + 20) & 1;
1264                 } while (ui_EOC != 1);
1265       /************************************************/
1266                 /*Read the digital value of the calibration Gain */
1267       /************************************************/
1268                 /* data[0] = inl (devpriv->iobase+i_Offset + 28); */
1269                 data[0] =
1270                         inl(devpriv->iobase +
1271                         s_BoardInfos[dev->minor].i_Offset + 28);
1272         }                       /* if (i_InterruptFlag == ADDIDATA_DISABLE) */
1273         return 0;
1274 }
1275
1276 static int i_APCI3200_Reset(struct comedi_device *dev)
1277 {
1278         struct addi_private *devpriv = dev->private;
1279         int i_Temp;
1280         unsigned int dw_Dummy;
1281
1282         /* i_InterruptFlag=0; */
1283         /* i_Initialised==0; */
1284         /* i_Count=0; */
1285         /* i_Sum=0; */
1286
1287         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1288         s_BoardInfos[dev->minor].i_Initialised = 0;
1289         s_BoardInfos[dev->minor].i_Count = 0;
1290         s_BoardInfos[dev->minor].i_Sum = 0;
1291         s_BoardInfos[dev->minor].b_StructInitialized = 0;
1292
1293         outl(0x83838383, devpriv->i_IobaseAmcc + 0x60);
1294
1295         /*  Enable the interrupt for the controller */
1296         dw_Dummy = inl(devpriv->i_IobaseAmcc + 0x38);
1297         outl(dw_Dummy | 0x2000, devpriv->i_IobaseAmcc + 0x38);
1298         outl(0, devpriv->i_IobaseAddon);        /* Resets the output */
1299   /***************/
1300         /*Empty the buffer */
1301   /**************/
1302         for (i_Temp = 0; i_Temp <= 95; i_Temp++) {
1303                 /* ui_InterruptChannelValue[i_Temp]=0; */
1304                 s_BoardInfos[dev->minor].ui_InterruptChannelValue[i_Temp] = 0;
1305         }                       /* for(i_Temp=0;i_Temp<=95;i_Temp++) */
1306   /*****************************/
1307         /*Reset the START and IRQ bit */
1308   /*****************************/
1309         for (i_Temp = 0; i_Temp <= 192;) {
1310                 while (((inl(devpriv->iobase + i_Temp + 12) >> 19) & 1) != 1) ;
1311                 outl(0, devpriv->iobase + i_Temp + 8);
1312                 i_Temp = i_Temp + 64;
1313         }                       /* for(i_Temp=0;i_Temp<=192;i_Temp+64) */
1314         return 0;
1315 }
1316
1317 /*
1318  * Read value of the selected channel
1319  *
1320  * data[0]  : Digital Value Of Input
1321  * data[1]  : Calibration Offset Value
1322  * data[2]  : Calibration Gain Value
1323  * data[3]  : CJC value
1324  * data[4]  : CJC offset value
1325  * data[5]  : CJC gain value
1326  * data[6] : CJC current source from eeprom
1327  * data[7] : Channel current source from eeprom
1328  * data[8] : Channle gain factor from eeprom
1329  */
1330 static int i_APCI3200_ReadAnalogInput(struct comedi_device *dev,
1331                                       struct comedi_subdevice *s,
1332                                       struct comedi_insn *insn,
1333                                       unsigned int *data)
1334 {
1335         unsigned int ui_DummyValue = 0;
1336         int i_ConvertCJCCalibration;
1337         int i = 0;
1338
1339         /* BEGIN JK 06.07.04: Management of sevrals boards */
1340         /* if(i_Initialised==0) */
1341         if (s_BoardInfos[dev->minor].i_Initialised == 0)
1342                 /* END JK 06.07.04: Management of sevrals boards */
1343         {
1344                 i_APCI3200_Reset(dev);
1345                 return -EINVAL;
1346         }                       /* if(i_Initialised==0); */
1347
1348 #ifdef PRINT_INFO
1349         printk("\n insn->unused[0] = %i", insn->unused[0]);
1350 #endif
1351
1352         switch (insn->unused[0]) {
1353         case 0:
1354
1355                 i_APCI3200_Read1AnalogInputChannel(dev, s, insn,
1356                         &ui_DummyValue);
1357                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1358                 /* ui_InterruptChannelValue[i_Count+0]=ui_DummyValue; */
1359                 s_BoardInfos[dev->minor].
1360                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1361                         i_Count + 0] = ui_DummyValue;
1362                 /* END JK 06.07.04: Management of sevrals boards */
1363
1364                 /* Begin JK 25.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1365                 i_APCI3200_GetChannelCalibrationValue(dev,
1366                         s_BoardInfos[dev->minor].ui_Channel_num,
1367                         &s_BoardInfos[dev->minor].
1368                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1369                                 i_Count + 6],
1370                         &s_BoardInfos[dev->minor].
1371                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1372                                 i_Count + 7],
1373                         &s_BoardInfos[dev->minor].
1374                         ui_InterruptChannelValue[s_BoardInfos[dev->minor].
1375                                 i_Count + 8]);
1376
1377 #ifdef PRINT_INFO
1378                 printk("\n s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count+6] = %lu", s_BoardInfos[dev->minor].ui_InterruptChannelValue[s_BoardInfos[dev->minor].i_Count + 6]);
1379
1380                 printk("\n s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count+7] = %lu", s_BoardInfos[dev->minor].ui_InterruptChannelValue[s_BoardInfos[dev->minor].i_Count + 7]);
1381
1382                 printk("\n s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count+8] = %lu", s_BoardInfos[dev->minor].ui_InterruptChannelValue[s_BoardInfos[dev->minor].i_Count + 8]);
1383 #endif
1384
1385                 /* End JK 25.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1386
1387                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1388                 /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE) && (i_CJCAvailable==1)) */
1389                 if ((s_BoardInfos[dev->minor].i_ADDIDATAType == 2)
1390                         && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE)
1391                         && (s_BoardInfos[dev->minor].i_CJCAvailable == 1))
1392                         /* END JK 06.07.04: Management of sevrals boards */
1393                 {
1394                         i_APCI3200_ReadCJCValue(dev, &ui_DummyValue);
1395                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1396                         /* ui_InterruptChannelValue[i_Count + 3]=ui_DummyValue; */
1397                         s_BoardInfos[dev->minor].
1398                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1399                                         minor].i_Count + 3] = ui_DummyValue;
1400                         /* END JK 06.07.04: Management of sevrals boards */
1401                 }               /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)) */
1402                 else {
1403                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1404                         /* ui_InterruptChannelValue[i_Count + 3]=0; */
1405                         s_BoardInfos[dev->minor].
1406                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1407                                         minor].i_Count + 3] = 0;
1408                         /* END JK 06.07.04: Management of sevrals boards */
1409                 }               /* elseif((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE) && (i_CJCAvailable==1)) */
1410
1411                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1412                 /* if (( i_AutoCalibration == FALSE) && (i_InterruptFlag == FALSE)) */
1413                 if ((s_BoardInfos[dev->minor].i_AutoCalibration == FALSE)
1414                         && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE))
1415                         /* END JK 06.07.04: Management of sevrals boards */
1416                 {
1417                         i_APCI3200_ReadCalibrationOffsetValue(dev,
1418                                 &ui_DummyValue);
1419                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1420                         /* ui_InterruptChannelValue[i_Count + 1]=ui_DummyValue; */
1421                         s_BoardInfos[dev->minor].
1422                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1423                                         minor].i_Count + 1] = ui_DummyValue;
1424                         /* END JK 06.07.04: Management of sevrals boards */
1425                         i_APCI3200_ReadCalibrationGainValue(dev,
1426                                 &ui_DummyValue);
1427                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1428                         /* ui_InterruptChannelValue[i_Count + 2]=ui_DummyValue; */
1429                         s_BoardInfos[dev->minor].
1430                                 ui_InterruptChannelValue[s_BoardInfos[dev->
1431                                         minor].i_Count + 2] = ui_DummyValue;
1432                         /* END JK 06.07.04: Management of sevrals boards */
1433                 }               /* if (( i_AutoCalibration == FALSE) && (i_InterruptFlag == FALSE)) */
1434
1435                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1436                 /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)&& (i_CJCAvailable==1)) */
1437                 if ((s_BoardInfos[dev->minor].i_ADDIDATAType == 2)
1438                         && (s_BoardInfos[dev->minor].i_InterruptFlag == FALSE)
1439                         && (s_BoardInfos[dev->minor].i_CJCAvailable == 1))
1440                         /* END JK 06.07.04: Management of sevrals boards */
1441                 {
1442           /**********************************************************/
1443                         /*Test if the Calibration channel must be read for the CJC */
1444           /**********************************************************/
1445           /**********************************/
1446                         /*Test if the polarity is the same */
1447           /**********************************/
1448                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1449                         /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
1450                         if (s_BoardInfos[dev->minor].i_CJCPolarity !=
1451                                 s_BoardInfos[dev->minor].i_ADDIDATAPolarity)
1452                                 /* END JK 06.07.04: Management of sevrals boards */
1453                         {
1454                                 i_ConvertCJCCalibration = 1;
1455                         }       /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
1456                         else {
1457                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1458                                 /* if(i_CJCGain==i_ADDIDATAGain) */
1459                                 if (s_BoardInfos[dev->minor].i_CJCGain ==
1460                                         s_BoardInfos[dev->minor].i_ADDIDATAGain)
1461                                         /* END JK 06.07.04: Management of sevrals boards */
1462                                 {
1463                                         i_ConvertCJCCalibration = 0;
1464                                 }       /* if(i_CJCGain==i_ADDIDATAGain) */
1465                                 else {
1466                                         i_ConvertCJCCalibration = 1;
1467                                 }       /* elseif(i_CJCGain==i_ADDIDATAGain) */
1468                         }       /* elseif(i_CJCPolarity!=i_ADDIDATAPolarity) */
1469                         if (i_ConvertCJCCalibration == 1) {
1470                                 i_APCI3200_ReadCJCCalOffset(dev,
1471                                         &ui_DummyValue);
1472                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1473                                 /* ui_InterruptChannelValue[i_Count+4]=ui_DummyValue; */
1474                                 s_BoardInfos[dev->minor].
1475                                         ui_InterruptChannelValue[s_BoardInfos
1476                                         [dev->minor].i_Count + 4] =
1477                                         ui_DummyValue;
1478                                 /* END JK 06.07.04: Management of sevrals boards */
1479
1480                                 i_APCI3200_ReadCJCCalGain(dev, &ui_DummyValue);
1481
1482                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1483                                 /* ui_InterruptChannelValue[i_Count+5]=ui_DummyValue; */
1484                                 s_BoardInfos[dev->minor].
1485                                         ui_InterruptChannelValue[s_BoardInfos
1486                                         [dev->minor].i_Count + 5] =
1487                                         ui_DummyValue;
1488                                 /* END JK 06.07.04: Management of sevrals boards */
1489                         }       /* if(i_ConvertCJCCalibration==1) */
1490                         else {
1491                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1492                                 /* ui_InterruptChannelValue[i_Count+4]=0; */
1493                                 /* ui_InterruptChannelValue[i_Count+5]=0; */
1494
1495                                 s_BoardInfos[dev->minor].
1496                                         ui_InterruptChannelValue[s_BoardInfos
1497                                         [dev->minor].i_Count + 4] = 0;
1498                                 s_BoardInfos[dev->minor].
1499                                         ui_InterruptChannelValue[s_BoardInfos
1500                                         [dev->minor].i_Count + 5] = 0;
1501                                 /* END JK 06.07.04: Management of sevrals boards */
1502                         }       /* elseif(i_ConvertCJCCalibration==1) */
1503                 }               /* if((i_ADDIDATAType==2) && (i_InterruptFlag == FALSE)) */
1504
1505                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1506                 /* if(i_ScanType!=1) */
1507                 if (s_BoardInfos[dev->minor].i_ScanType != 1) {
1508                         /* i_Count=0; */
1509                         s_BoardInfos[dev->minor].i_Count = 0;
1510                 }               /* if(i_ScanType!=1) */
1511                 else {
1512                         /* i_Count=i_Count +6; */
1513                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1514                         /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count +6; */
1515                         s_BoardInfos[dev->minor].i_Count =
1516                                 s_BoardInfos[dev->minor].i_Count + 9;
1517                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1518                 }               /* else if(i_ScanType!=1) */
1519
1520                 /* if((i_ScanType==1) &&(i_InterruptFlag==1)) */
1521                 if ((s_BoardInfos[dev->minor].i_ScanType == 1)
1522                         && (s_BoardInfos[dev->minor].i_InterruptFlag == 1)) {
1523                         /* i_Count=i_Count-6; */
1524                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1525                         /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count-6; */
1526                         s_BoardInfos[dev->minor].i_Count =
1527                                 s_BoardInfos[dev->minor].i_Count - 9;
1528                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1529                 }
1530                 /* if(i_ScanType==0) */
1531                 if (s_BoardInfos[dev->minor].i_ScanType == 0) {
1532                         /*
1533                            data[0]= ui_InterruptChannelValue[0];
1534                            data[1]= ui_InterruptChannelValue[1];
1535                            data[2]= ui_InterruptChannelValue[2];
1536                            data[3]= ui_InterruptChannelValue[3];
1537                            data[4]= ui_InterruptChannelValue[4];
1538                            data[5]= ui_InterruptChannelValue[5];
1539                          */
1540 #ifdef PRINT_INFO
1541                         printk("\n data[0]= s_BoardInfos [dev->minor].ui_InterruptChannelValue[0];");
1542 #endif
1543                         data[0] =
1544                                 s_BoardInfos[dev->minor].
1545                                 ui_InterruptChannelValue[0];
1546                         data[1] =
1547                                 s_BoardInfos[dev->minor].
1548                                 ui_InterruptChannelValue[1];
1549                         data[2] =
1550                                 s_BoardInfos[dev->minor].
1551                                 ui_InterruptChannelValue[2];
1552                         data[3] =
1553                                 s_BoardInfos[dev->minor].
1554                                 ui_InterruptChannelValue[3];
1555                         data[4] =
1556                                 s_BoardInfos[dev->minor].
1557                                 ui_InterruptChannelValue[4];
1558                         data[5] =
1559                                 s_BoardInfos[dev->minor].
1560                                 ui_InterruptChannelValue[5];
1561
1562                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1563                         /* printk("\n 0 - i_APCI3200_GetChannelCalibrationValue data [6] = %lu, data [7] = %lu, data [8] = %lu", data [6], data [7], data [8]); */
1564                         i_APCI3200_GetChannelCalibrationValue(dev,
1565                                 s_BoardInfos[dev->minor].ui_Channel_num,
1566                                 &data[6], &data[7], &data[8]);
1567                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1568                 }
1569                 break;
1570         case 1:
1571
1572                 for (i = 0; i < insn->n; i++) {
1573                         /* data[i]=ui_InterruptChannelValue[i]; */
1574                         data[i] =
1575                                 s_BoardInfos[dev->minor].
1576                                 ui_InterruptChannelValue[i];
1577                 }
1578
1579                 /* i_Count=0; */
1580                 /* i_Sum=0; */
1581                 /* if(i_ScanType==1) */
1582                 s_BoardInfos[dev->minor].i_Count = 0;
1583                 s_BoardInfos[dev->minor].i_Sum = 0;
1584                 if (s_BoardInfos[dev->minor].i_ScanType == 1) {
1585                         /* i_Initialised=0; */
1586                         /* i_InterruptFlag=0; */
1587                         s_BoardInfos[dev->minor].i_Initialised = 0;
1588                         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1589                         /* END JK 06.07.04: Management of sevrals boards */
1590                 }
1591                 break;
1592         default:
1593                 printk("\nThe parameters passed are in error\n");
1594                 i_APCI3200_Reset(dev);
1595                 return -EINVAL;
1596         }                       /* switch(insn->unused[0]) */
1597
1598         return insn->n;
1599 }
1600
1601 /*
1602  * Configures The Analog Input Subdevice
1603  *
1604  * data[0]  = 0  Normal AI
1605  *          = 1  RTD
1606  *          = 2  THERMOCOUPLE
1607  * data[1]  = Gain To Use
1608  * data[2]  = 0  Bipolar
1609  *          = 1  Unipolar
1610  * data[3]  = Offset Range
1611  * data[4]  = 0  DC Coupling
1612  *          = 1  AC Coupling
1613  * data[5]  = 0  Single
1614  *          = 1  Differential
1615  * data[6]  = TimerReloadValue
1616  * data[7]  = ConvertingTimeUnit
1617  * data[8]  = 0  Analog voltage measurement
1618  *          = 1  Resistance measurement
1619  *          = 2  Temperature measurement
1620  * data[9]  = 0  Interrupt Disable
1621  *          = 1  INterrupt Enable
1622  * data[10] = Type of Thermocouple
1623  * data[11] = single channel Module Number
1624  * data[12] = 0  Single Read
1625  *          = 1  Read more channel
1626  *          = 2  Single scan
1627  *          = 3  Continuous Scan
1628  * data[13] = Number of channels to read
1629  * data[14] = 0  RTD not used
1630  *          = 1  RTD 2 wire connection
1631  *          = 2  RTD 3 wire connection
1632  *          = 3  RTD 4 wire connection
1633  */
1634 static int i_APCI3200_ConfigAnalogInput(struct comedi_device *dev,
1635                                         struct comedi_subdevice *s,
1636                                         struct comedi_insn *insn,
1637                                         unsigned int *data)
1638 {
1639         struct addi_private *devpriv = dev->private;
1640         unsigned int ul_Config = 0, ul_Temp = 0;
1641         unsigned int ui_ChannelNo = 0;
1642         unsigned int ui_Dummy = 0;
1643         int i_err = 0;
1644
1645         /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1646
1647 #ifdef PRINT_INFO
1648         int i = 0, i2 = 0;
1649 #endif
1650         /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1651
1652         /* BEGIN JK 06.07.04: Management of sevrals boards */
1653         /*  Initialize the structure */
1654         if (s_BoardInfos[dev->minor].b_StructInitialized != 1) {
1655                 s_BoardInfos[dev->minor].i_CJCAvailable = 1;
1656                 s_BoardInfos[dev->minor].i_CJCPolarity = 0;
1657                 s_BoardInfos[dev->minor].i_CJCGain = 2; /* changed from 0 to 2 */
1658                 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
1659                 s_BoardInfos[dev->minor].i_AutoCalibration = 0; /* : auto calibration */
1660                 s_BoardInfos[dev->minor].i_ChannelCount = 0;
1661                 s_BoardInfos[dev->minor].i_Sum = 0;
1662                 s_BoardInfos[dev->minor].ui_Channel_num = 0;
1663                 s_BoardInfos[dev->minor].i_Count = 0;
1664                 s_BoardInfos[dev->minor].i_Initialised = 0;
1665                 s_BoardInfos[dev->minor].b_StructInitialized = 1;
1666
1667                 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1668                 s_BoardInfos[dev->minor].i_ConnectionType = 0;
1669                 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1670
1671                 /* Begin JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1672                 memset(s_BoardInfos[dev->minor].s_Module, 0,
1673                         sizeof(s_BoardInfos[dev->minor].s_Module[MAX_MODULE]));
1674
1675                 v_GetAPCI3200EepromCalibrationValue(devpriv->i_IobaseAmcc,
1676                         &s_BoardInfos[dev->minor]);
1677
1678 #ifdef PRINT_INFO
1679                 for (i = 0; i < MAX_MODULE; i++) {
1680                         printk("\n s_Module[%i].ul_CurrentSourceCJC = %lu", i,
1681                                 s_BoardInfos[dev->minor].s_Module[i].
1682                                 ul_CurrentSourceCJC);
1683
1684                         for (i2 = 0; i2 < 5; i2++) {
1685                                 printk("\n s_Module[%i].ul_CurrentSource [%i] = %lu", i, i2, s_BoardInfos[dev->minor].s_Module[i].ul_CurrentSource[i2]);
1686                         }
1687
1688                         for (i2 = 0; i2 < 8; i2++) {
1689                                 printk("\n s_Module[%i].ul_GainFactor [%i] = %lu", i, i2, s_BoardInfos[dev->minor].s_Module[i].ul_GainFactor[i2]);
1690                         }
1691
1692                         for (i2 = 0; i2 < 8; i2++) {
1693                                 printk("\n s_Module[%i].w_GainValue [%i] = %u",
1694                                         i, i2,
1695                                         s_BoardInfos[dev->minor].s_Module[i].
1696                                         w_GainValue[i2]);
1697                         }
1698                 }
1699 #endif
1700                 /* End JK 21.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
1701         }
1702
1703         if (data[0] != 0 && data[0] != 1 && data[0] != 2) {
1704                 printk("\nThe selection of acquisition type is in error\n");
1705                 i_err++;
1706         }                       /* if(data[0]!=0 && data[0]!=1 && data[0]!=2) */
1707         if (data[0] == 1) {
1708                 if (data[14] != 0 && data[14] != 1 && data[14] != 2
1709                         && data[14] != 4) {
1710                         printk("\n Error in selection of RTD connection type\n");
1711                         i_err++;
1712                 }               /* if(data[14]!=0 && data[14]!=1 && data[14]!=2 && data[14]!=4) */
1713         }                       /* if(data[0]==1 ) */
1714         if (data[1] < 0 || data[1] > 7) {
1715                 printk("\nThe selection of gain is in error\n");
1716                 i_err++;
1717         }                       /*  if(data[1]<0 || data[1]>7) */
1718         if (data[2] != 0 && data[2] != 1) {
1719                 printk("\nThe selection of polarity is in error\n");
1720                 i_err++;
1721         }                       /* if(data[2]!=0 &&  data[2]!=1) */
1722         if (data[3] != 0) {
1723                 printk("\nThe selection of offset range  is in error\n");
1724                 i_err++;
1725         }                       /*  if(data[3]!=0) */
1726         if (data[4] != 0 && data[4] != 1) {
1727                 printk("\nThe selection of coupling is in error\n");
1728                 i_err++;
1729         }                       /* if(data[4]!=0 &&  data[4]!=1) */
1730         if (data[5] != 0 && data[5] != 1) {
1731                 printk("\nThe selection of single/differential mode is in error\n");
1732                 i_err++;
1733         }                       /* if(data[5]!=0 &&  data[5]!=1) */
1734         if (data[8] != 0 && data[8] != 1 && data[2] != 2) {
1735                 printk("\nError in selection of functionality\n");
1736         }                       /* if(data[8]!=0 && data[8]!=1 && data[2]!=2) */
1737         if (data[12] == 0 || data[12] == 1) {
1738                 if (data[6] != 20 && data[6] != 40 && data[6] != 80
1739                         && data[6] != 160) {
1740                         printk("\nThe selection of conversion time reload value is in error\n");
1741                         i_err++;
1742                 }               /*  if (data[6]!=20 && data[6]!=40 && data[6]!=80 && data[6]!=160 ) */
1743                 if (data[7] != 2) {
1744                         printk("\nThe selection of conversion time unit  is in error\n");
1745                         i_err++;
1746                 }               /*  if(data[7]!=2) */
1747         }
1748         if (data[9] != 0 && data[9] != 1) {
1749                 printk("\nThe selection of interrupt enable is in error\n");
1750                 i_err++;
1751         }                       /* if(data[9]!=0 &&  data[9]!=1) */
1752         if (data[11] < 0 || data[11] > 4) {
1753                 printk("\nThe selection of module is in error\n");
1754                 i_err++;
1755         }                       /* if(data[11] <0 ||  data[11]>1) */
1756         if (data[12] < 0 || data[12] > 3) {
1757                 printk("\nThe selection of singlechannel/scan selection is in error\n");
1758                 i_err++;
1759         }                       /* if(data[12] < 0 ||  data[12]> 3) */
1760         if (data[13] < 0 || data[13] > 16) {
1761                 printk("\nThe selection of number of channels is in error\n");
1762                 i_err++;
1763         }                       /*  if(data[13] <0 ||data[13] >15) */
1764
1765         /* BEGIN JK 06.07.04: Management of sevrals boards */
1766         /*
1767            i_ChannelCount=data[13];
1768            i_ScanType=data[12];
1769            i_ADDIDATAPolarity = data[2];
1770            i_ADDIDATAGain=data[1];
1771            i_ADDIDATAConversionTime=data[6];
1772            i_ADDIDATAConversionTimeUnit=data[7];
1773            i_ADDIDATAType=data[0];
1774          */
1775
1776         /*  Save acquisition configuration for the actual board */
1777         s_BoardInfos[dev->minor].i_ChannelCount = data[13];
1778         s_BoardInfos[dev->minor].i_ScanType = data[12];
1779         s_BoardInfos[dev->minor].i_ADDIDATAPolarity = data[2];
1780         s_BoardInfos[dev->minor].i_ADDIDATAGain = data[1];
1781         s_BoardInfos[dev->minor].i_ADDIDATAConversionTime = data[6];
1782         s_BoardInfos[dev->minor].i_ADDIDATAConversionTimeUnit = data[7];
1783         s_BoardInfos[dev->minor].i_ADDIDATAType = data[0];
1784         /* Begin JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1785         s_BoardInfos[dev->minor].i_ConnectionType = data[5];
1786         /* End JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1787         /* END JK 06.07.04: Management of sevrals boards */
1788
1789         /* Begin JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1790         memset(s_BoardInfos[dev->minor].ui_ScanValueArray, 0, (7 + 12) * sizeof(unsigned int)); /*  7 is the maximal number of channels */
1791         /* End JK 19.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
1792
1793         /* BEGIN JK 02.07.04 : This while can't be do, it block the process when using severals boards */
1794         /* while(i_InterruptFlag==1) */
1795         while (s_BoardInfos[dev->minor].i_InterruptFlag == 1) {
1796 #ifndef MSXBOX
1797                 udelay(1);
1798 #else
1799                 /*  In the case where the driver is compiled for the MSX-Box */
1800                 /*  we used a printk to have a little delay because udelay */
1801                 /*  seems to be broken under the MSX-Box. */
1802                 /*  This solution hat to be studied. */
1803                 printk("");
1804 #endif
1805         }
1806         /* END JK 02.07.04 : This while can't be do, it block the process when using severals boards */
1807
1808         ui_ChannelNo = CR_CHAN(insn->chanspec); /*  get the channel */
1809         /* BEGIN JK 06.07.04: Management of sevrals boards */
1810         /* i_ChannelNo=ui_ChannelNo; */
1811         /* ui_Channel_num =ui_ChannelNo; */
1812
1813         s_BoardInfos[dev->minor].i_ChannelNo = ui_ChannelNo;
1814         s_BoardInfos[dev->minor].ui_Channel_num = ui_ChannelNo;
1815
1816         /* END JK 06.07.04: Management of sevrals boards */
1817
1818         if (data[5] == 0) {
1819                 if (ui_ChannelNo < 0 || ui_ChannelNo > 15) {
1820                         printk("\nThe Selection of the channel is in error\n");
1821                         i_err++;
1822                 }               /*  if(ui_ChannelNo<0 || ui_ChannelNo>15) */
1823         }                       /* if(data[5]==0) */
1824         else {
1825                 if (data[14] == 2) {
1826                         if (ui_ChannelNo < 0 || ui_ChannelNo > 3) {
1827                                 printk("\nThe Selection of the channel is in error\n");
1828                                 i_err++;
1829                         }       /*  if(ui_ChannelNo<0 || ui_ChannelNo>3) */
1830                 }               /* if(data[14]==2) */
1831                 else {
1832                         if (ui_ChannelNo < 0 || ui_ChannelNo > 7) {
1833                                 printk("\nThe Selection of the channel is in error\n");
1834                                 i_err++;
1835                         }       /*  if(ui_ChannelNo<0 || ui_ChannelNo>7) */
1836                 }               /* elseif(data[14]==2) */
1837         }                       /* elseif(data[5]==0) */
1838         if (data[12] == 0 || data[12] == 1) {
1839                 switch (data[5]) {
1840                 case 0:
1841                         if (ui_ChannelNo >= 0 && ui_ChannelNo <= 3) {
1842                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1843                                 /* i_Offset=0; */
1844                                 s_BoardInfos[dev->minor].i_Offset = 0;
1845                                 /* END JK 06.07.04: Management of sevrals boards */
1846                         }       /* if(ui_ChannelNo >=0 && ui_ChannelNo <=3) */
1847                         if (ui_ChannelNo >= 4 && ui_ChannelNo <= 7) {
1848                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1849                                 /* i_Offset=64; */
1850                                 s_BoardInfos[dev->minor].i_Offset = 64;
1851                                 /* END JK 06.07.04: Management of sevrals boards */
1852                         }       /* if(ui_ChannelNo >=4 && ui_ChannelNo <=7) */
1853                         if (ui_ChannelNo >= 8 && ui_ChannelNo <= 11) {
1854                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1855                                 /* i_Offset=128; */
1856                                 s_BoardInfos[dev->minor].i_Offset = 128;
1857                                 /* END JK 06.07.04: Management of sevrals boards */
1858                         }       /* if(ui_ChannelNo >=8 && ui_ChannelNo <=11) */
1859                         if (ui_ChannelNo >= 12 && ui_ChannelNo <= 15) {
1860                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1861                                 /* i_Offset=192; */
1862                                 s_BoardInfos[dev->minor].i_Offset = 192;
1863                                 /* END JK 06.07.04: Management of sevrals boards */
1864                         }       /* if(ui_ChannelNo >=12 && ui_ChannelNo <=15) */
1865                         break;
1866                 case 1:
1867                         if (data[14] == 2) {
1868                                 if (ui_ChannelNo == 0) {
1869                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1870                                         /* i_Offset=0; */
1871                                         s_BoardInfos[dev->minor].i_Offset = 0;
1872                                         /* END JK 06.07.04: Management of sevrals boards */
1873                                 }       /* if(ui_ChannelNo ==0 ) */
1874                                 if (ui_ChannelNo == 1) {
1875                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1876                                         /* i_Offset=0; */
1877                                         s_BoardInfos[dev->minor].i_Offset = 64;
1878                                         /* END JK 06.07.04: Management of sevrals boards */
1879                                 }       /*  if(ui_ChannelNo ==1) */
1880                                 if (ui_ChannelNo == 2) {
1881                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1882                                         /* i_Offset=128; */
1883                                         s_BoardInfos[dev->minor].i_Offset = 128;
1884                                         /* END JK 06.07.04: Management of sevrals boards */
1885                                 }       /* if(ui_ChannelNo ==2 ) */
1886                                 if (ui_ChannelNo == 3) {
1887                                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1888                                         /* i_Offset=192; */
1889                                         s_BoardInfos[dev->minor].i_Offset = 192;
1890                                         /* END JK 06.07.04: Management of sevrals boards */
1891                                 }       /* if(ui_ChannelNo ==3) */
1892
1893                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1894                                 /* i_ChannelNo=0; */
1895                                 s_BoardInfos[dev->minor].i_ChannelNo = 0;
1896                                 /* END JK 06.07.04: Management of sevrals boards */
1897                                 ui_ChannelNo = 0;
1898                                 break;
1899                         }       /* if(data[14]==2) */
1900                         if (ui_ChannelNo >= 0 && ui_ChannelNo <= 1) {
1901                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1902                                 /* i_Offset=0; */
1903                                 s_BoardInfos[dev->minor].i_Offset = 0;
1904                                 /* END JK 06.07.04: Management of sevrals boards */
1905                         }       /* if(ui_ChannelNo >=0 && ui_ChannelNo <=1) */
1906                         if (ui_ChannelNo >= 2 && ui_ChannelNo <= 3) {
1907                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1908                                 /* i_ChannelNo=i_ChannelNo-2; */
1909                                 /* i_Offset=64; */
1910                                 s_BoardInfos[dev->minor].i_ChannelNo =
1911                                         s_BoardInfos[dev->minor].i_ChannelNo -
1912                                         2;
1913                                 s_BoardInfos[dev->minor].i_Offset = 64;
1914                                 /* END JK 06.07.04: Management of sevrals boards */
1915                                 ui_ChannelNo = ui_ChannelNo - 2;
1916                         }       /* if(ui_ChannelNo >=2 && ui_ChannelNo <=3) */
1917                         if (ui_ChannelNo >= 4 && ui_ChannelNo <= 5) {
1918                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1919                                 /* i_ChannelNo=i_ChannelNo-4; */
1920                                 /* i_Offset=128; */
1921                                 s_BoardInfos[dev->minor].i_ChannelNo =
1922                                         s_BoardInfos[dev->minor].i_ChannelNo -
1923                                         4;
1924                                 s_BoardInfos[dev->minor].i_Offset = 128;
1925                                 /* END JK 06.07.04: Management of sevrals boards */
1926                                 ui_ChannelNo = ui_ChannelNo - 4;
1927                         }       /* if(ui_ChannelNo >=4 && ui_ChannelNo <=5) */
1928                         if (ui_ChannelNo >= 6 && ui_ChannelNo <= 7) {
1929                                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1930                                 /* i_ChannelNo=i_ChannelNo-6; */
1931                                 /* i_Offset=192; */
1932                                 s_BoardInfos[dev->minor].i_ChannelNo =
1933                                         s_BoardInfos[dev->minor].i_ChannelNo -
1934                                         6;
1935                                 s_BoardInfos[dev->minor].i_Offset = 192;
1936                                 /* END JK 06.07.04: Management of sevrals boards */
1937                                 ui_ChannelNo = ui_ChannelNo - 6;
1938                         }       /* if(ui_ChannelNo >=6 && ui_ChannelNo <=7) */
1939                         break;
1940
1941                 default:
1942                         printk("\n This selection of polarity does not exist\n");
1943                         i_err++;
1944                 }               /* switch(data[2]) */
1945         }                       /* if(data[12]==0 || data[12]==1) */
1946         else {
1947                 switch (data[11]) {
1948                 case 1:
1949                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1950                         /* i_Offset=0; */
1951                         s_BoardInfos[dev->minor].i_Offset = 0;
1952                         /* END JK 06.07.04: Management of sevrals boards */
1953                         break;
1954                 case 2:
1955                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1956                         /* i_Offset=64; */
1957                         s_BoardInfos[dev->minor].i_Offset = 64;
1958                         /* END JK 06.07.04: Management of sevrals boards */
1959                         break;
1960                 case 3:
1961                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1962                         /* i_Offset=128; */
1963                         s_BoardInfos[dev->minor].i_Offset = 128;
1964                         /* END JK 06.07.04: Management of sevrals boards */
1965                         break;
1966                 case 4:
1967                         /* BEGIN JK 06.07.04: Management of sevrals boards */
1968                         /* i_Offset=192; */
1969                         s_BoardInfos[dev->minor].i_Offset = 192;
1970                         /* END JK 06.07.04: Management of sevrals boards */
1971                         break;
1972                 default:
1973                         printk("\nError in module selection\n");
1974                         i_err++;
1975                 }               /*  switch(data[11]) */
1976         }                       /*  elseif(data[12]==0 || data[12]==1) */
1977         if (i_err) {
1978                 i_APCI3200_Reset(dev);
1979                 return -EINVAL;
1980         }
1981         /* if(i_ScanType!=1) */
1982         if (s_BoardInfos[dev->minor].i_ScanType != 1) {
1983                 /* BEGIN JK 06.07.04: Management of sevrals boards */
1984                 /* i_Count=0; */
1985                 /* i_Sum=0; */
1986                 s_BoardInfos[dev->minor].i_Count = 0;
1987                 s_BoardInfos[dev->minor].i_Sum = 0;
1988                 /* END JK 06.07.04: Management of sevrals boards */
1989         }                       /* if(i_ScanType!=1) */
1990
1991         ul_Config =
1992                 data[1] | (data[2] << 6) | (data[5] << 7) | (data[3] << 8) |
1993                 (data[4] << 9);
1994         /* BEGIN JK 06.07.04: Management of sevrals boards */
1995         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
1996         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
1997                                         12) >> 19) & 1) != 1) ;
1998         /* END JK 06.07.04: Management of sevrals boards */
1999   /*********************************/
2000         /* Write the channel to configure */
2001   /*********************************/
2002         /* BEGIN JK 06.07.04: Management of sevrals boards */
2003         /* outl(0 | ui_ChannelNo , devpriv->iobase+i_Offset + 0x4); */
2004         outl(0 | ui_ChannelNo,
2005                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x4);
2006         /* END JK 06.07.04: Management of sevrals boards */
2007
2008         /* BEGIN JK 06.07.04: Management of sevrals boards */
2009         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2010         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2011                                         12) >> 19) & 1) != 1) ;
2012         /* END JK 06.07.04: Management of sevrals boards */
2013   /**************************/
2014         /* Reset the configuration */
2015   /**************************/
2016         /* BEGIN JK 06.07.04: Management of sevrals boards */
2017         /* outl(0 , devpriv->iobase+i_Offset + 0x0); */
2018         outl(0, devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x0);
2019         /* END JK 06.07.04: Management of sevrals boards */
2020
2021         /* BEGIN JK 06.07.04: Management of sevrals boards */
2022         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2023         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2024                                         12) >> 19) & 1) != 1) ;
2025         /* END JK 06.07.04: Management of sevrals boards */
2026
2027   /***************************/
2028         /* Write the configuration */
2029   /***************************/
2030         /* BEGIN JK 06.07.04: Management of sevrals boards */
2031         /* outl(ul_Config , devpriv->iobase+i_Offset + 0x0); */
2032         outl(ul_Config,
2033                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x0);
2034         /* END JK 06.07.04: Management of sevrals boards */
2035
2036   /***************************/
2037         /*Reset the calibration bit */
2038   /***************************/
2039         /* BEGIN JK 06.07.04: Management of sevrals boards */
2040         /* ul_Temp = inl(devpriv->iobase+i_Offset + 12); */
2041         ul_Temp = inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2042         /* END JK 06.07.04: Management of sevrals boards */
2043
2044         /* BEGIN JK 06.07.04: Management of sevrals boards */
2045         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2046         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2047                                         12) >> 19) & 1) != 1) ;
2048         /* END JK 06.07.04: Management of sevrals boards */
2049
2050         /* BEGIN JK 06.07.04: Management of sevrals boards */
2051         /* outl((ul_Temp & 0xFFF9FFFF) , devpriv->iobase+.i_Offset + 12); */
2052         outl((ul_Temp & 0xFFF9FFFF),
2053                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2054         /* END JK 06.07.04: Management of sevrals boards */
2055
2056         if (data[9] == 1) {
2057                 devpriv->tsk_Current = current;
2058                 /* BEGIN JK 06.07.04: Management of sevrals boards */
2059                 /* i_InterruptFlag=1; */
2060                 s_BoardInfos[dev->minor].i_InterruptFlag = 1;
2061                 /* END JK 06.07.04: Management of sevrals boards */
2062         }                       /*  if(data[9]==1) */
2063         else {
2064                 /* BEGIN JK 06.07.04: Management of sevrals boards */
2065                 /* i_InterruptFlag=0; */
2066                 s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2067                 /* END JK 06.07.04: Management of sevrals boards */
2068         }                       /* else  if(data[9]==1) */
2069
2070         /* BEGIN JK 06.07.04: Management of sevrals boards */
2071         /* i_Initialised=1; */
2072         s_BoardInfos[dev->minor].i_Initialised = 1;
2073         /* END JK 06.07.04: Management of sevrals boards */
2074
2075         /* BEGIN JK 06.07.04: Management of sevrals boards */
2076         /* if(i_ScanType==1) */
2077         if (s_BoardInfos[dev->minor].i_ScanType == 1)
2078                 /* END JK 06.07.04: Management of sevrals boards */
2079         {
2080                 /* BEGIN JK 06.07.04: Management of sevrals boards */
2081                 /* i_Sum=i_Sum+1; */
2082                 s_BoardInfos[dev->minor].i_Sum =
2083                         s_BoardInfos[dev->minor].i_Sum + 1;
2084                 /* END JK 06.07.04: Management of sevrals boards */
2085
2086                 insn->unused[0] = 0;
2087                 i_APCI3200_ReadAnalogInput(dev, s, insn, &ui_Dummy);
2088         }
2089
2090         return insn->n;
2091 }
2092
2093 /*
2094  * Tests the Selected Anlog Input Channel
2095  *
2096  * data[0] = 0  TestAnalogInputShortCircuit
2097  *         = 1  TestAnalogInputConnection
2098  *
2099  * data[0] : Digital value obtained
2100  * data[1] : calibration offset
2101  * data[2] : calibration gain
2102  */
2103 static int i_APCI3200_InsnBits_AnalogInput_Test(struct comedi_device *dev,
2104                                                 struct comedi_subdevice *s,
2105                                                 struct comedi_insn *insn,
2106                                                 unsigned int *data)
2107 {
2108         struct addi_private *devpriv = dev->private;
2109         unsigned int ui_Configuration = 0;
2110         int i_Temp;             /* ,i_TimeUnit; */
2111
2112         /* if(i_Initialised==0) */
2113
2114         if (s_BoardInfos[dev->minor].i_Initialised == 0) {
2115                 i_APCI3200_Reset(dev);
2116                 return -EINVAL;
2117         }                       /* if(i_Initialised==0); */
2118         if (data[0] != 0 && data[0] != 1) {
2119                 printk("\nError in selection of functionality\n");
2120                 i_APCI3200_Reset(dev);
2121                 return -EINVAL;
2122         }                       /* if(data[0]!=0 && data[0]!=1) */
2123
2124         if (data[0] == 1)       /* Perform Short Circuit TEST */
2125         {
2126       /**************************/
2127                 /*Set the short-cicuit bit */
2128       /**************************/
2129                 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2130                 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2131                                                 i_Offset + 12) >> 19) & 1) !=
2132                         1) ;
2133                 /* outl((0x00001000 |i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2134                 outl((0x00001000 | s_BoardInfos[dev->minor].i_ChannelNo),
2135                         devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2136                         4);
2137       /*************************/
2138                 /*Set the time unit to ns */
2139       /*************************/
2140                 /* i_TimeUnit= i_ADDIDATAConversionTimeUnit;
2141                    i_ADDIDATAConversionTimeUnit= 1; */
2142                 /* i_Temp= i_InterruptFlag ; */
2143                 i_Temp = s_BoardInfos[dev->minor].i_InterruptFlag;
2144                 /* i_InterruptFlag = ADDIDATA_DISABLE; */
2145                 s_BoardInfos[dev->minor].i_InterruptFlag = ADDIDATA_DISABLE;
2146                 i_APCI3200_Read1AnalogInputChannel(dev, s, insn, data);
2147                 /* if(i_AutoCalibration == FALSE) */
2148                 if (s_BoardInfos[dev->minor].i_AutoCalibration == FALSE) {
2149                         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2150                         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2151                                                         i_Offset +
2152                                                         12) >> 19) & 1) != 1) ;
2153
2154                         /* outl((0x00001000 |i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2155                         outl((0x00001000 | s_BoardInfos[dev->minor].
2156                                         i_ChannelNo),
2157                                 devpriv->iobase +
2158                                 s_BoardInfos[dev->minor].i_Offset + 4);
2159                         data++;
2160                         i_APCI3200_ReadCalibrationOffsetValue(dev, data);
2161                         data++;
2162                         i_APCI3200_ReadCalibrationGainValue(dev, data);
2163                 }
2164         } else {
2165                 /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2166                 while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2167                                                 i_Offset + 12) >> 19) & 1) !=
2168                         1) ;
2169                 /* outl((0x00000800|i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2170                 outl((0x00000800 | s_BoardInfos[dev->minor].i_ChannelNo),
2171                         devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2172                         4);
2173                 /* ui_Configuration = inl(devpriv->iobase+i_Offset + 0); */
2174                 ui_Configuration =
2175                         inl(devpriv->iobase +
2176                         s_BoardInfos[dev->minor].i_Offset + 0);
2177       /*************************/
2178                 /*Set the time unit to ns */
2179       /*************************/
2180                 /* i_TimeUnit= i_ADDIDATAConversionTimeUnit;
2181                    i_ADDIDATAConversionTimeUnit= 1; */
2182                 /* i_Temp= i_InterruptFlag ; */
2183                 i_Temp = s_BoardInfos[dev->minor].i_InterruptFlag;
2184                 /* i_InterruptFlag = ADDIDATA_DISABLE; */
2185                 s_BoardInfos[dev->minor].i_InterruptFlag = ADDIDATA_DISABLE;
2186                 i_APCI3200_Read1AnalogInputChannel(dev, s, insn, data);
2187                 /* if(i_AutoCalibration == FALSE) */
2188                 if (s_BoardInfos[dev->minor].i_AutoCalibration == FALSE) {
2189                         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2190                         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].
2191                                                         i_Offset +
2192                                                         12) >> 19) & 1) != 1) ;
2193                         /* outl((0x00000800|i_ChannelNo) , devpriv->iobase+i_Offset + 4); */
2194                         outl((0x00000800 | s_BoardInfos[dev->minor].
2195                                         i_ChannelNo),
2196                                 devpriv->iobase +
2197                                 s_BoardInfos[dev->minor].i_Offset + 4);
2198                         data++;
2199                         i_APCI3200_ReadCalibrationOffsetValue(dev, data);
2200                         data++;
2201                         i_APCI3200_ReadCalibrationGainValue(dev, data);
2202                 }
2203         }
2204         /* i_InterruptFlag=i_Temp ; */
2205         s_BoardInfos[dev->minor].i_InterruptFlag = i_Temp;
2206         /* printk("\ni_InterruptFlag=%d\n",i_InterruptFlag); */
2207         return insn->n;
2208 }
2209
2210 static int i_APCI3200_InsnWriteReleaseAnalogInput(struct comedi_device *dev,
2211                                                   struct comedi_subdevice *s,
2212                                                   struct comedi_insn *insn,
2213                                                   unsigned int *data)
2214 {
2215         i_APCI3200_Reset(dev);
2216         return insn->n;
2217 }
2218
2219 static int i_APCI3200_CommandTestAnalogInput(struct comedi_device *dev,
2220                                              struct comedi_subdevice *s,
2221                                              struct comedi_cmd *cmd)
2222 {
2223
2224         int err = 0;
2225         unsigned int ui_ConvertTime = 0;
2226         unsigned int ui_ConvertTimeBase = 0;
2227         unsigned int ui_DelayTime = 0;
2228         unsigned int ui_DelayTimeBase = 0;
2229         int i_Triggermode = 0;
2230         int i_TriggerEdge = 0;
2231         int i_NbrOfChannel = 0;
2232         int i_Cpt = 0;
2233         double d_ConversionTimeForAllChannels = 0.0;
2234         double d_SCANTimeNewUnit = 0.0;
2235
2236         /* Step 1 : check if triggers are trivially valid */
2237
2238         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
2239         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
2240                                         TRIG_TIMER | TRIG_FOLLOW);
2241         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
2242         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
2243         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
2244
2245         if (s_BoardInfos[dev->minor].i_InterruptFlag == 0)
2246                 err |= -EINVAL;
2247
2248         if (err) {
2249                 i_APCI3200_Reset(dev);
2250                 return 1;
2251         }
2252
2253         /* Step 2a : make sure trigger sources are unique */
2254
2255         err |= cfc_check_trigger_is_unique(&cmd->start_src);
2256         err |= cfc_check_trigger_is_unique(&cmd->scan_begin_src);
2257         err |= cfc_check_trigger_is_unique(&cmd->stop_src);
2258
2259         /* Step 2b : and mutually compatible */
2260
2261         if (cmd->start_src == TRIG_EXT) {
2262                 i_TriggerEdge = cmd->start_arg & 0xFFFF;
2263                 i_Triggermode = cmd->start_arg >> 16;
2264                 if (i_TriggerEdge < 1 || i_TriggerEdge > 3) {
2265                         err++;
2266                         printk("\nThe trigger edge selection is in error\n");
2267                 }
2268                 if (i_Triggermode != 2) {
2269                         err++;
2270                         printk("\nThe trigger mode selection is in error\n");
2271                 }
2272         }
2273
2274         if (err) {
2275                 i_APCI3200_Reset(dev);
2276                 return 2;
2277         }
2278         /* i_FirstChannel=cmd->chanlist[0]; */
2279         s_BoardInfos[dev->minor].i_FirstChannel = cmd->chanlist[0];
2280         /* i_LastChannel=cmd->chanlist[1]; */
2281         s_BoardInfos[dev->minor].i_LastChannel = cmd->chanlist[1];
2282
2283         if (cmd->convert_src == TRIG_TIMER) {
2284                 ui_ConvertTime = cmd->convert_arg & 0xFFFF;
2285                 ui_ConvertTimeBase = cmd->convert_arg >> 16;
2286                 if (ui_ConvertTime != 20 && ui_ConvertTime != 40
2287                         && ui_ConvertTime != 80 && ui_ConvertTime != 160)
2288                 {
2289                         printk("\nThe selection of conversion time reload value is in error\n");
2290                         err++;
2291                 }               /*  if (ui_ConvertTime!=20 && ui_ConvertTime!=40 && ui_ConvertTime!=80 && ui_ConvertTime!=160 ) */
2292                 if (ui_ConvertTimeBase != 2) {
2293                         printk("\nThe selection of conversion time unit  is in error\n");
2294                         err++;
2295                 }               /* if(ui_ConvertTimeBase!=2) */
2296         } else {
2297                 ui_ConvertTime = 0;
2298                 ui_ConvertTimeBase = 0;
2299         }
2300         if (cmd->scan_begin_src == TRIG_FOLLOW) {
2301                 ui_DelayTime = 0;
2302                 ui_DelayTimeBase = 0;
2303         }                       /* if(cmd->scan_begin_src==TRIG_FOLLOW) */
2304         else {
2305                 ui_DelayTime = cmd->scan_begin_arg & 0xFFFF;
2306                 ui_DelayTimeBase = cmd->scan_begin_arg >> 16;
2307                 if (ui_DelayTimeBase != 2 && ui_DelayTimeBase != 3) {
2308                         err++;
2309                         printk("\nThe Delay time base selection is in error\n");
2310                 }
2311                 if (ui_DelayTime < 1 || ui_DelayTime > 1023) {
2312                         err++;
2313                         printk("\nThe Delay time value is in error\n");
2314                 }
2315                 if (err) {
2316                         i_APCI3200_Reset(dev);
2317                         return 3;
2318                 }
2319                 fpu_begin();
2320                 d_SCANTimeNewUnit = (double)ui_DelayTime;
2321                 /* i_NbrOfChannel= i_LastChannel-i_FirstChannel + 4; */
2322                 i_NbrOfChannel =
2323                         s_BoardInfos[dev->minor].i_LastChannel -
2324                         s_BoardInfos[dev->minor].i_FirstChannel + 4;
2325       /**********************************************************/
2326                 /*calculate the total conversion time for all the channels */
2327       /**********************************************************/
2328                 d_ConversionTimeForAllChannels =
2329                         (double)((double)ui_ConvertTime /
2330                         (double)i_NbrOfChannel);
2331
2332       /*******************************/
2333                 /*Convert the frequence in time */
2334       /*******************************/
2335                 d_ConversionTimeForAllChannels =
2336                         (double)1.0 / d_ConversionTimeForAllChannels;
2337                 ui_ConvertTimeBase = 3;
2338       /***********************************/
2339                 /*Test if the time unit is the same */
2340       /***********************************/
2341
2342                 if (ui_DelayTimeBase <= ui_ConvertTimeBase) {
2343
2344                         for (i_Cpt = 0;
2345                                 i_Cpt < (ui_ConvertTimeBase - ui_DelayTimeBase);
2346                                 i_Cpt++) {
2347
2348                                 d_ConversionTimeForAllChannels =
2349                                         d_ConversionTimeForAllChannels * 1000;
2350                                 d_ConversionTimeForAllChannels =
2351                                         d_ConversionTimeForAllChannels + 1;
2352                         }
2353                 } else {
2354                         for (i_Cpt = 0;
2355                                 i_Cpt < (ui_DelayTimeBase - ui_ConvertTimeBase);
2356                                 i_Cpt++) {
2357                                 d_SCANTimeNewUnit = d_SCANTimeNewUnit * 1000;
2358
2359                         }
2360                 }
2361
2362                 if (d_ConversionTimeForAllChannels >= d_SCANTimeNewUnit) {
2363
2364                         printk("\nSCAN Delay value cannot be used\n");
2365           /*********************************/
2366                         /*SCAN Delay value cannot be used */
2367           /*********************************/
2368                         err++;
2369                 }
2370                 fpu_end();
2371         }                       /* else if(cmd->scan_begin_src==TRIG_FOLLOW) */
2372
2373         if (err) {
2374                 i_APCI3200_Reset(dev);
2375                 return 4;
2376         }
2377
2378         return 0;
2379 }
2380
2381 static int i_APCI3200_StopCyclicAcquisition(struct comedi_device *dev,
2382                                             struct comedi_subdevice *s)
2383 {
2384         struct addi_private *devpriv = dev->private;
2385         unsigned int ui_Configuration = 0;
2386
2387         /* i_InterruptFlag=0; */
2388         /* i_Initialised=0; */
2389         /* i_Count=0; */
2390         /* i_Sum=0; */
2391         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2392         s_BoardInfos[dev->minor].i_Initialised = 0;
2393         s_BoardInfos[dev->minor].i_Count = 0;
2394         s_BoardInfos[dev->minor].i_Sum = 0;
2395
2396   /*******************/
2397         /*Read the register */
2398   /*******************/
2399         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 8); */
2400         ui_Configuration =
2401                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2402   /*****************************/
2403         /*Reset the START and IRQ bit */
2404   /*****************************/
2405         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2406         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2407                                         12) >> 19) & 1) != 1) ;
2408         /* outl((ui_Configuration & 0xFFE7FFFF),devpriv->iobase+i_Offset + 8); */
2409         outl((ui_Configuration & 0xFFE7FFFF),
2410                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2411         return 0;
2412 }
2413
2414 /*
2415  * Does asynchronous acquisition
2416  * Determines the mode 1 or 2.
2417  */
2418 static int i_APCI3200_CommandAnalogInput(struct comedi_device *dev,
2419                                          struct comedi_subdevice *s)
2420 {
2421         struct addi_private *devpriv = dev->private;
2422         struct comedi_cmd *cmd = &s->async->cmd;
2423         unsigned int ui_Configuration = 0;
2424         /* INT  i_CurrentSource = 0; */
2425         unsigned int ui_Trigger = 0;
2426         unsigned int ui_TriggerEdge = 0;
2427         unsigned int ui_Triggermode = 0;
2428         unsigned int ui_ScanMode = 0;
2429         unsigned int ui_ConvertTime = 0;
2430         unsigned int ui_ConvertTimeBase = 0;
2431         unsigned int ui_DelayTime = 0;
2432         unsigned int ui_DelayTimeBase = 0;
2433         unsigned int ui_DelayMode = 0;
2434
2435         /* i_FirstChannel=cmd->chanlist[0]; */
2436         /* i_LastChannel=cmd->chanlist[1]; */
2437         s_BoardInfos[dev->minor].i_FirstChannel = cmd->chanlist[0];
2438         s_BoardInfos[dev->minor].i_LastChannel = cmd->chanlist[1];
2439         if (cmd->start_src == TRIG_EXT) {
2440                 ui_Trigger = 1;
2441                 ui_TriggerEdge = cmd->start_arg & 0xFFFF;
2442                 ui_Triggermode = cmd->start_arg >> 16;
2443         }                       /* if(cmd->start_src==TRIG_EXT) */
2444         else {
2445                 ui_Trigger = 0;
2446         }                       /* elseif(cmd->start_src==TRIG_EXT) */
2447
2448         if (cmd->stop_src == TRIG_COUNT) {
2449                 ui_ScanMode = 0;
2450         }                       /*  if (cmd->stop_src==TRIG_COUNT) */
2451         else {
2452                 ui_ScanMode = 2;
2453         }                       /* else if (cmd->stop_src==TRIG_COUNT) */
2454
2455         if (cmd->scan_begin_src == TRIG_FOLLOW) {
2456                 ui_DelayTime = 0;
2457                 ui_DelayTimeBase = 0;
2458                 ui_DelayMode = 0;
2459         }                       /* if(cmd->scan_begin_src==TRIG_FOLLOW) */
2460         else {
2461                 ui_DelayTime = cmd->scan_begin_arg & 0xFFFF;
2462                 ui_DelayTimeBase = cmd->scan_begin_arg >> 16;
2463                 ui_DelayMode = 1;
2464         }                       /* else if(cmd->scan_begin_src==TRIG_FOLLOW) */
2465         /*         printk("\nui_DelayTime=%u\n",ui_DelayTime); */
2466         /*         printk("\nui_DelayTimeBase=%u\n",ui_DelayTimeBase); */
2467         if (cmd->convert_src == TRIG_TIMER) {
2468                 ui_ConvertTime = cmd->convert_arg & 0xFFFF;
2469                 ui_ConvertTimeBase = cmd->convert_arg >> 16;
2470         } else {
2471                 ui_ConvertTime = 0;
2472                 ui_ConvertTimeBase = 0;
2473         }
2474
2475         /*  if(i_ADDIDATAType ==1 || ((i_ADDIDATAType==2))) */
2476         /*    { */
2477   /**************************************************/
2478         /*Read the old configuration of the current source */
2479   /**************************************************/
2480         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 12); */
2481         ui_Configuration =
2482                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2483   /***********************************************/
2484         /*Write the configuration of the current source */
2485   /***********************************************/
2486         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2487         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2488                                         12) >> 19) & 1) != 1) ;
2489         /* outl((ui_Configuration & 0xFFC00000 ), devpriv->iobase+i_Offset +12); */
2490         outl((ui_Configuration & 0xFFC00000),
2491                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 12);
2492         /*  } */
2493         ui_Configuration = 0;
2494         /*      printk("\nfirstchannel=%u\n",i_FirstChannel); */
2495         /*      printk("\nlastchannel=%u\n",i_LastChannel); */
2496         /*      printk("\nui_Trigger=%u\n",ui_Trigger); */
2497         /*      printk("\nui_TriggerEdge=%u\n",ui_TriggerEdge); */
2498         /*      printk("\nui_Triggermode=%u\n",ui_Triggermode); */
2499         /*       printk("\nui_DelayMode=%u\n",ui_DelayMode); */
2500         /*      printk("\nui_ScanMode=%u\n",ui_ScanMode); */
2501
2502         /* ui_Configuration = i_FirstChannel |(i_LastChannel << 8)| 0x00100000 | */
2503         ui_Configuration =
2504                 s_BoardInfos[dev->minor].i_FirstChannel | (s_BoardInfos[dev->
2505                         minor].
2506                 i_LastChannel << 8) | 0x00100000 | (ui_Trigger << 24) |
2507                 (ui_TriggerEdge << 25) | (ui_Triggermode << 27) | (ui_DelayMode
2508                 << 18) | (ui_ScanMode << 16);
2509
2510   /*************************/
2511         /*Write the Configuration */
2512   /*************************/
2513         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2514         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2515                                         12) >> 19) & 1) != 1) ;
2516         /* outl( ui_Configuration, devpriv->iobase+i_Offset + 0x8); */
2517         outl(ui_Configuration,
2518                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 0x8);
2519   /***********************/
2520         /*Write the Delay Value */
2521   /***********************/
2522         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2523         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2524                                         12) >> 19) & 1) != 1) ;
2525         /* outl(ui_DelayTime,devpriv->iobase+i_Offset + 40); */
2526         outl(ui_DelayTime,
2527                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 40);
2528   /***************************/
2529         /*Write the Delay time base */
2530   /***************************/
2531         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2532         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2533                                         12) >> 19) & 1) != 1) ;
2534         /* outl(ui_DelayTimeBase,devpriv->iobase+i_Offset + 44); */
2535         outl(ui_DelayTimeBase,
2536                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 44);
2537   /*********************************/
2538         /*Write the conversion time value */
2539   /*********************************/
2540         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2541         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2542                                         12) >> 19) & 1) != 1) ;
2543         /* outl(ui_ConvertTime,devpriv->iobase+i_Offset + 32); */
2544         outl(ui_ConvertTime,
2545                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 32);
2546
2547   /********************************/
2548         /*Write the conversion time base */
2549   /********************************/
2550         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2551         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2552                                         12) >> 19) & 1) != 1) ;
2553         /* outl(ui_ConvertTimeBase,devpriv->iobase+i_Offset + 36); */
2554         outl(ui_ConvertTimeBase,
2555                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 36);
2556   /*******************/
2557         /*Read the register */
2558   /*******************/
2559         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 4); */
2560         ui_Configuration =
2561                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
2562   /******************/
2563         /*Set the SCAN bit */
2564   /******************/
2565         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2566         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2567                                         12) >> 19) & 1) != 1) ;
2568
2569         /* outl(((ui_Configuration & 0x1E0FF) | 0x00002000),devpriv->iobase+i_Offset + 4); */
2570         outl(((ui_Configuration & 0x1E0FF) | 0x00002000),
2571                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 4);
2572   /*******************/
2573         /*Read the register */
2574   /*******************/
2575         ui_Configuration = 0;
2576         /* ui_Configuration = inl(devpriv->iobase+i_Offset + 8); */
2577         ui_Configuration =
2578                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2579
2580   /*******************/
2581         /*Set the START bit */
2582   /*******************/
2583         /* while (((inl(devpriv->iobase+i_Offset+12)>>19) & 1) != 1); */
2584         while (((inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset +
2585                                         12) >> 19) & 1) != 1) ;
2586         /* outl((ui_Configuration | 0x00080000),devpriv->iobase+i_Offset + 8); */
2587         outl((ui_Configuration | 0x00080000),
2588                 devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 8);
2589         return 0;
2590 }
2591
2592 /*
2593  * This function copies the acquired data(from FIFO) to Comedi buffer.
2594  */
2595 static int i_APCI3200_InterruptHandleEos(struct comedi_device *dev)
2596 {
2597         struct addi_private *devpriv = dev->private;
2598         unsigned int ui_StatusRegister = 0;
2599         struct comedi_subdevice *s = &dev->subdevices[0];
2600
2601         /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2602         /* comedi_async *async = s->async; */
2603         /* UINT *data; */
2604         /* data=async->data+async->buf_int_ptr;//new samples added from here onwards */
2605         int n = 0, i = 0;
2606         /* END JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2607
2608   /************************************/
2609         /*Read the interrupt status register */
2610   /************************************/
2611         /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2612         ui_StatusRegister =
2613                 inl(devpriv->iobase + s_BoardInfos[dev->minor].i_Offset + 16);
2614
2615   /*************************/
2616         /*Test if interrupt occur */
2617   /*************************/
2618
2619         if ((ui_StatusRegister & 0x2) == 0x2) {
2620       /*************************/
2621                 /*Read the channel number */
2622       /*************************/
2623                 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2624                 /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2625                 /* This value is not used */
2626                 /* ui_ChannelNumber = inl(devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 24); */
2627                 s->async->events = 0;
2628                 /* END JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2629
2630       /*************************************/
2631                 /*Read the digital Analog Input value */
2632       /*************************************/
2633
2634                 /* data[i_Count] = inl(devpriv->iobase+i_Offset + 28); */
2635                 /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2636                 /* data[s_BoardInfos [dev->minor].i_Count] = inl(devpriv->iobase+s_BoardInfos [dev->minor].i_Offset + 28); */
2637                 s_BoardInfos[dev->minor].ui_ScanValueArray[s_BoardInfos[dev->
2638                                 minor].i_Count] =
2639                         inl(devpriv->iobase +
2640                         s_BoardInfos[dev->minor].i_Offset + 28);
2641                 /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2642
2643                 /* if((i_Count == (i_LastChannel-i_FirstChannel+3))) */
2644                 if ((s_BoardInfos[dev->minor].i_Count ==
2645                                 (s_BoardInfos[dev->minor].i_LastChannel -
2646                                         s_BoardInfos[dev->minor].
2647                                         i_FirstChannel + 3))) {
2648
2649                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2650                         s_BoardInfos[dev->minor].i_Count++;
2651
2652                         for (i = s_BoardInfos[dev->minor].i_FirstChannel;
2653                                 i <= s_BoardInfos[dev->minor].i_LastChannel;
2654                                 i++) {
2655                                 i_APCI3200_GetChannelCalibrationValue(dev, i,
2656                                         &s_BoardInfos[dev->minor].
2657                                         ui_ScanValueArray[s_BoardInfos[dev->
2658                                                         minor].i_Count + ((i -
2659                                                                 s_BoardInfos
2660                                                                 [dev->minor].
2661                                                                 i_FirstChannel)
2662                                                         * 3)],
2663                                         &s_BoardInfos[dev->minor].
2664                                         ui_ScanValueArray[s_BoardInfos[dev->
2665                                                         minor].i_Count + ((i -
2666                                                                 s_BoardInfos
2667                                                                 [dev->minor].
2668                                                                 i_FirstChannel)
2669                                                         * 3) + 1],
2670                                         &s_BoardInfos[dev->minor].
2671                                         ui_ScanValueArray[s_BoardInfos[dev->
2672                                                         minor].i_Count + ((i -
2673                                                                 s_BoardInfos
2674                                                                 [dev->minor].
2675                                                                 i_FirstChannel)
2676                                                         * 3) + 2]);
2677                         }
2678
2679                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2680
2681                         /* i_Count=-1; */
2682
2683                         s_BoardInfos[dev->minor].i_Count = -1;
2684
2685                         /* async->buf_int_count+=(i_LastChannel-i_FirstChannel+4)*sizeof(unsigned int); */
2686                         /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2687                         /* async->buf_int_count+=(s_BoardInfos [dev->minor].i_LastChannel-s_BoardInfos [dev->minor].i_FirstChannel+4)*sizeof(unsigned int); */
2688                         /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2689                         /* async->buf_int_ptr+=(i_LastChannel-i_FirstChannel+4)*sizeof(unsigned int); */
2690                         /* Begin JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2691                         /* async->buf_int_ptr+=(s_BoardInfos [dev->minor].i_LastChannel-s_BoardInfos [dev->minor].i_FirstChannel+4)*sizeof(unsigned int); */
2692                         /* comedi_eos(dev,s); */
2693
2694                         /*  Set the event type (Comedi Buffer End Of Scan) */
2695                         s->async->events |= COMEDI_CB_EOS;
2696
2697                         /*  Test if enougth memory is available and allocate it for 7 values */
2698                         /* n = comedi_buf_write_alloc(s->async, 7*sizeof(unsigned int)); */
2699                         n = comedi_buf_write_alloc(s->async,
2700                                 (7 + 12) * sizeof(unsigned int));
2701
2702                         /*  If not enough memory available, event is set to Comedi Buffer Error */
2703                         if (n > ((7 + 12) * sizeof(unsigned int))) {
2704                                 printk("\ncomedi_buf_write_alloc n = %i", n);
2705                                 s->async->events |= COMEDI_CB_ERROR;
2706                         }
2707                         /*  Write all 7 scan values in the comedi buffer */
2708                         comedi_buf_memcpy_to(s->async, 0,
2709                                 (unsigned int *) s_BoardInfos[dev->minor].
2710                                 ui_ScanValueArray, (7 + 12) * sizeof(unsigned int));
2711
2712                         /*  Update comedi buffer pinters indexes */
2713                         comedi_buf_write_free(s->async,
2714                                 (7 + 12) * sizeof(unsigned int));
2715
2716                         /*  Send events */
2717                         comedi_event(dev, s);
2718                         /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2719
2720                         /* BEGIN JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2721                         /*  */
2722                         /* if (s->async->buf_int_ptr>=s->async->data_len) //  for buffer rool over */
2723                         /*   { */
2724                         /*     /* buffer rollover */ */
2725                         /*     s->async->buf_int_ptr=0; */
2726                         /*     comedi_eobuf(dev,s); */
2727                         /*   } */
2728                         /* End JK 18.10.2004: APCI-3200 Driver update 0.7.57 -> 0.7.68 */
2729                 }
2730                 /* i_Count++; */
2731                 s_BoardInfos[dev->minor].i_Count++;
2732         }
2733         /* i_InterruptFlag=0; */
2734         s_BoardInfos[dev->minor].i_InterruptFlag = 0;
2735         return 0;
2736 }
2737
2738 static void v_APCI3200_Interrupt(int irq, void *d)
2739 {
2740         struct comedi_device *dev = d;
2741         struct addi_private *devpriv = dev->private;
2742         unsigned int ui_StatusRegister = 0;
2743         unsigned int ui_ChannelNumber = 0;
2744         int i_CalibrationFlag = 0;
2745         int i_CJCFlag = 0;
2746         unsigned int ui_DummyValue = 0;
2747         unsigned int ui_DigitalTemperature = 0;
2748         unsigned int ui_DigitalInput = 0;
2749         int i_ConvertCJCCalibration;
2750         /* BEGIN JK TEST */
2751         int i_ReturnValue = 0;
2752         /* END JK TEST */
2753
2754         /* printk ("\n i_ScanType = %i i_ADDIDATAType = %i", s_BoardInfos [dev->minor].i_ScanType, s_BoardInfos [dev->minor].i_ADDIDATAType); */
2755
2756         /* switch(i_ScanType) */
2757         switch (s_BoardInfos[dev->minor].i_ScanType) {
2758         case 0:
2759         case 1:
2760                 /* switch(i_ADDIDATAType) */
2761                 switch (s_BoardInfos[dev->minor].i_ADDIDATAType) {
2762                 case 0:
2763                 case 1:
2764
2765           /************************************/
2766                         /*Read the interrupt status register */
2767           /************************************/
2768                         /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2769                         ui_StatusRegister =
2770                                 inl(devpriv->iobase +
2771                                 s_BoardInfos[dev->minor].i_Offset + 16);
2772                         if ((ui_StatusRegister & 0x2) == 0x2) {
2773                                 /* i_CalibrationFlag = ((inl(devpriv->iobase+i_Offset + 12) & 0x00060000) >> 17); */
2774                                 i_CalibrationFlag =
2775                                         ((inl(devpriv->iobase +
2776                                                         s_BoardInfos[dev->
2777                                                                 minor].
2778                                                         i_Offset +
2779                                                         12) & 0x00060000) >>
2780                                         17);
2781               /*************************/
2782                                 /*Read the channel number */
2783               /*************************/
2784                                 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2785
2786               /*************************************/
2787                                 /*Read the digital analog input value */
2788               /*************************************/
2789                                 /* ui_DigitalInput = inl(devpriv->iobase+i_Offset + 28); */
2790                                 ui_DigitalInput =
2791                                         inl(devpriv->iobase +
2792                                         s_BoardInfos[dev->minor].i_Offset + 28);
2793
2794               /***********************************************/
2795                                 /* Test if the value read is the channel value */
2796               /***********************************************/
2797                                 if (i_CalibrationFlag == 0) {
2798                                         /* ui_InterruptChannelValue[i_Count + 0] = ui_DigitalInput; */
2799                                         s_BoardInfos[dev->minor].
2800                                                 ui_InterruptChannelValue
2801                                                 [s_BoardInfos[dev->minor].
2802                                                 i_Count + 0] = ui_DigitalInput;
2803
2804                                         /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2805                                         /*
2806                                            printk("\n 1 - i_APCI3200_GetChannelCalibrationValue (dev, s_BoardInfos %i", ui_ChannelNumber);
2807                                            i_APCI3200_GetChannelCalibrationValue (dev, s_BoardInfos [dev->minor].ui_Channel_num,
2808                                            &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 6],
2809                                            &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 7],
2810                                            &s_BoardInfos [dev->minor].ui_InterruptChannelValue[s_BoardInfos [dev->minor].i_Count + 8]);
2811                                          */
2812                                         /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2813
2814                   /******************************************************/
2815                                         /*Start the conversion of the calibration offset value */
2816                   /******************************************************/
2817                                         i_APCI3200_ReadCalibrationOffsetValue
2818                                                 (dev, &ui_DummyValue);
2819                                 }       /* if (i_CalibrationFlag == 0) */
2820               /**********************************************************/
2821                                 /* Test if the value read is the calibration offset value */
2822               /**********************************************************/
2823
2824                                 if (i_CalibrationFlag == 1) {
2825
2826                   /******************/
2827                                         /* Save the value */
2828                   /******************/
2829
2830                                         /* ui_InterruptChannelValue[i_Count + 1] = ui_DigitalInput; */
2831                                         s_BoardInfos[dev->minor].
2832                                                 ui_InterruptChannelValue
2833                                                 [s_BoardInfos[dev->minor].
2834                                                 i_Count + 1] = ui_DigitalInput;
2835
2836                   /******************************************************/
2837                                         /* Start the conversion of the calibration gain value */
2838                   /******************************************************/
2839                                         i_APCI3200_ReadCalibrationGainValue(dev,
2840                                                 &ui_DummyValue);
2841                                 }       /* if (i_CalibrationFlag == 1) */
2842               /******************************************************/
2843                                 /*Test if the value read is the calibration gain value */
2844               /******************************************************/
2845
2846                                 if (i_CalibrationFlag == 2) {
2847
2848                   /****************/
2849                                         /*Save the value */
2850                   /****************/
2851                                         /* ui_InterruptChannelValue[i_Count + 2] = ui_DigitalInput; */
2852                                         s_BoardInfos[dev->minor].
2853                                                 ui_InterruptChannelValue
2854                                                 [s_BoardInfos[dev->minor].
2855                                                 i_Count + 2] = ui_DigitalInput;
2856                                         /* if(i_ScanType==1) */
2857                                         if (s_BoardInfos[dev->minor].
2858                                                 i_ScanType == 1) {
2859
2860                                                 /* i_InterruptFlag=0; */
2861                                                 s_BoardInfos[dev->minor].
2862                                                         i_InterruptFlag = 0;
2863                                                 /* i_Count=i_Count + 6; */
2864                                                 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2865                                                 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count + 6; */
2866                                                 s_BoardInfos[dev->minor].
2867                                                         i_Count =
2868                                                         s_BoardInfos[dev->
2869                                                         minor].i_Count + 9;
2870                                                 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2871                                         }       /* if(i_ScanType==1) */
2872                                         else {
2873                                                 /* i_Count=0; */
2874                                                 s_BoardInfos[dev->minor].
2875                                                         i_Count = 0;
2876                                         }       /* elseif(i_ScanType==1) */
2877                                         /* if(i_ScanType!=1) */
2878                                         if (s_BoardInfos[dev->minor].
2879                                                 i_ScanType != 1) {
2880                                                 i_ReturnValue = send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
2881                                         }       /* if(i_ScanType!=1) */
2882                                         else {
2883                                                 /* if(i_ChannelCount==i_Sum) */
2884                                                 if (s_BoardInfos[dev->minor].
2885                                                         i_ChannelCount ==
2886                                                         s_BoardInfos[dev->
2887                                                                 minor].i_Sum) {
2888                                                         send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
2889                                                 }
2890                                         }       /* if(i_ScanType!=1) */
2891                                 }       /* if (i_CalibrationFlag == 2) */
2892                         }       /*  if ((ui_StatusRegister & 0x2) == 0x2) */
2893
2894                         break;
2895
2896                 case 2:
2897           /************************************/
2898                         /*Read the interrupt status register */
2899           /************************************/
2900
2901                         /* ui_StatusRegister = inl(devpriv->iobase+i_Offset + 16); */
2902                         ui_StatusRegister =
2903                                 inl(devpriv->iobase +
2904                                 s_BoardInfos[dev->minor].i_Offset + 16);
2905           /*************************/
2906                         /*Test if interrupt occur */
2907           /*************************/
2908
2909                         if ((ui_StatusRegister & 0x2) == 0x2) {
2910
2911                                 /* i_CJCFlag = ((inl(devpriv->iobase+i_Offset + 4) & 0x00000400) >> 10); */
2912                                 i_CJCFlag =
2913                                         ((inl(devpriv->iobase +
2914                                                         s_BoardInfos[dev->
2915                                                                 minor].
2916                                                         i_Offset +
2917                                                         4) & 0x00000400) >> 10);
2918
2919                                 /* i_CalibrationFlag = ((inl(devpriv->iobase+i_Offset + 12) & 0x00060000) >> 17); */
2920                                 i_CalibrationFlag =
2921                                         ((inl(devpriv->iobase +
2922                                                         s_BoardInfos[dev->
2923                                                                 minor].
2924                                                         i_Offset +
2925                                                         12) & 0x00060000) >>
2926                                         17);
2927
2928               /*************************/
2929                                 /*Read the channel number */
2930               /*************************/
2931
2932                                 /* ui_ChannelNumber = inl(devpriv->iobase+i_Offset + 24); */
2933                                 ui_ChannelNumber =
2934                                         inl(devpriv->iobase +
2935                                         s_BoardInfos[dev->minor].i_Offset + 24);
2936                                 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2937                                 s_BoardInfos[dev->minor].ui_Channel_num =
2938                                         ui_ChannelNumber;
2939                                 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
2940
2941               /************************************/
2942                                 /*Read the digital temperature value */
2943               /************************************/
2944                                 /* ui_DigitalTemperature = inl(devpriv->iobase+i_Offset + 28); */
2945                                 ui_DigitalTemperature =
2946                                         inl(devpriv->iobase +
2947                                         s_BoardInfos[dev->minor].i_Offset + 28);
2948
2949               /*********************************************/
2950                                 /*Test if the value read is the channel value */
2951               /*********************************************/
2952
2953                                 if ((i_CalibrationFlag == 0)
2954                                         && (i_CJCFlag == 0)) {
2955                                         /* ui_InterruptChannelValue[i_Count + 0]=ui_DigitalTemperature; */
2956                                         s_BoardInfos[dev->minor].
2957                                                 ui_InterruptChannelValue
2958                                                 [s_BoardInfos[dev->minor].
2959                                                 i_Count + 0] =
2960                                                 ui_DigitalTemperature;
2961
2962                   /*********************************/
2963                                         /*Start the conversion of the CJC */
2964                   /*********************************/
2965                                         i_APCI3200_ReadCJCValue(dev,
2966                                                 &ui_DummyValue);
2967
2968                                 }       /* if ((i_CalibrationFlag == 0) && (i_CJCFlag == 0)) */
2969
2970                  /*****************************************/
2971                                 /*Test if the value read is the CJC value */
2972                  /*****************************************/
2973
2974                                 if ((i_CJCFlag == 1)
2975                                         && (i_CalibrationFlag == 0)) {
2976                                         /* ui_InterruptChannelValue[i_Count + 3]=ui_DigitalTemperature; */
2977                                         s_BoardInfos[dev->minor].
2978                                                 ui_InterruptChannelValue
2979                                                 [s_BoardInfos[dev->minor].
2980                                                 i_Count + 3] =
2981                                                 ui_DigitalTemperature;
2982
2983                   /******************************************************/
2984                                         /*Start the conversion of the calibration offset value */
2985                   /******************************************************/
2986                                         i_APCI3200_ReadCalibrationOffsetValue
2987                                                 (dev, &ui_DummyValue);
2988                                 }       /*  if ((i_CJCFlag == 1) && (i_CalibrationFlag == 0)) */
2989
2990                  /********************************************************/
2991                                 /*Test if the value read is the calibration offset value */
2992                  /********************************************************/
2993
2994                                 if ((i_CalibrationFlag == 1)
2995                                         && (i_CJCFlag == 0)) {
2996                                         /* ui_InterruptChannelValue[i_Count + 1]=ui_DigitalTemperature; */
2997                                         s_BoardInfos[dev->minor].
2998                                                 ui_InterruptChannelValue
2999                                                 [s_BoardInfos[dev->minor].
3000                                                 i_Count + 1] =
3001                                                 ui_DigitalTemperature;
3002
3003                   /****************************************************/
3004                                         /*Start the conversion of the calibration gain value */
3005                   /****************************************************/
3006                                         i_APCI3200_ReadCalibrationGainValue(dev,
3007                                                 &ui_DummyValue);
3008
3009                                 }       /* if ((i_CalibrationFlag == 1) && (i_CJCFlag == 0)) */
3010
3011               /******************************************************/
3012                                 /*Test if the value read is the calibration gain value */
3013               /******************************************************/
3014
3015                                 if ((i_CalibrationFlag == 2)
3016                                         && (i_CJCFlag == 0)) {
3017                                         /* ui_InterruptChannelValue[i_Count + 2]=ui_DigitalTemperature; */
3018                                         s_BoardInfos[dev->minor].
3019                                                 ui_InterruptChannelValue
3020                                                 [s_BoardInfos[dev->minor].
3021                                                 i_Count + 2] =
3022                                                 ui_DigitalTemperature;
3023
3024                   /**********************************************************/
3025                                         /*Test if the Calibration channel must be read for the CJC */
3026                   /**********************************************************/
3027
3028                                         /*Test if the polarity is the same */
3029                   /**********************************/
3030                                         /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
3031                                         if (s_BoardInfos[dev->minor].
3032                                                 i_CJCPolarity !=
3033                                                 s_BoardInfos[dev->minor].
3034                                                 i_ADDIDATAPolarity) {
3035                                                 i_ConvertCJCCalibration = 1;
3036                                         }       /* if(i_CJCPolarity!=i_ADDIDATAPolarity) */
3037                                         else {
3038                                                 /* if(i_CJCGain==i_ADDIDATAGain) */
3039                                                 if (s_BoardInfos[dev->minor].
3040                                                         i_CJCGain ==
3041                                                         s_BoardInfos[dev->
3042                                                                 minor].
3043                                                         i_ADDIDATAGain) {
3044                                                         i_ConvertCJCCalibration
3045                                                                 = 0;
3046                                                 }       /* if(i_CJCGain==i_ADDIDATAGain) */
3047                                                 else {
3048                                                         i_ConvertCJCCalibration
3049                                                                 = 1;
3050                                                 }       /* elseif(i_CJCGain==i_ADDIDATAGain) */
3051                                         }       /* elseif(i_CJCPolarity!=i_ADDIDATAPolarity) */
3052                                         if (i_ConvertCJCCalibration == 1) {
3053                       /****************************************************************/
3054                                                 /*Start the conversion of the calibration gain value for the CJC */
3055                       /****************************************************************/
3056                                                 i_APCI3200_ReadCJCCalOffset(dev,
3057                                                         &ui_DummyValue);
3058
3059                                         }       /* if(i_ConvertCJCCalibration==1) */
3060                                         else {
3061                                                 /* ui_InterruptChannelValue[i_Count + 4]=0; */
3062                                                 /* ui_InterruptChannelValue[i_Count + 5]=0; */
3063                                                 s_BoardInfos[dev->minor].
3064                                                         ui_InterruptChannelValue
3065                                                         [s_BoardInfos[dev->
3066                                                                 minor].i_Count +
3067                                                         4] = 0;
3068                                                 s_BoardInfos[dev->minor].
3069                                                         ui_InterruptChannelValue
3070                                                         [s_BoardInfos[dev->
3071                                                                 minor].i_Count +
3072                                                         5] = 0;
3073                                         }       /* elseif(i_ConvertCJCCalibration==1) */
3074                                 }       /* else if ((i_CalibrationFlag == 2) && (i_CJCFlag == 0)) */
3075
3076                  /********************************************************************/
3077                                 /*Test if the value read is the calibration offset value for the CJC */
3078                  /********************************************************************/
3079
3080                                 if ((i_CalibrationFlag == 1)
3081                                         && (i_CJCFlag == 1)) {
3082                                         /* ui_InterruptChannelValue[i_Count + 4]=ui_DigitalTemperature; */
3083                                         s_BoardInfos[dev->minor].
3084                                                 ui_InterruptChannelValue
3085                                                 [s_BoardInfos[dev->minor].
3086                                                 i_Count + 4] =
3087                                                 ui_DigitalTemperature;
3088
3089                   /****************************************************************/
3090                                         /*Start the conversion of the calibration gain value for the CJC */
3091                   /****************************************************************/
3092                                         i_APCI3200_ReadCJCCalGain(dev,
3093                                                 &ui_DummyValue);
3094
3095                                 }       /* if ((i_CalibrationFlag == 1) && (i_CJCFlag == 1)) */
3096
3097               /******************************************************************/
3098                                 /*Test if the value read is the calibration gain value for the CJC */
3099               /******************************************************************/
3100
3101                                 if ((i_CalibrationFlag == 2)
3102                                         && (i_CJCFlag == 1)) {
3103                                         /* ui_InterruptChannelValue[i_Count + 5]=ui_DigitalTemperature; */
3104                                         s_BoardInfos[dev->minor].
3105                                                 ui_InterruptChannelValue
3106                                                 [s_BoardInfos[dev->minor].
3107                                                 i_Count + 5] =
3108                                                 ui_DigitalTemperature;
3109
3110                                         /* if(i_ScanType==1) */
3111                                         if (s_BoardInfos[dev->minor].
3112                                                 i_ScanType == 1) {
3113
3114                                                 /* i_InterruptFlag=0; */
3115                                                 s_BoardInfos[dev->minor].
3116                                                         i_InterruptFlag = 0;
3117                                                 /* i_Count=i_Count + 6; */
3118                                                 /* Begin JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
3119                                                 /* s_BoardInfos [dev->minor].i_Count=s_BoardInfos [dev->minor].i_Count + 6; */
3120                                                 s_BoardInfos[dev->minor].
3121                                                         i_Count =
3122                                                         s_BoardInfos[dev->
3123                                                         minor].i_Count + 9;
3124                                                 /* End JK 22.10.2004: APCI-3200 / APCI-3300 Reading of EEPROM values */
3125                                         }       /* if(i_ScanType==1) */
3126                                         else {
3127                                                 /* i_Count=0; */
3128                                                 s_BoardInfos[dev->minor].
3129                                                         i_Count = 0;
3130                                         }       /* elseif(i_ScanType==1) */
3131
3132                                         /* if(i_ScanType!=1) */
3133                                         if (s_BoardInfos[dev->minor].
3134                                                 i_ScanType != 1) {
3135                                                 send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
3136                                         }       /* if(i_ScanType!=1) */
3137                                         else {
3138                                                 /* if(i_ChannelCount==i_Sum) */
3139                                                 if (s_BoardInfos[dev->minor].
3140                                                         i_ChannelCount ==
3141                                                         s_BoardInfos[dev->
3142                                                                 minor].i_Sum) {
3143                                                         send_sig(SIGIO, devpriv->tsk_Current, 0);       /*  send signal to the sample */
3144
3145                                                 }       /* if(i_ChannelCount==i_Sum) */
3146                                         }       /* else if(i_ScanType!=1) */
3147                                 }       /* if ((i_CalibrationFlag == 2) && (i_CJCFlag == 1)) */
3148
3149                         }       /* else if ((ui_StatusRegister & 0x2) == 0x2) */
3150                         break;
3151                 }               /* switch(i_ADDIDATAType) */
3152                 break;
3153         case 2:
3154         case 3:
3155                 i_APCI3200_InterruptHandleEos(dev);
3156                 break;
3157         }                       /* switch(i_ScanType) */
3158         return;
3159 }