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

   1 /**
   2 @verbatim
   3
   4 Copyright (C) 2004,2005  ADDI-DATA GmbH for the source code of this module.
   5
   6         ADDI-DATA GmbH
   7         Dieselstrasse 3
   8         D-77833 Ottersweier
   9         Tel: +19(0)7223/9493-0
  10         Fax: +49(0)7223/9493-92
  11         http://www.addi-data-com
  12         info@addi-data.com
  13
  14 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19
  20 You shoud also find the complete GPL in the COPYING file accompanying this source code.
  21
  22 @endverbatim
  23 */
  24 /*
  25
  26   +-----------------------------------------------------------------------+
  27   | (C) ADDI-DATA GmbH          Dieselstrasse 3      D-77833 Ottersweier  |
  28   +-----------------------------------------------------------------------+
  29   | Tel : +49 (0) 7223/9493-0     | email    : info@addi-data.com         |
  30   | Fax : +49 (0) 7223/9493-92    | Internet : http://www.addi-data.com   |
  31   +-----------------------------------------------------------------------+
  32   | Project   : ADDI DATA         | Compiler : GCC                                    |
  33   | Modulname : addi_eeprom.c     | Version  : 2.96                       |
  34   +-------------------------------+---------------------------------------+
  35   | Project manager: Eric Stolz   | Date     :  02/12/2002                |
  36   +-----------------------------------------------------------------------+
  37   | Description : ADDI EEPROM  Module                                     |
  38   +-----------------------------------------------------------------------+
  39   |                             UPDATE'S                                  |
  40   +-----------------------------------------------------------------------+
  41   |   Date   |   Author  |          Description of updates                |
  42   +----------+-----------+------------------------------------------------+
  43   |          |           |                                                |
  44   |          |           |                                                |
  45   +----------+-----------+------------------------------------------------+
  46 */
  47
  48 #define NVCMD_BEGIN_READ        (0x7 << 5)      /*  nvRam begin read command */
  49 #define NVCMD_LOAD_LOW          (0x4 << 5)      /*  nvRam load low command */
  50 #define NVCMD_LOAD_HIGH         (0x5 << 5)      /*  nvRam load high command */
  51 #define EE76_CMD_LEN            13      /*  bits in instructions */
  52 #define EE_READ                 0x0180  /*  01 1000 0000 read instruction */
  53
  54 #define EEPROM_DIGITALINPUT                     0
  55 #define EEPROM_DIGITALOUTPUT                    1
  56 #define EEPROM_ANALOGINPUT                              2
  57 #define EEPROM_ANALOGOUTPUT                             3
  58 #define EEPROM_TIMER                                    4
  59 #define EEPROM_WATCHDOG                                 5
  60 #define EEPROM_TIMER_WATCHDOG_COUNTER   10
  61
  62 struct str_Functionality {
  63         unsigned char b_Type;
  64         unsigned short w_Address;
  65 };
  66
  67 struct str_MainHeader {
  68         unsigned short w_HeaderSize;
  69         unsigned char b_Nfunctions;
  70         struct str_Functionality s_Functions[7];
  71 };
  72
  73 struct str_DigitalInputHeader {
  74         unsigned short w_Nchannel;
  75         unsigned char b_Interruptible;
  76         unsigned short w_NinterruptLogic;
  77 };
  78
  79 struct str_DigitalOutputHeader {
  80
  81         unsigned short w_Nchannel;
  82 };
  83
  84
  85 /* used for timer as well as watchdog */
  86
  87 struct str_TimerDetails {
  88
  89         unsigned short w_HeaderSize;
  90         unsigned char b_Resolution;
  91         unsigned char b_Mode;           /*  in case of Watchdog it is functionality */
  92         unsigned short w_MinTiming;
  93         unsigned char b_TimeBase;
  94 };
  95
  96 struct str_TimerMainHeader {
  97
  98
  99         unsigned short w_Ntimer;
 100         struct str_TimerDetails s_TimerDetails[4];      /*   supports 4 timers */
 101 };
 102
 103
 104 typedef struct {
 105         unsigned short w_Nchannel;
 106         unsigned char b_Resolution;
 107 } str_AnalogOutputHeader;
 108
 109 struct str_AnalogInputHeader {
 110         unsigned short w_Nchannel;
 111         unsigned short w_MinConvertTiming;
 112         unsigned short w_MinDelayTiming;
 113         unsigned char b_HasDma;
 114         unsigned char b_Resolution;
 115 };
 116
 117
 118                 /*****************************************/
 119                 /*            Read Header Functions              */
 120                 /*****************************************/
 121
 122 int i_EepromReadMainHeader(unsigned short w_PCIBoardEepromAddress,
 123         char *pc_PCIChipInformation, struct comedi_device *dev);
 124
 125 int i_EepromReadDigitalInputHeader(unsigned short w_PCIBoardEepromAddress,
 126         char *pc_PCIChipInformation, unsigned short w_Address,
 127         struct str_DigitalInputHeader *s_Header);
 128
 129 int i_EepromReadDigitalOutputHeader(unsigned short w_PCIBoardEepromAddress,
 130         char *pc_PCIChipInformation, unsigned short w_Address,
 131         struct str_DigitalOutputHeader *s_Header);
 132
 133 int i_EepromReadTimerHeader(unsigned short w_PCIBoardEepromAddress,
 134         char *pc_PCIChipInformation, unsigned short w_Address,
 135         struct str_TimerMainHeader *s_Header);
 136
 137 int i_EepromReadAnlogOutputHeader(unsigned short w_PCIBoardEepromAddress,
 138         char *pc_PCIChipInformation, unsigned short w_Address,
 139         str_AnalogOutputHeader *s_Header);
 140
 141 int i_EepromReadAnlogInputHeader(unsigned short w_PCIBoardEepromAddress,
 142         char *pc_PCIChipInformation, unsigned short w_Address,
 143         struct str_AnalogInputHeader *s_Header);
 144
 145                 /******************************************/
 146                 /*      Eeprom Specific Functions                         */
 147                 /******************************************/
 148 unsigned short w_EepromReadWord(unsigned short w_PCIBoardEepromAddress, char *pc_PCIChipInformation,
 149         unsigned short w_EepromStartAddress);
 150 void v_EepromWaitBusy(unsigned short w_PCIBoardEepromAddress);
 151 void v_EepromClock76(unsigned int dw_Address, unsigned int dw_RegisterValue);
 152 void v_EepromWaitBusy(unsigned short w_PCIBoardEepromAddress);
 153 void v_EepromSendCommand76(unsigned int dw_Address, unsigned int dw_EepromCommand,
 154         unsigned char b_DataLengthInBits);
 155 void v_EepromCs76Read(unsigned int dw_Address, unsigned short w_offset, unsigned short *pw_Value);
 156
 157 /*
 158 +----------------------------------------------------------------------------+
 159 | Function   Name   : unsigned short w_EepromReadWord                                  |
 160 |                               (unsigned short w_PCIBoardEepromAddress,                         |
 161 |                                char * pc_PCIChipInformation,                           |
 162 |                                unsigned short   w_EepromStartAddress)                          |
 163 +----------------------------------------------------------------------------+
 164 | Task              : Read from eepromn a word                               |
 165 +----------------------------------------------------------------------------+
 166 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
 167 |                                                                                                                                        |
 168 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
 169 |                                                                                                                                        |
 170 |                     unsigned short w_EepromStartAddress    : Selected eeprom address |
 171 +----------------------------------------------------------------------------+
 172 | Output Parameters : -                                                      |
 173 +----------------------------------------------------------------------------+
 174 | Return Value      : Read word value from eeprom                            |
 175 +----------------------------------------------------------------------------+
 176 */
 177
 178 unsigned short w_EepromReadWord(unsigned short w_PCIBoardEepromAddress, char *pc_PCIChipInformation,
 179         unsigned short w_EepromStartAddress)
 180 {
 181
 182         unsigned char b_Counter = 0;
 183
 184         unsigned char b_ReadByte = 0;
 185
 186         unsigned char b_ReadLowByte = 0;
 187
 188         unsigned char b_ReadHighByte = 0;
 189
 190         unsigned char b_SelectedAddressLow = 0;
 191
 192         unsigned char b_SelectedAddressHigh = 0;
 193
 194         unsigned short w_ReadWord = 0;
 195
 196         /**************************/
 197
 198         /* Test the PCI chip type */
 199
 200         /**************************/
 201
 202         if ((!strcmp(pc_PCIChipInformation, "S5920")) ||
 203                 (!strcmp(pc_PCIChipInformation, "S5933")))
 204         {
 205
 206                 for (b_Counter = 0; b_Counter < 2; b_Counter++)
 207                 {
 208
 209                         b_SelectedAddressLow = (w_EepromStartAddress + b_Counter) % 256;        /* Read the low 8 bit part */
 210
 211                         b_SelectedAddressHigh = (w_EepromStartAddress + b_Counter) / 256;       /* Read the high 8 bit part */
 212
 213               /************************************/
 214
 215                         /* Select the load low address mode */
 216
 217               /************************************/
 218
 219                         outb(NVCMD_LOAD_LOW, w_PCIBoardEepromAddress + 0x3F);
 220
 221               /****************/
 222
 223                         /* Wait on busy */
 224
 225               /****************/
 226
 227                         v_EepromWaitBusy(w_PCIBoardEepromAddress);
 228
 229               /************************/
 230
 231                         /* Load the low address */
 232
 233               /************************/
 234
 235                         outb(b_SelectedAddressLow,
 236                                 w_PCIBoardEepromAddress + 0x3E);
 237
 238               /****************/
 239
 240                         /* Wait on busy */
 241
 242               /****************/
 243
 244                         v_EepromWaitBusy(w_PCIBoardEepromAddress);
 245
 246               /*************************************/
 247
 248                         /* Select the load high address mode */
 249
 250               /*************************************/
 251
 252                         outb(NVCMD_LOAD_HIGH, w_PCIBoardEepromAddress + 0x3F);
 253
 254               /****************/
 255
 256                         /* Wait on busy */
 257
 258               /****************/
 259
 260                         v_EepromWaitBusy(w_PCIBoardEepromAddress);
 261
 262               /*************************/
 263
 264                         /* Load the high address */
 265
 266               /*************************/
 267
 268                         outb(b_SelectedAddressHigh,
 269                                 w_PCIBoardEepromAddress + 0x3E);
 270
 271               /****************/
 272
 273                         /* Wait on busy */
 274
 275               /****************/
 276
 277                         v_EepromWaitBusy(w_PCIBoardEepromAddress);
 278
 279               /************************/
 280
 281                         /* Select the READ mode */
 282
 283               /************************/
 284
 285                         outb(NVCMD_BEGIN_READ, w_PCIBoardEepromAddress + 0x3F);
 286
 287               /****************/
 288
 289                         /* Wait on busy */
 290
 291               /****************/
 292
 293                         v_EepromWaitBusy(w_PCIBoardEepromAddress);
 294
 295               /*****************************/
 296
 297                         /* Read data into the EEPROM */
 298
 299               /*****************************/
 300
 301                         b_ReadByte = inb(w_PCIBoardEepromAddress + 0x3E);
 302
 303               /****************/
 304
 305                         /* Wait on busy */
 306
 307               /****************/
 308
 309                         v_EepromWaitBusy(w_PCIBoardEepromAddress);
 310
 311               /*********************************/
 312
 313                         /* Select the upper address part */
 314
 315               /*********************************/
 316
 317                         if (b_Counter == 0)
 318                         {
 319
 320                                 b_ReadLowByte = b_ReadByte;
 321
 322                         }       /*  if(b_Counter==0) */
 323
 324                         else
 325                         {
 326
 327                                 b_ReadHighByte = b_ReadByte;
 328
 329                         }       /*  if(b_Counter==0) */
 330
 331                 }               /*  for (b_Counter=0; b_Counter<2; b_Counter++) */
 332
 333                 w_ReadWord = (b_ReadLowByte | (((unsigned short) b_ReadHighByte) * 256));
 334
 335         }                       /*  end of if ((!strcmp(pc_PCIChipInformation, "S5920")) || (!strcmp(pc_PCIChipInformation, "S5933"))) */
 336
 337         if (!strcmp(pc_PCIChipInformation, "93C76"))
 338         {
 339
 340            /*************************************/
 341
 342                 /* Read 16 bit from the EEPROM 93C76 */
 343
 344            /*************************************/
 345
 346                 v_EepromCs76Read(w_PCIBoardEepromAddress, w_EepromStartAddress,
 347                         &w_ReadWord);
 348
 349         }
 350
 351         return w_ReadWord;
 352
 353 }
 354
 355 /*
 356
 357 +----------------------------------------------------------------------------+
 358
 359 | Function   Name   : void v_EepromWaitBusy                                  |
 360
 361 |                       (unsigned short w_PCIBoardEepromAddress)                         |
 362
 363 +----------------------------------------------------------------------------+
 364
 365 | Task              : Wait the busy flag from PCI controller                 |
 366
 367 +----------------------------------------------------------------------------+
 368
 369 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom base address |
 370
 371 +----------------------------------------------------------------------------+
 372
 373 | Output Parameters : -                                                      |
 374
 375 +----------------------------------------------------------------------------+
 376
 377 | Return Value      : -                                                      |
 378
 379 +----------------------------------------------------------------------------+
 380
 381 */
 382
 383 void v_EepromWaitBusy(unsigned short w_PCIBoardEepromAddress)
 384 {
 385
 386         unsigned char b_EepromBusy = 0;
 387
 388         do
 389         {
 390
 391            /*************/
 392
 393                 /* IMPORTANT */
 394
 395            /*************/
 396
 397            /************************************************************************/
 398
 399                 /* An error has been written in the AMCC 5933 book at the page B-13 */
 400
 401                 /* Ex: if you read a byte and look for the busy statusEEPROM=0x80 and   */
 402
 403                 /*      the operator register is AMCC_OP_REG_MCSR+3 */
 404
 405                 /*      unsigned short read  EEPROM=0x8000 andAMCC_OP_REG_MCSR+2                  */
 406
 407                 /*      unsigned int read  EEPROM=0x80000000 and AMCC_OP_REG_MCSR */
 408
 409            /************************************************************************/
 410
 411                 b_EepromBusy = inb(w_PCIBoardEepromAddress + 0x3F);
 412                 b_EepromBusy = b_EepromBusy & 0x80;
 413
 414         } while (b_EepromBusy == 0x80);
 415
 416 }
 417
 418 /*
 419
 420 +---------------------------------------------------------------------------------+
 421
 422 | Function   Name   : void v_EepromClock76(unsigned int dw_Address,                      |
 423
 424 |                                          unsigned int dw_RegisterValue)                                         |
 425
 426 +---------------------------------------------------------------------------------+
 427
 428 | Task              : This function sends the clocking sequence to the EEPROM.    |
 429
 430 +---------------------------------------------------------------------------------+
 431
 432 | Input Parameters  : unsigned int dw_Address : PCI eeprom base address                  |
 433
 434 |                     unsigned int dw_RegisterValue : PCI eeprom register value to write.|
 435
 436 +---------------------------------------------------------------------------------+
 437
 438 | Output Parameters : -                                                           |
 439
 440 +---------------------------------------------------------------------------------+
 441
 442 | Return Value      : -                                                           |
 443
 444 +---------------------------------------------------------------------------------+
 445
 446 */
 447
 448 void v_EepromClock76(unsigned int dw_Address, unsigned int dw_RegisterValue)
 449 {
 450
 451    /************************/
 452
 453         /* Set EEPROM clock Low */
 454
 455    /************************/
 456
 457         outl(dw_RegisterValue & 0x6, dw_Address);
 458
 459    /***************/
 460
 461         /* Wait 0.1 ms */
 462
 463    /***************/
 464
 465         udelay(100);
 466
 467    /*************************/
 468
 469         /* Set EEPROM clock High */
 470
 471    /*************************/
 472
 473         outl(dw_RegisterValue | 0x1, dw_Address);
 474
 475    /***************/
 476
 477         /* Wait 0.1 ms */
 478
 479    /***************/
 480
 481         udelay(100);
 482
 483 }
 484
 485 /*
 486
 487 +---------------------------------------------------------------------------------+
 488
 489 | Function   Name   : void v_EepromSendCommand76(unsigned int dw_Address,                |
 490
 491 |                                          unsigned int   dw_EepromCommand,                               |
 492
 493 |                                          unsigned char    b_DataLengthInBits)                        |
 494
 495 +---------------------------------------------------------------------------------+
 496
 497 | Task              : This function sends a Command to the EEPROM 93C76.          |
 498
 499 +---------------------------------------------------------------------------------+
 500
 501 | Input Parameters  : unsigned int dw_Address : PCI eeprom base address                  |
 502
 503 |                     unsigned int dw_EepromCommand : PCI eeprom command to write.       |
 504
 505 |                     unsigned char  b_DataLengthInBits : PCI eeprom command data length.  |
 506
 507 +---------------------------------------------------------------------------------+
 508
 509 | Output Parameters : -                                                           |
 510
 511 +---------------------------------------------------------------------------------+
 512
 513 | Return Value      : -                                                           |
 514
 515 +---------------------------------------------------------------------------------+
 516
 517 */
 518
 519 void v_EepromSendCommand76(unsigned int dw_Address, unsigned int dw_EepromCommand,
 520         unsigned char b_DataLengthInBits)
 521 {
 522
 523         char c_BitPos = 0;
 524
 525         unsigned int dw_RegisterValue = 0;
 526
 527    /*****************************/
 528
 529         /* Enable EEPROM Chip Select */
 530
 531    /*****************************/
 532
 533         dw_RegisterValue = 0x2;
 534
 535    /********************************************************************/
 536
 537         /* Toggle EEPROM's Chip select to get it out of Shift Register Mode */
 538
 539    /********************************************************************/
 540
 541         outl(dw_RegisterValue, dw_Address);
 542
 543    /***************/
 544
 545         /* Wait 0.1 ms */
 546
 547    /***************/
 548
 549         udelay(100);
 550
 551    /*******************************************/
 552
 553         /* Send EEPROM command - one bit at a time */
 554
 555    /*******************************************/
 556
 557         for (c_BitPos = (b_DataLengthInBits - 1); c_BitPos >= 0; c_BitPos--)
 558         {
 559
 560       /**********************************/
 561
 562                 /* Check if current bit is 0 or 1 */
 563
 564       /**********************************/
 565
 566                 if (dw_EepromCommand & (1 << c_BitPos))
 567                 {
 568
 569          /***********/
 570
 571                         /* Write 1 */
 572
 573          /***********/
 574
 575                         dw_RegisterValue = dw_RegisterValue | 0x4;
 576
 577                 }
 578
 579                 else
 580                 {
 581
 582          /***********/
 583
 584                         /* Write 0 */
 585
 586          /***********/
 587
 588                         dw_RegisterValue = dw_RegisterValue & 0x3;
 589
 590                 }
 591
 592       /*********************/
 593
 594                 /* Write the command */
 595
 596       /*********************/
 597
 598                 outl(dw_RegisterValue, dw_Address);
 599
 600       /***************/
 601
 602                 /* Wait 0.1 ms */
 603
 604       /***************/
 605
 606                 udelay(100);
 607
 608       /****************************/
 609
 610                 /* Trigger the EEPROM clock */
 611
 612       /****************************/
 613
 614                 v_EepromClock76(dw_Address, dw_RegisterValue);
 615
 616         }
 617
 618 }
 619
 620 /*
 621
 622 +---------------------------------------------------------------------------------+
 623
 624 | Function   Name   : void v_EepromCs76Read(unsigned int dw_Address,                     |
 625
 626 |                                          unsigned short    w_offset,                                            |
 627
 628 |                                          unsigned short *   pw_Value)                                           |
 629
 630 +---------------------------------------------------------------------------------+
 631
 632 | Task              : This function read a value from the EEPROM 93C76.           |
 633
 634 +---------------------------------------------------------------------------------+
 635
 636 | Input Parameters  : unsigned int dw_Address : PCI eeprom base address                  |
 637
 638 |                     unsigned short    w_offset : Offset of the adress to read             |
 639
 640 |                     unsigned short *   pw_Value : PCI eeprom 16 bit read value.            |
 641
 642 +---------------------------------------------------------------------------------+
 643
 644 | Output Parameters : -                                                           |
 645
 646 +---------------------------------------------------------------------------------+
 647
 648 | Return Value      : -                                                           |
 649
 650 +---------------------------------------------------------------------------------+
 651
 652 */
 653
 654 void v_EepromCs76Read(unsigned int dw_Address, unsigned short w_offset, unsigned short *pw_Value)
 655 {
 656
 657         char c_BitPos = 0;
 658
 659         unsigned int dw_RegisterValue = 0;
 660
 661         unsigned int dw_RegisterValueRead = 0;
 662
 663    /*************************************************/
 664
 665         /* Send EEPROM read command and offset to EEPROM */
 666
 667    /*************************************************/
 668
 669         v_EepromSendCommand76(dw_Address, (EE_READ << 4) | (w_offset / 2),
 670                 EE76_CMD_LEN);
 671
 672    /*******************************/
 673
 674         /* Get the last register value */
 675
 676    /*******************************/
 677
 678         dw_RegisterValue = (((w_offset / 2) & 0x1) << 2) | 0x2;
 679
 680    /*****************************/
 681
 682         /* Set the 16-bit value of 0 */
 683
 684    /*****************************/
 685
 686         *pw_Value = 0;
 687
 688    /************************/
 689
 690         /* Get the 16-bit value */
 691
 692    /************************/
 693
 694         for (c_BitPos = 0; c_BitPos < 16; c_BitPos++)
 695         {
 696
 697       /****************************/
 698
 699                 /* Trigger the EEPROM clock */
 700
 701       /****************************/
 702
 703                 v_EepromClock76(dw_Address, dw_RegisterValue);
 704
 705       /**********************/
 706
 707                 /* Get the result bit */
 708
 709       /**********************/
 710
 711                 dw_RegisterValueRead = inl(dw_Address);
 712
 713       /***************/
 714
 715                 /* Wait 0.1 ms */
 716
 717       /***************/
 718
 719                 udelay(100);
 720
 721       /***************************************/
 722
 723                 /* Get bit value and shift into result */
 724
 725       /***************************************/
 726
 727                 if (dw_RegisterValueRead & 0x8)
 728                 {
 729
 730          /**********/
 731
 732                         /* Read 1 */
 733
 734          /**********/
 735
 736                         *pw_Value = (*pw_Value << 1) | 0x1;
 737
 738                 }
 739
 740                 else
 741                 {
 742
 743          /**********/
 744
 745                         /* Read 0 */
 746
 747          /**********/
 748
 749                         *pw_Value = (*pw_Value << 1);
 750
 751                 }
 752
 753         }
 754
 755    /*************************/
 756
 757         /* Clear all EEPROM bits */
 758
 759    /*************************/
 760
 761         dw_RegisterValue = 0x0;
 762
 763    /********************************************************************/
 764
 765         /* Toggle EEPROM's Chip select to get it out of Shift Register Mode */
 766
 767    /********************************************************************/
 768
 769         outl(dw_RegisterValue, dw_Address);
 770
 771    /***************/
 772
 773         /* Wait 0.1 ms */
 774
 775    /***************/
 776
 777         udelay(100);
 778
 779 }
 780
 781         /******************************************/
 782         /*      EEPROM HEADER READ FUNCTIONS      */
 783         /******************************************/
 784
 785 /*
 786 +----------------------------------------------------------------------------+
 787 | Function Name  : int i_EepromReadMainHeader(unsigned short w_PCIBoardEepromAddress,  |
 788 |                               char *  pc_PCIChipInformation,struct comedi_device *dev)    |
 789 +----------------------------------------------------------------------------+
 790 | Task              : Read from eeprom Main Header                           |
 791 +----------------------------------------------------------------------------+
 792 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
 793 |                                                                                                                                        |
 794 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
 795 |                                                                                                                                        |
 796 |                         struct comedi_device *dev                : comedi device structure |
 797 |                                                                                        pointer                                 |
 798 +----------------------------------------------------------------------------+
 799 | Output Parameters : -                                                      |
 800 +----------------------------------------------------------------------------+
 801 | Return Value      : 0                                                                              |
 802 +----------------------------------------------------------------------------+
 803 */
 804
 805 int i_EepromReadMainHeader(unsigned short w_PCIBoardEepromAddress,
 806         char *pc_PCIChipInformation, struct comedi_device *dev)
 807 {
 808         unsigned short w_Temp, i, w_Count = 0;
 809         unsigned int ui_Temp;
 810         struct str_MainHeader s_MainHeader;
 811         struct str_DigitalInputHeader s_DigitalInputHeader;
 812         struct str_DigitalOutputHeader s_DigitalOutputHeader;
 813         /* struct str_TimerMainHeader     s_TimerMainHeader,s_WatchdogMainHeader; */
 814         str_AnalogOutputHeader s_AnalogOutputHeader;
 815         struct str_AnalogInputHeader s_AnalogInputHeader;
 816
 817         /* Read size */
 818         s_MainHeader.w_HeaderSize =
 819                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
 820                 0x100 + 8);
 821
 822         /* Read nbr of functionality */
 823         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
 824                 pc_PCIChipInformation, 0x100 + 10);
 825         s_MainHeader.b_Nfunctions = (unsigned char) w_Temp & 0x00FF;
 826
 827         /* Read functionality details */
 828         for (i = 0; i < s_MainHeader.b_Nfunctions; i++) {
 829                 /* Read Type */
 830                 w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
 831                         pc_PCIChipInformation, 0x100 + 12 + w_Count);
 832                 s_MainHeader.s_Functions[i].b_Type = (unsigned char) w_Temp & 0x3F;
 833                 w_Count = w_Count + 2;
 834                 /* Read Address */
 835                 s_MainHeader.s_Functions[i].w_Address =
 836                         w_EepromReadWord(w_PCIBoardEepromAddress,
 837                         pc_PCIChipInformation, 0x100 + 12 + w_Count);
 838                 w_Count = w_Count + 2;
 839         }
 840
 841         /* Display main header info */
 842         for (i = 0; i < s_MainHeader.b_Nfunctions; i++) {
 843
 844                 switch (s_MainHeader.s_Functions[i].b_Type) {
 845                 case EEPROM_DIGITALINPUT:
 846                         i_EepromReadDigitalInputHeader(w_PCIBoardEepromAddress,
 847                                 pc_PCIChipInformation,
 848                                 s_MainHeader.s_Functions[i].w_Address,
 849                                 &s_DigitalInputHeader);
 850                         this_board->i_NbrDiChannel =
 851                                 s_DigitalInputHeader.w_Nchannel;
 852                         break;
 853
 854                 case EEPROM_DIGITALOUTPUT:
 855                         i_EepromReadDigitalOutputHeader(w_PCIBoardEepromAddress,
 856                                 pc_PCIChipInformation,
 857                                 s_MainHeader.s_Functions[i].w_Address,
 858                                 &s_DigitalOutputHeader);
 859                         this_board->i_NbrDoChannel =
 860                                 s_DigitalOutputHeader.w_Nchannel;
 861                         ui_Temp = 0xffffffff;
 862                         this_board->i_DoMaxdata =
 863                                 ui_Temp >> (32 - this_board->i_NbrDoChannel);
 864                         break;
 865
 866                 case EEPROM_ANALOGINPUT:
 867                         i_EepromReadAnlogInputHeader(w_PCIBoardEepromAddress,
 868                                 pc_PCIChipInformation,
 869                                 s_MainHeader.s_Functions[i].w_Address,
 870                                 &s_AnalogInputHeader);
 871                         if (!(strcmp(this_board->pc_DriverName, "apci3200")))
 872                                 this_board->i_NbrAiChannel =
 873                                         s_AnalogInputHeader.w_Nchannel * 4;
 874                         else
 875                                 this_board->i_NbrAiChannel =
 876                                         s_AnalogInputHeader.w_Nchannel;
 877                         this_board->i_Dma = s_AnalogInputHeader.b_HasDma;
 878                         this_board->ui_MinAcquisitiontimeNs =
 879                                 (unsigned int) s_AnalogInputHeader.w_MinConvertTiming *
 880                                 1000;
 881                         this_board->ui_MinDelaytimeNs =
 882                                 (unsigned int) s_AnalogInputHeader.w_MinDelayTiming *
 883                                 1000;
 884                         ui_Temp = 0xffff;
 885                         this_board->i_AiMaxdata =
 886                                 ui_Temp >> (16 -
 887                                 s_AnalogInputHeader.b_Resolution);
 888                         break;
 889
 890                 case EEPROM_ANALOGOUTPUT:
 891                         i_EepromReadAnlogOutputHeader(w_PCIBoardEepromAddress,
 892                                 pc_PCIChipInformation,
 893                                 s_MainHeader.s_Functions[i].w_Address,
 894                                 &s_AnalogOutputHeader);
 895                         this_board->i_NbrAoChannel =
 896                                 s_AnalogOutputHeader.w_Nchannel;
 897                         ui_Temp = 0xffff;
 898                         this_board->i_AoMaxdata =
 899                                 ui_Temp >> (16 -
 900                                 s_AnalogOutputHeader.b_Resolution);
 901                         break;
 902
 903                 case EEPROM_TIMER:
 904                         this_board->i_Timer = 1;        /* Timer subdevice present */
 905                         break;
 906
 907                 case EEPROM_WATCHDOG:
 908                         this_board->i_Timer = 1;        /* Timer subdevice present */
 909                         break;
 910
 911                 case EEPROM_TIMER_WATCHDOG_COUNTER:
 912                         this_board->i_Timer = 1;        /* Timer subdevice present */
 913                 }
 914         }
 915
 916         return 0;
 917 }
 918
 919 /*
 920 +----------------------------------------------------------------------------+
 921 | Function Name  : int i_EepromReadDigitalInputHeader(unsigned short                                     |
 922 |                       w_PCIBoardEepromAddress,char *pc_PCIChipInformation,     |
 923 |                       unsigned short w_Address,struct str_DigitalInputHeader *s_Header)                |
 924 |                                                                                                                                        |
 925 +----------------------------------------------------------------------------+
 926 | Task              : Read Digital Input Header                              |
 927 +----------------------------------------------------------------------------+
 928 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
 929 |                                                                                                                                        |
 930 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
 931 |                                                                                                                                        |
 932 |                        struct str_DigitalInputHeader *s_Header: Digita Input Header   |
 933 |                                                                                                  Pointer                       |
 934 +----------------------------------------------------------------------------+
 935 | Output Parameters : -                                                      |
 936 +----------------------------------------------------------------------------+
 937 | Return Value      : 0                                                                              |
 938 +----------------------------------------------------------------------------+
 939 */
 940 int i_EepromReadDigitalInputHeader(unsigned short w_PCIBoardEepromAddress,
 941         char *pc_PCIChipInformation, unsigned short w_Address,
 942         struct str_DigitalInputHeader *s_Header)
 943 {
 944         unsigned short w_Temp;
 945
 946         /*  read nbr of channels */
 947         s_Header->w_Nchannel =
 948                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
 949                 0x100 + w_Address + 6);
 950
 951         /*  interruptible or not */
 952         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
 953                 pc_PCIChipInformation, 0x100 + w_Address + 8);
 954         s_Header->b_Interruptible = (unsigned char) (w_Temp >> 7) & 0x01;
 955
 956 /* How many interruptible logic */
 957         s_Header->w_NinterruptLogic =
 958                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
 959                 0x100 + w_Address + 10);
 960
 961         return 0;
 962 }
 963
 964 /*
 965 +----------------------------------------------------------------------------+
 966 | Function Name  : int i_EepromReadDigitalOutputHeader(unsigned short                            |
 967 |                       w_PCIBoardEepromAddress,char *pc_PCIChipInformation,     |
 968 |                       unsigned short w_Address,struct str_DigitalOutputHeader *s_Header)           |
 969 |                                                                                                                                        |
 970 +----------------------------------------------------------------------------+
 971 | Task              : Read Digital Output Header                             |
 972 +----------------------------------------------------------------------------+
 973 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
 974 |                                                                                                                                        |
 975 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
 976 |                                                                                                                                        |
 977 |                        struct str_DigitalOutputHeader *s_Header: Digital Output Header|
 978 |                                                                                          Pointer                               |
 979 +----------------------------------------------------------------------------+
 980 | Output Parameters : -                                                      |
 981 +----------------------------------------------------------------------------+
 982 | Return Value      : 0                                                                              |
 983 +----------------------------------------------------------------------------+
 984 */
 985 int i_EepromReadDigitalOutputHeader(unsigned short w_PCIBoardEepromAddress,
 986         char *pc_PCIChipInformation, unsigned short w_Address,
 987         struct str_DigitalOutputHeader *s_Header)
 988 {
 989 /* Read Nbr channels */
 990         s_Header->w_Nchannel =
 991                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
 992                 0x100 + w_Address + 6);
 993         return 0;
 994 }
 995
 996 /*
 997 +----------------------------------------------------------------------------+
 998 | Function Name  : int i_EepromReadTimerHeader(unsigned short w_PCIBoardEepromAddress, |
 999 |                       char *pc_PCIChipInformation,WORD w_Address,                              |
1000 |                       struct str_TimerMainHeader *s_Header)                                                    |
1001 +----------------------------------------------------------------------------+
1002 | Task              : Read Timer or Watchdog Header                          |
1003 +----------------------------------------------------------------------------+
1004 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
1005 |                                                                                                                                        |
1006 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
1007 |                                                                                                                                        |
1008 |                        struct str_TimerMainHeader *s_Header: Timer Header                      |
1009 |                                                                                          Pointer                               |
1010 +----------------------------------------------------------------------------+
1011 | Output Parameters : -                                                      |
1012 +----------------------------------------------------------------------------+
1013 | Return Value      : 0                                                                              |
1014 +----------------------------------------------------------------------------+
1015 */
1016 int i_EepromReadTimerHeader(unsigned short w_PCIBoardEepromAddress,
1017         char *pc_PCIChipInformation, unsigned short w_Address,
1018         struct str_TimerMainHeader *s_Header)
1019 {
1020
1021         unsigned short i, w_Size = 0, w_Temp;
1022
1023 /* Read No of Timer */
1024         s_Header->w_Ntimer =
1025                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
1026                 0x100 + w_Address + 6);
1027 /* Read header size */
1028
1029         for (i = 0; i < s_Header->w_Ntimer; i++) {
1030                 s_Header->s_TimerDetails[i].w_HeaderSize =
1031                         w_EepromReadWord(w_PCIBoardEepromAddress,
1032                         pc_PCIChipInformation,
1033                         0x100 + w_Address + 8 + w_Size + 0);
1034                 w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1035                         pc_PCIChipInformation,
1036                         0x100 + w_Address + 8 + w_Size + 2);
1037
1038                 /* Read Resolution */
1039                 s_Header->s_TimerDetails[i].b_Resolution =
1040                         (unsigned char) (w_Temp >> 10) & 0x3F;
1041
1042                 /* Read Mode */
1043                 s_Header->s_TimerDetails[i].b_Mode =
1044                         (unsigned char) (w_Temp >> 4) & 0x3F;
1045
1046                 w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1047                         pc_PCIChipInformation,
1048                         0x100 + w_Address + 8 + w_Size + 4);
1049
1050                 /* Read MinTiming */
1051                 s_Header->s_TimerDetails[i].w_MinTiming = (w_Temp >> 6) & 0x3FF;
1052
1053                 /* Read Timebase */
1054                 s_Header->s_TimerDetails[i].b_TimeBase = (unsigned char) (w_Temp) & 0x3F;
1055                 w_Size += s_Header->s_TimerDetails[i].w_HeaderSize;
1056         }
1057
1058         return 0;
1059 }
1060
1061 /*
1062 +----------------------------------------------------------------------------+
1063 | Function Name  : int i_EepromReadAnlogOutputHeader(unsigned short                                      |
1064 |                       w_PCIBoardEepromAddress,char *pc_PCIChipInformation,     |
1065 |                       unsigned short w_Address,str_AnalogOutputHeader *s_Header)         |
1066 +----------------------------------------------------------------------------+
1067 | Task              : Read Nalog Output  Header                              |
1068 +----------------------------------------------------------------------------+
1069 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
1070 |                                                                                                                                        |
1071 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
1072 |                                                                                                                                        |
1073 |                        str_AnalogOutputHeader *s_Header:Anlog Output Header    |
1074 |                                                                                          Pointer                               |
1075 +----------------------------------------------------------------------------+
1076 | Output Parameters : -                                                      |
1077 +----------------------------------------------------------------------------+
1078 | Return Value      : 0                                                                              |
1079 +----------------------------------------------------------------------------+
1080 */
1081
1082 int i_EepromReadAnlogOutputHeader(unsigned short w_PCIBoardEepromAddress,
1083         char *pc_PCIChipInformation, unsigned short w_Address,
1084         str_AnalogOutputHeader *s_Header)
1085 {
1086         unsigned short w_Temp;
1087         /*  No of channels for 1st hard component */
1088         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1089                 pc_PCIChipInformation, 0x100 + w_Address + 10);
1090         s_Header->w_Nchannel = (w_Temp >> 4) & 0x03FF;
1091         /*  Resolution for 1st hard component */
1092         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1093                 pc_PCIChipInformation, 0x100 + w_Address + 16);
1094         s_Header->b_Resolution = (unsigned char) (w_Temp >> 8) & 0xFF;
1095         return 0;
1096 }
1097
1098 /*
1099 +----------------------------------------------------------------------------+
1100 | Function Name  : int i_EepromReadAnlogInputHeader(unsigned short                                       |
1101 |                       w_PCIBoardEepromAddress,char *pc_PCIChipInformation,     |
1102 |                       unsigned short w_Address,struct str_AnalogInputHeader *s_Header)          |
1103 +----------------------------------------------------------------------------+
1104 | Task              : Read Nalog Output  Header                              |
1105 +----------------------------------------------------------------------------+
1106 | Input Parameters  : unsigned short w_PCIBoardEepromAddress : PCI eeprom address      |
1107 |                                                                                                                                        |
1108 |                     char *pc_PCIChipInformation  : PCI Chip Type.          |
1109 |                                                                                                                                        |
1110 |                        struct str_AnalogInputHeader *s_Header:Anlog Input Header      |
1111 |                                                                                          Pointer                               |
1112 +----------------------------------------------------------------------------+
1113 | Output Parameters : -                                                      |
1114 +----------------------------------------------------------------------------+
1115 | Return Value      : 0                                                                              |
1116 +----------------------------------------------------------------------------+
1117 */
1118
1119 /* Reads only for ONE  hardware component */
1120 int i_EepromReadAnlogInputHeader(unsigned short w_PCIBoardEepromAddress,
1121         char *pc_PCIChipInformation, unsigned short w_Address,
1122         struct str_AnalogInputHeader *s_Header)
1123 {
1124         unsigned short w_Temp, w_Offset;
1125         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1126                 pc_PCIChipInformation, 0x100 + w_Address + 10);
1127         s_Header->w_Nchannel = (w_Temp >> 4) & 0x03FF;
1128         s_Header->w_MinConvertTiming =
1129                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
1130                 0x100 + w_Address + 16);
1131         s_Header->w_MinDelayTiming =
1132                 w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation,
1133                 0x100 + w_Address + 30);
1134         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1135                 pc_PCIChipInformation, 0x100 + w_Address + 20);
1136         s_Header->b_HasDma = (w_Temp >> 13) & 0x01;     /*  whether dma present or not */
1137
1138         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress, pc_PCIChipInformation, 0x100 + w_Address + 72);      /*  reading Y */
1139         w_Temp = w_Temp & 0x00FF;
1140         if (w_Temp)             /* Y>0 */
1141         {
1142                 w_Offset = 74 + (2 * w_Temp) + (10 * (1 + (w_Temp / 16)));      /*  offset of first analog input single header */
1143                 w_Offset = w_Offset + 2;        /*  resolution */
1144         } else                  /* Y=0 */
1145         {
1146                 w_Offset = 74;
1147                 w_Offset = w_Offset + 2;        /*  resolution */
1148         }
1149
1150 /* read Resolution */
1151         w_Temp = w_EepromReadWord(w_PCIBoardEepromAddress,
1152                 pc_PCIChipInformation, 0x100 + w_Address + w_Offset);
1153         s_Header->b_Resolution = w_Temp & 0x001F;       /*  last 5 bits */
1154
1155         return 0;
1156 }