drivers/net/irda/via-ircc.h

   1 /*********************************************************************
   2  *
   3  * Filename:      via-ircc.h
   4  * Version:       1.0
   5  * Description:   Driver for the VIA VT8231/VT8233 IrDA chipsets
   6  * Author:        VIA Technologies, inc
   7  * Date  :        08/06/2003
   8
   9 Copyright (c) 1998-2003 VIA Technologies, Inc.
  10
  11 This program is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free Software
  13 Foundation; either version 2, or (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful, but WITHOUT
  16 ANY WARRANTIES OR REPRESENTATIONS; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18 See the GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License along with
  21 this program; if not, write to the Free Software Foundation, Inc.,
  22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23
  24  * Comment:
  25  * jul/08/2002 : Rx buffer length should use Rx ring ptr.
  26  * Oct/28/2002 : Add SB id for 3147 and 3177.
  27  * jul/09/2002 : only implement two kind of dongle currently.
  28  * Oct/02/2002 : work on VT8231 and VT8233 .
  29  * Aug/06/2003 : change driver format to pci driver .
  30  ********************************************************************/
  31 #ifndef via_IRCC_H
  32 #define via_IRCC_H
  33 #include <linux/time.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/pm.h>
  36 #include <linux/types.h>
  37 #include <asm/io.h>
  38
  39 #define MAX_TX_WINDOW 7
  40 #define MAX_RX_WINDOW 7
  41
  42 struct st_fifo_entry {
  43         int status;
  44         int len;
  45 };
  46
  47 struct st_fifo {
  48         struct st_fifo_entry entries[MAX_RX_WINDOW + 2];
  49         int pending_bytes;
  50         int head;
  51         int tail;
  52         int len;
  53 };
  54
  55 struct frame_cb {
  56         void *start;            /* Start of frame in DMA mem */
  57         int len;                /* Lenght of frame in DMA mem */
  58 };
  59
  60 struct tx_fifo {
  61         struct frame_cb queue[MAX_TX_WINDOW + 2];       /* Info about frames in queue */
  62         int ptr;                /* Currently being sent */
  63         int len;                /* Lenght of queue */
  64         int free;               /* Next free slot */
  65         void *tail;             /* Next free start in DMA mem */
  66 };
  67
  68
  69 struct eventflag                // for keeping track of Interrupt Events
  70 {
  71         //--------tx part
  72         unsigned char TxFIFOUnderRun;
  73         unsigned char EOMessage;
  74         unsigned char TxFIFOReady;
  75         unsigned char EarlyEOM;
  76         //--------rx part
  77         unsigned char PHYErr;
  78         unsigned char CRCErr;
  79         unsigned char RxFIFOOverRun;
  80         unsigned char EOPacket;
  81         unsigned char RxAvail;
  82         unsigned char TooLargePacket;
  83         unsigned char SIRBad;
  84         //--------unknown
  85         unsigned char Unknown;
  86         //----------
  87         unsigned char TimeOut;
  88         unsigned char RxDMATC;
  89         unsigned char TxDMATC;
  90 };
  91
  92 /* Private data for each instance */
  93 struct via_ircc_cb {
  94         struct st_fifo st_fifo; /* Info about received frames */
  95         struct tx_fifo tx_fifo; /* Info about frames to be transmitted */
  96
  97         struct net_device *netdev;      /* Yes! we are some kind of netdevice */
  98         struct net_device_stats stats;
  99
 100         struct irlap_cb *irlap; /* The link layer we are binded to */
 101         struct qos_info qos;    /* QoS capabilities for this device */
 102
 103         chipio_t io;            /* IrDA controller information */
 104         iobuff_t tx_buff;       /* Transmit buffer */
 105         iobuff_t rx_buff;       /* Receive buffer */
 106         dma_addr_t tx_buff_dma;
 107         dma_addr_t rx_buff_dma;
 108
 109         __u8 ier;               /* Interrupt enable register */
 110
 111         struct timeval stamp;
 112         struct timeval now;
 113
 114         spinlock_t lock;        /* For serializing operations */
 115
 116         __u32 flags;            /* Interface flags */
 117         __u32 new_speed;
 118         int index;              /* Instance index */
 119
 120         struct eventflag EventFlag;
 121         struct pm_dev *dev;
 122         unsigned int chip_id;   /* to remember chip id */
 123         unsigned int RetryCount;
 124         unsigned int RxDataReady;
 125         unsigned int RxLastCount;
 126 };
 127
 128
 129 //---------I=Infrared,  H=Host, M=Misc, T=Tx, R=Rx, ST=Status,
 130 //         CF=Config, CT=Control, L=Low, H=High, C=Count
 131 #define  I_CF_L_0               0x10
 132 #define  I_CF_H_0               0x11
 133 #define  I_SIR_BOF              0x12
 134 #define  I_SIR_EOF              0x13
 135 #define  I_ST_CT_0              0x15
 136 #define  I_ST_L_1               0x16
 137 #define  I_ST_H_1               0x17
 138 #define  I_CF_L_1               0x18
 139 #define  I_CF_H_1               0x19
 140 #define  I_CF_L_2               0x1a
 141 #define  I_CF_H_2               0x1b
 142 #define  I_CF_3         0x1e
 143 #define  H_CT                   0x20
 144 #define  H_ST                   0x21
 145 #define  M_CT                   0x22
 146 #define  TX_CT_1                0x23
 147 #define  TX_CT_2                0x24
 148 #define  TX_ST                  0x25
 149 #define  RX_CT                  0x26
 150 #define  RX_ST                  0x27
 151 #define  RESET                  0x28
 152 #define  P_ADDR         0x29
 153 #define  RX_C_L         0x2a
 154 #define  RX_C_H         0x2b
 155 #define  RX_P_L         0x2c
 156 #define  RX_P_H         0x2d
 157 #define  TX_C_L         0x2e
 158 #define  TX_C_H         0x2f
 159 #define  TIMER          0x32
 160 #define  I_CF_4                 0x33
 161 #define  I_T_C_L                0x34
 162 #define  I_T_C_H                0x35
 163 #define  VERSION                0x3f
 164 //-------------------------------
 165 #define StartAddr       0x10    // the first register address
 166 #define EndAddr         0x3f    // the last register address
 167 #define GetBit(val,bit)  val = (unsigned char) ((val>>bit) & 0x1)
 168                         // Returns the bit
 169 #define SetBit(val,bit)  val= (unsigned char ) (val | (0x1 << bit))
 170                         // Sets bit to 1
 171 #define ResetBit(val,bit) val= (unsigned char ) (val & ~(0x1 << bit))
 172                         // Sets bit to 0
 173 #define PCI_CONFIG_ADDRESS 0xcf8
 174 #define PCI_CONFIG_DATA    0xcfc
 175
 176 #define VenderID    0x1106
 177 #define DeviceID1   0x8231
 178 #define DeviceID2   0x3109
 179 #define DeviceID3   0x3074
 180 //F01_S
 181 #define DeviceID4   0x3147
 182 #define DeviceID5   0x3177
 183 //F01_E
 184
 185 #define OFF   0
 186 #define ON   1
 187 #define DMA_TX_MODE   0x08
 188 #define DMA_RX_MODE   0x04
 189
 190 #define DMA1   0
 191 #define DMA2   0xc0
 192 #define MASK1   DMA1+0x0a
 193 #define MASK2   DMA2+0x14
 194
 195 #define Clk_bit 0x40
 196 #define Tx_bit 0x01
 197 #define Rd_Valid 0x08
 198 #define RxBit 0x08
 199
 200 static void DisableDmaChannel(unsigned int channel)
 201 {
 202         switch (channel) {      // 8 Bit DMA channels DMAC1
 203         case 0:
 204                 outb(4, MASK1); //mask channel 0
 205                 break;
 206         case 1:
 207                 outb(5, MASK1); //Mask channel 1
 208                 break;
 209         case 2:
 210                 outb(6, MASK1); //Mask channel 2
 211                 break;
 212         case 3:
 213                 outb(7, MASK1); //Mask channel 3
 214                 break;
 215         case 5:
 216                 outb(5, MASK2); //Mask channel 5
 217                 break;
 218         case 6:
 219                 outb(6, MASK2); //Mask channel 6
 220                 break;
 221         case 7:
 222                 outb(7, MASK2); //Mask channel 7
 223                 break;
 224         default:
 225                 break;
 226         };                      //Switch
 227 }
 228
 229 static unsigned char ReadLPCReg(int iRegNum)
 230 {
 231         unsigned char iVal;
 232
 233         outb(0x87, 0x2e);
 234         outb(0x87, 0x2e);
 235         outb(iRegNum, 0x2e);
 236         iVal = inb(0x2f);
 237         outb(0xaa, 0x2e);
 238
 239         return iVal;
 240 }
 241
 242 static void WriteLPCReg(int iRegNum, unsigned char iVal)
 243 {
 244
 245         outb(0x87, 0x2e);
 246         outb(0x87, 0x2e);
 247         outb(iRegNum, 0x2e);
 248         outb(iVal, 0x2f);
 249         outb(0xAA, 0x2e);
 250 }
 251
 252 static __u8 ReadReg(unsigned int BaseAddr, int iRegNum)
 253 {
 254         return ((__u8) inb(BaseAddr + iRegNum));
 255 }
 256
 257 static void WriteReg(unsigned int BaseAddr, int iRegNum, unsigned char iVal)
 258 {
 259         outb(iVal, BaseAddr + iRegNum);
 260 }
 261
 262 static int WriteRegBit(unsigned int BaseAddr, unsigned char RegNum,
 263                 unsigned char BitPos, unsigned char value)
 264 {
 265         __u8 Rtemp, Wtemp;
 266
 267         if (BitPos > 7) {
 268                 return -1;
 269         }
 270         if ((RegNum < StartAddr) || (RegNum > EndAddr))
 271                 return -1;
 272         Rtemp = ReadReg(BaseAddr, RegNum);
 273         if (value == 0)
 274                 Wtemp = ResetBit(Rtemp, BitPos);
 275         else {
 276                 if (value == 1)
 277                         Wtemp = SetBit(Rtemp, BitPos);
 278                 else
 279                         return -1;
 280         }
 281         WriteReg(BaseAddr, RegNum, Wtemp);
 282         return 0;
 283 }
 284
 285 static __u8 CheckRegBit(unsigned int BaseAddr, unsigned char RegNum,
 286                  unsigned char BitPos)
 287 {
 288         __u8 temp;
 289
 290         if (BitPos > 7)
 291                 return 0xff;
 292         if ((RegNum < StartAddr) || (RegNum > EndAddr)) {
 293 //     printf("what is the register %x!\n",RegNum);
 294         }
 295         temp = ReadReg(BaseAddr, RegNum);
 296         return GetBit(temp, BitPos);
 297 }
 298
 299 static void SetMaxRxPacketSize(__u16 iobase, __u16 size)
 300 {
 301         __u16 low, high;
 302         if ((size & 0xe000) == 0) {
 303                 low = size & 0x00ff;
 304                 high = (size & 0x1f00) >> 8;
 305                 WriteReg(iobase, I_CF_L_2, low);
 306                 WriteReg(iobase, I_CF_H_2, high);
 307
 308         }
 309
 310 }
 311
 312 //for both Rx and Tx
 313
 314 static void SetFIFO(__u16 iobase, __u16 value)
 315 {
 316         switch (value) {
 317         case 128:
 318                 WriteRegBit(iobase, 0x11, 0, 0);
 319                 WriteRegBit(iobase, 0x11, 7, 1);
 320                 break;
 321         case 64:
 322                 WriteRegBit(iobase, 0x11, 0, 0);
 323                 WriteRegBit(iobase, 0x11, 7, 0);
 324                 break;
 325         case 32:
 326                 WriteRegBit(iobase, 0x11, 0, 1);
 327                 WriteRegBit(iobase, 0x11, 7, 0);
 328                 break;
 329         default:
 330                 WriteRegBit(iobase, 0x11, 0, 0);
 331                 WriteRegBit(iobase, 0x11, 7, 0);
 332         }
 333
 334 }
 335
 336 #define CRC16(BaseAddr,val)         WriteRegBit(BaseAddr,I_CF_L_0,7,val)        //0 for 32 CRC
 337 /*
 338 #define SetVFIR(BaseAddr,val)       WriteRegBit(BaseAddr,I_CF_H_0,5,val)
 339 #define SetFIR(BaseAddr,val)        WriteRegBit(BaseAddr,I_CF_L_0,6,val)
 340 #define SetMIR(BaseAddr,val)        WriteRegBit(BaseAddr,I_CF_L_0,5,val)
 341 #define SetSIR(BaseAddr,val)        WriteRegBit(BaseAddr,I_CF_L_0,4,val)
 342 */
 343 #define SIRFilter(BaseAddr,val)     WriteRegBit(BaseAddr,I_CF_L_0,3,val)
 344 #define Filter(BaseAddr,val)        WriteRegBit(BaseAddr,I_CF_L_0,2,val)
 345 #define InvertTX(BaseAddr,val)      WriteRegBit(BaseAddr,I_CF_L_0,1,val)
 346 #define InvertRX(BaseAddr,val)      WriteRegBit(BaseAddr,I_CF_L_0,0,val)
 347 //****************************I_CF_H_0
 348 #define EnableTX(BaseAddr,val)      WriteRegBit(BaseAddr,I_CF_H_0,4,val)
 349 #define EnableRX(BaseAddr,val)      WriteRegBit(BaseAddr,I_CF_H_0,3,val)
 350 #define EnableDMA(BaseAddr,val)     WriteRegBit(BaseAddr,I_CF_H_0,2,val)
 351 #define SIRRecvAny(BaseAddr,val)    WriteRegBit(BaseAddr,I_CF_H_0,1,val)
 352 #define DiableTrans(BaseAddr,val)   WriteRegBit(BaseAddr,I_CF_H_0,0,val)
 353 //***************************I_SIR_BOF,I_SIR_EOF
 354 #define SetSIRBOF(BaseAddr,val)     WriteReg(BaseAddr,I_SIR_BOF,val)
 355 #define SetSIREOF(BaseAddr,val)     WriteReg(BaseAddr,I_SIR_EOF,val)
 356 #define GetSIRBOF(BaseAddr)        ReadReg(BaseAddr,I_SIR_BOF)
 357 #define GetSIREOF(BaseAddr)        ReadReg(BaseAddr,I_SIR_EOF)
 358 //*******************I_ST_CT_0
 359 #define EnPhys(BaseAddr,val)   WriteRegBit(BaseAddr,I_ST_CT_0,7,val)
 360 #define IsModeError(BaseAddr) CheckRegBit(BaseAddr,I_ST_CT_0,6) //RO
 361 #define IsVFIROn(BaseAddr)     CheckRegBit(BaseAddr,0x14,0)     //RO for VT1211 only
 362 #define IsFIROn(BaseAddr)     CheckRegBit(BaseAddr,I_ST_CT_0,5) //RO
 363 #define IsMIROn(BaseAddr)     CheckRegBit(BaseAddr,I_ST_CT_0,4) //RO
 364 #define IsSIROn(BaseAddr)     CheckRegBit(BaseAddr,I_ST_CT_0,3) //RO
 365 #define IsEnableTX(BaseAddr)  CheckRegBit(BaseAddr,I_ST_CT_0,2) //RO
 366 #define IsEnableRX(BaseAddr)  CheckRegBit(BaseAddr,I_ST_CT_0,1) //RO
 367 #define Is16CRC(BaseAddr)     CheckRegBit(BaseAddr,I_ST_CT_0,0) //RO
 368 //***************************I_CF_3
 369 #define DisableAdjacentPulseWidth(BaseAddr,val) WriteRegBit(BaseAddr,I_CF_3,5,val)      //1 disable
 370 #define DisablePulseWidthAdjust(BaseAddr,val)   WriteRegBit(BaseAddr,I_CF_3,4,val)      //1 disable
 371 #define UseOneRX(BaseAddr,val)                  WriteRegBit(BaseAddr,I_CF_3,1,val)      //0 use two RX
 372 #define SlowIRRXLowActive(BaseAddr,val)         WriteRegBit(BaseAddr,I_CF_3,0,val)      //0 show RX high=1 in SIR
 373 //***************************H_CT
 374 #define EnAllInt(BaseAddr,val)   WriteRegBit(BaseAddr,H_CT,7,val)
 375 #define TXStart(BaseAddr,val)    WriteRegBit(BaseAddr,H_CT,6,val)
 376 #define RXStart(BaseAddr,val)    WriteRegBit(BaseAddr,H_CT,5,val)
 377 #define ClearRXInt(BaseAddr,val)   WriteRegBit(BaseAddr,H_CT,4,val)     // 1 clear
 378 //*****************H_ST
 379 #define IsRXInt(BaseAddr)           CheckRegBit(BaseAddr,H_ST,4)
 380 #define GetIntIndentify(BaseAddr)   ((ReadReg(BaseAddr,H_ST)&0xf1) >>1)
 381 #define IsHostBusy(BaseAddr)        CheckRegBit(BaseAddr,H_ST,0)
 382 #define GetHostStatus(BaseAddr)     ReadReg(BaseAddr,H_ST)      //RO
 383 //**************************M_CT
 384 #define EnTXDMA(BaseAddr,val)         WriteRegBit(BaseAddr,M_CT,7,val)
 385 #define EnRXDMA(BaseAddr,val)         WriteRegBit(BaseAddr,M_CT,6,val)
 386 #define SwapDMA(BaseAddr,val)         WriteRegBit(BaseAddr,M_CT,5,val)
 387 #define EnInternalLoop(BaseAddr,val)  WriteRegBit(BaseAddr,M_CT,4,val)
 388 #define EnExternalLoop(BaseAddr,val)  WriteRegBit(BaseAddr,M_CT,3,val)
 389 //**************************TX_CT_1
 390 #define EnTXFIFOHalfLevelInt(BaseAddr,val)   WriteRegBit(BaseAddr,TX_CT_1,4,val)        //half empty int (1 half)
 391 #define EnTXFIFOUnderrunEOMInt(BaseAddr,val) WriteRegBit(BaseAddr,TX_CT_1,5,val)
 392 #define EnTXFIFOReadyInt(BaseAddr,val)       WriteRegBit(BaseAddr,TX_CT_1,6,val)        //int when reach it threshold (setting by bit 4)
 393 //**************************TX_CT_2
 394 #define ForceUnderrun(BaseAddr,val)   WriteRegBit(BaseAddr,TX_CT_2,7,val)       // force an underrun int
 395 #define EnTXCRC(BaseAddr,val)         WriteRegBit(BaseAddr,TX_CT_2,6,val)       //1 for FIR,MIR...0 (not SIR)
 396 #define ForceBADCRC(BaseAddr,val)     WriteRegBit(BaseAddr,TX_CT_2,5,val)       //force an bad CRC
 397 #define SendSIP(BaseAddr,val)         WriteRegBit(BaseAddr,TX_CT_2,4,val)       //send indication pulse for prevent SIR disturb
 398 #define ClearEnTX(BaseAddr,val)       WriteRegBit(BaseAddr,TX_CT_2,3,val)       // opposite to EnTX
 399 //*****************TX_ST
 400 #define GetTXStatus(BaseAddr)   ReadReg(BaseAddr,TX_ST) //RO
 401 //**************************RX_CT
 402 #define EnRXSpecInt(BaseAddr,val)           WriteRegBit(BaseAddr,RX_CT,0,val)
 403 #define EnRXFIFOReadyInt(BaseAddr,val)      WriteRegBit(BaseAddr,RX_CT,1,val)   //enable int when reach it threshold (setting by bit 7)
 404 #define EnRXFIFOHalfLevelInt(BaseAddr,val)  WriteRegBit(BaseAddr,RX_CT,7,val)   //enable int when (1) half full...or (0) just not full
 405 //*****************RX_ST
 406 #define GetRXStatus(BaseAddr)   ReadReg(BaseAddr,RX_ST) //RO
 407 //***********************P_ADDR
 408 #define SetPacketAddr(BaseAddr,addr)        WriteReg(BaseAddr,P_ADDR,addr)
 409 //***********************I_CF_4
 410 #define EnGPIOtoRX2(BaseAddr,val)       WriteRegBit(BaseAddr,I_CF_4,7,val)
 411 #define EnTimerInt(BaseAddr,val)                WriteRegBit(BaseAddr,I_CF_4,1,val)
 412 #define ClearTimerInt(BaseAddr,val)     WriteRegBit(BaseAddr,I_CF_4,0,val)
 413 //***********************I_T_C_L
 414 #define WriteGIO(BaseAddr,val)      WriteRegBit(BaseAddr,I_T_C_L,7,val)
 415 #define ReadGIO(BaseAddr)                   CheckRegBit(BaseAddr,I_T_C_L,7)
 416 #define ReadRX(BaseAddr)                    CheckRegBit(BaseAddr,I_T_C_L,3)     //RO
 417 #define WriteTX(BaseAddr,val)           WriteRegBit(BaseAddr,I_T_C_L,0,val)
 418 //***********************I_T_C_H
 419 #define EnRX2(BaseAddr,val)                 WriteRegBit(BaseAddr,I_T_C_H,7,val)
 420 #define ReadRX2(BaseAddr)           CheckRegBit(BaseAddr,I_T_C_H,7)
 421 //**********************Version
 422 #define GetFIRVersion(BaseAddr)         ReadReg(BaseAddr,VERSION)
 423
 424
 425 static void SetTimer(__u16 iobase, __u8 count)
 426 {
 427         EnTimerInt(iobase, OFF);
 428         WriteReg(iobase, TIMER, count);
 429         EnTimerInt(iobase, ON);
 430 }
 431
 432
 433 static void SetSendByte(__u16 iobase, __u32 count)
 434 {
 435         __u32 low, high;
 436
 437         if ((count & 0xf000) == 0) {
 438                 low = count & 0x00ff;
 439                 high = (count & 0x0f00) >> 8;
 440                 WriteReg(iobase, TX_C_L, low);
 441                 WriteReg(iobase, TX_C_H, high);
 442         }
 443 }
 444
 445 static void ResetChip(__u16 iobase, __u8 type)
 446 {
 447         __u8 value;
 448
 449         value = (type + 2) << 4;
 450         WriteReg(iobase, RESET, type);
 451 }
 452
 453 static int CkRxRecv(__u16 iobase, struct via_ircc_cb *self)
 454 {
 455         __u8 low, high;
 456         __u16 wTmp = 0, wTmp1 = 0, wTmp_new = 0;
 457
 458         low = ReadReg(iobase, RX_C_L);
 459         high = ReadReg(iobase, RX_C_H);
 460         wTmp1 = high;
 461         wTmp = (wTmp1 << 8) | low;
 462         udelay(10);
 463         low = ReadReg(iobase, RX_C_L);
 464         high = ReadReg(iobase, RX_C_H);
 465         wTmp1 = high;
 466         wTmp_new = (wTmp1 << 8) | low;
 467         if (wTmp_new != wTmp)
 468                 return 1;
 469         else
 470                 return 0;
 471
 472 }
 473
 474 static __u16 RxCurCount(__u16 iobase, struct via_ircc_cb * self)
 475 {
 476         __u8 low, high;
 477         __u16 wTmp = 0, wTmp1 = 0;
 478
 479         low = ReadReg(iobase, RX_P_L);
 480         high = ReadReg(iobase, RX_P_H);
 481         wTmp1 = high;
 482         wTmp = (wTmp1 << 8) | low;
 483         return wTmp;
 484 }
 485
 486 /* This Routine can only use in recevie_complete
 487  * for it will update last count.
 488  */
 489
 490 static __u16 GetRecvByte(__u16 iobase, struct via_ircc_cb * self)
 491 {
 492         __u8 low, high;
 493         __u16 wTmp, wTmp1, ret;
 494
 495         low = ReadReg(iobase, RX_P_L);
 496         high = ReadReg(iobase, RX_P_H);
 497         wTmp1 = high;
 498         wTmp = (wTmp1 << 8) | low;
 499
 500
 501         if (wTmp >= self->RxLastCount)
 502                 ret = wTmp - self->RxLastCount;
 503         else
 504                 ret = (0x8000 - self->RxLastCount) + wTmp;
 505         self->RxLastCount = wTmp;
 506
 507 /* RX_P is more actually the RX_C
 508  low=ReadReg(iobase,RX_C_L);
 509  high=ReadReg(iobase,RX_C_H);
 510
 511  if(!(high&0xe000)) {
 512          temp=(high<<8)+low;
 513          return temp;
 514  }
 515  else return 0;
 516 */
 517         return ret;
 518 }
 519
 520 static void Sdelay(__u16 scale)
 521 {
 522         __u8 bTmp;
 523         int i, j;
 524
 525         for (j = 0; j < scale; j++) {
 526                 for (i = 0; i < 0x20; i++) {
 527                         bTmp = inb(0xeb);
 528                         outb(bTmp, 0xeb);
 529                 }
 530         }
 531 }
 532
 533 static void Tdelay(__u16 scale)
 534 {
 535         __u8 bTmp;
 536         int i, j;
 537
 538         for (j = 0; j < scale; j++) {
 539                 for (i = 0; i < 0x50; i++) {
 540                         bTmp = inb(0xeb);
 541                         outb(bTmp, 0xeb);
 542                 }
 543         }
 544 }
 545
 546
 547 static void ActClk(__u16 iobase, __u8 value)
 548 {
 549         __u8 bTmp;
 550         bTmp = ReadReg(iobase, 0x34);
 551         if (value)
 552                 WriteReg(iobase, 0x34, bTmp | Clk_bit);
 553         else
 554                 WriteReg(iobase, 0x34, bTmp & ~Clk_bit);
 555 }
 556
 557 static void ClkTx(__u16 iobase, __u8 Clk, __u8 Tx)
 558 {
 559         __u8 bTmp;
 560
 561         bTmp = ReadReg(iobase, 0x34);
 562         if (Clk == 0)
 563                 bTmp &= ~Clk_bit;
 564         else {
 565                 if (Clk == 1)
 566                         bTmp |= Clk_bit;
 567         }
 568         WriteReg(iobase, 0x34, bTmp);
 569         Sdelay(1);
 570         if (Tx == 0)
 571                 bTmp &= ~Tx_bit;
 572         else {
 573                 if (Tx == 1)
 574                         bTmp |= Tx_bit;
 575         }
 576         WriteReg(iobase, 0x34, bTmp);
 577 }
 578
 579 static void Wr_Byte(__u16 iobase, __u8 data)
 580 {
 581         __u8 bData = data;
 582 //      __u8 btmp;
 583         int i;
 584
 585         ClkTx(iobase, 0, 1);
 586
 587         Tdelay(2);
 588         ActClk(iobase, 1);
 589         Tdelay(1);
 590
 591         for (i = 0; i < 8; i++) {       //LDN
 592
 593                 if ((bData >> i) & 0x01) {
 594                         ClkTx(iobase, 0, 1);    //bit data = 1;
 595                 } else {
 596                         ClkTx(iobase, 0, 0);    //bit data = 1;
 597                 }
 598                 Tdelay(2);
 599                 Sdelay(1);
 600                 ActClk(iobase, 1);      //clk hi
 601                 Tdelay(1);
 602         }
 603 }
 604
 605 static __u8 Rd_Indx(__u16 iobase, __u8 addr, __u8 index)
 606 {
 607         __u8 data = 0, bTmp, data_bit;
 608         int i;
 609
 610         bTmp = addr | (index << 1) | 0;
 611         ClkTx(iobase, 0, 0);
 612         Tdelay(2);
 613         ActClk(iobase, 1);
 614         udelay(1);
 615         Wr_Byte(iobase, bTmp);
 616         Sdelay(1);
 617         ClkTx(iobase, 0, 0);
 618         Tdelay(2);
 619         for (i = 0; i < 10; i++) {
 620                 ActClk(iobase, 1);
 621                 Tdelay(1);
 622                 ActClk(iobase, 0);
 623                 Tdelay(1);
 624                 ClkTx(iobase, 0, 1);
 625                 Tdelay(1);
 626                 bTmp = ReadReg(iobase, 0x34);
 627                 if (!(bTmp & Rd_Valid))
 628                         break;
 629         }
 630         if (!(bTmp & Rd_Valid)) {
 631                 for (i = 0; i < 8; i++) {
 632                         ActClk(iobase, 1);
 633                         Tdelay(1);
 634                         ActClk(iobase, 0);
 635                         bTmp = ReadReg(iobase, 0x34);
 636                         data_bit = 1 << i;
 637                         if (bTmp & RxBit)
 638                                 data |= data_bit;
 639                         else
 640                                 data &= ~data_bit;
 641                         Tdelay(2);
 642                 }
 643         } else {
 644                 for (i = 0; i < 2; i++) {
 645                         ActClk(iobase, 1);
 646                         Tdelay(1);
 647                         ActClk(iobase, 0);
 648                         Tdelay(2);
 649                 }
 650                 bTmp = ReadReg(iobase, 0x34);
 651         }
 652         for (i = 0; i < 1; i++) {
 653                 ActClk(iobase, 1);
 654                 Tdelay(1);
 655                 ActClk(iobase, 0);
 656                 Tdelay(2);
 657         }
 658         ClkTx(iobase, 0, 0);
 659         Tdelay(1);
 660         for (i = 0; i < 3; i++) {
 661                 ActClk(iobase, 1);
 662                 Tdelay(1);
 663                 ActClk(iobase, 0);
 664                 Tdelay(2);
 665         }
 666         return data;
 667 }
 668
 669 static void Wr_Indx(__u16 iobase, __u8 addr, __u8 index, __u8 data)
 670 {
 671         int i;
 672         __u8 bTmp;
 673
 674         ClkTx(iobase, 0, 0);
 675         udelay(2);
 676         ActClk(iobase, 1);
 677         udelay(1);
 678         bTmp = addr | (index << 1) | 1;
 679         Wr_Byte(iobase, bTmp);
 680         Wr_Byte(iobase, data);
 681         for (i = 0; i < 2; i++) {
 682                 ClkTx(iobase, 0, 0);
 683                 Tdelay(2);
 684                 ActClk(iobase, 1);
 685                 Tdelay(1);
 686         }
 687         ActClk(iobase, 0);
 688 }
 689
 690 static void ResetDongle(__u16 iobase)
 691 {
 692         int i;
 693         ClkTx(iobase, 0, 0);
 694         Tdelay(1);
 695         for (i = 0; i < 30; i++) {
 696                 ActClk(iobase, 1);
 697                 Tdelay(1);
 698                 ActClk(iobase, 0);
 699                 Tdelay(1);
 700         }
 701         ActClk(iobase, 0);
 702 }
 703
 704 static void SetSITmode(__u16 iobase)
 705 {
 706
 707         __u8 bTmp;
 708
 709         bTmp = ReadLPCReg(0x28);
 710         WriteLPCReg(0x28, bTmp | 0x10); //select ITMOFF
 711         bTmp = ReadReg(iobase, 0x35);
 712         WriteReg(iobase, 0x35, bTmp | 0x40);    // Driver ITMOFF
 713         WriteReg(iobase, 0x28, bTmp | 0x80);    // enable All interrupt
 714 }
 715
 716 static void SI_SetMode(__u16 iobase, int mode)
 717 {
 718         //__u32 dTmp;
 719         __u8 bTmp;
 720
 721         WriteLPCReg(0x28, 0x70);        // S/W Reset
 722         SetSITmode(iobase);
 723         ResetDongle(iobase);
 724         udelay(10);
 725         Wr_Indx(iobase, 0x40, 0x0, 0x17);       //RX ,APEN enable,Normal power
 726         Wr_Indx(iobase, 0x40, 0x1, mode);       //Set Mode
 727         Wr_Indx(iobase, 0x40, 0x2, 0xff);       //Set power to FIR VFIR > 1m
 728         bTmp = Rd_Indx(iobase, 0x40, 1);
 729 }
 730
 731 static void InitCard(__u16 iobase)
 732 {
 733         ResetChip(iobase, 5);
 734         WriteReg(iobase, I_ST_CT_0, 0x00);      // open CHIP on
 735         SetSIRBOF(iobase, 0xc0);        // hardware default value
 736         SetSIREOF(iobase, 0xc1);
 737 }
 738
 739 static void CommonInit(__u16 iobase)
 740 {
 741 //  EnTXCRC(iobase,0);
 742         SwapDMA(iobase, OFF);
 743         SetMaxRxPacketSize(iobase, 0x0fff);     //set to max:4095
 744         EnRXFIFOReadyInt(iobase, OFF);
 745         EnRXFIFOHalfLevelInt(iobase, OFF);
 746         EnTXFIFOHalfLevelInt(iobase, OFF);
 747         EnTXFIFOUnderrunEOMInt(iobase, ON);
 748 //  EnTXFIFOReadyInt(iobase,ON);
 749         InvertTX(iobase, OFF);
 750         InvertRX(iobase, OFF);
 751 //  WriteLPCReg(0xF0,0); //(if VT1211 then do this)
 752         if (IsSIROn(iobase)) {
 753                 SIRFilter(iobase, ON);
 754                 SIRRecvAny(iobase, ON);
 755         } else {
 756                 SIRFilter(iobase, OFF);
 757                 SIRRecvAny(iobase, OFF);
 758         }
 759         EnRXSpecInt(iobase, ON);
 760         WriteReg(iobase, I_ST_CT_0, 0x80);
 761         EnableDMA(iobase, ON);
 762 }
 763
 764 static void SetBaudRate(__u16 iobase, __u32 rate)
 765 {
 766         __u8 value = 11, temp;
 767
 768         if (IsSIROn(iobase)) {
 769                 switch (rate) {
 770                 case (__u32) (2400L):
 771                         value = 47;
 772                         break;
 773                 case (__u32) (9600L):
 774                         value = 11;
 775                         break;
 776                 case (__u32) (19200L):
 777                         value = 5;
 778                         break;
 779                 case (__u32) (38400L):
 780                         value = 2;
 781                         break;
 782                 case (__u32) (57600L):
 783                         value = 1;
 784                         break;
 785                 case (__u32) (115200L):
 786                         value = 0;
 787                         break;
 788                 default:
 789                         break;
 790                 };
 791         } else if (IsMIROn(iobase)) {
 792                 value = 0;      // will automatically be fixed in 1.152M
 793         } else if (IsFIROn(iobase)) {
 794                 value = 0;      // will automatically be fixed in 4M
 795         }
 796         temp = (ReadReg(iobase, I_CF_H_1) & 0x03);
 797         temp = temp | (value << 2);
 798         WriteReg(iobase, I_CF_H_1, temp);
 799 }
 800
 801 static void SetPulseWidth(__u16 iobase, __u8 width)
 802 {
 803         __u8 temp, temp1, temp2;
 804
 805         temp = (ReadReg(iobase, I_CF_L_1) & 0x1f);
 806         temp1 = (ReadReg(iobase, I_CF_H_1) & 0xfc);
 807         temp2 = (width & 0x07) << 5;
 808         temp = temp | temp2;
 809         temp2 = (width & 0x18) >> 3;
 810         temp1 = temp1 | temp2;
 811         WriteReg(iobase, I_CF_L_1, temp);
 812         WriteReg(iobase, I_CF_H_1, temp1);
 813 }
 814
 815 static void SetSendPreambleCount(__u16 iobase, __u8 count)
 816 {
 817         __u8 temp;
 818
 819         temp = ReadReg(iobase, I_CF_L_1) & 0xe0;
 820         temp = temp | count;
 821         WriteReg(iobase, I_CF_L_1, temp);
 822
 823 }
 824
 825 static void SetVFIR(__u16 BaseAddr, __u8 val)
 826 {
 827         __u8 tmp;
 828
 829         tmp = ReadReg(BaseAddr, I_CF_L_0);
 830         WriteReg(BaseAddr, I_CF_L_0, tmp & 0x8f);
 831         WriteRegBit(BaseAddr, I_CF_H_0, 5, val);
 832 }
 833
 834 static void SetFIR(__u16 BaseAddr, __u8 val)
 835 {
 836         __u8 tmp;
 837
 838         WriteRegBit(BaseAddr, I_CF_H_0, 5, 0);
 839         tmp = ReadReg(BaseAddr, I_CF_L_0);
 840         WriteReg(BaseAddr, I_CF_L_0, tmp & 0x8f);
 841         WriteRegBit(BaseAddr, I_CF_L_0, 6, val);
 842 }
 843
 844 static void SetMIR(__u16 BaseAddr, __u8 val)
 845 {
 846         __u8 tmp;
 847
 848         WriteRegBit(BaseAddr, I_CF_H_0, 5, 0);
 849         tmp = ReadReg(BaseAddr, I_CF_L_0);
 850         WriteReg(BaseAddr, I_CF_L_0, tmp & 0x8f);
 851         WriteRegBit(BaseAddr, I_CF_L_0, 5, val);
 852 }
 853
 854 static void SetSIR(__u16 BaseAddr, __u8 val)
 855 {
 856         __u8 tmp;
 857
 858         WriteRegBit(BaseAddr, I_CF_H_0, 5, 0);
 859         tmp = ReadReg(BaseAddr, I_CF_L_0);
 860         WriteReg(BaseAddr, I_CF_L_0, tmp & 0x8f);
 861         WriteRegBit(BaseAddr, I_CF_L_0, 4, val);
 862 }
 863
 864 #endif                          /* via_IRCC_H */