drivers/net/irda/via-ircc.c

   1 /********************************************************************
   2  Filename:      via-ircc.c
   3  Version:       1.0
   4  Description:   Driver for the VIA VT8231/VT8233 IrDA chipsets
   5  Author:        VIA Technologies,inc
   6  Date  :        08/06/2003
   7
   8 Copyright (c) 1998-2003 VIA Technologies, Inc.
   9
  10 This program is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free Software
  12 Foundation; either version 2, or (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful, but WITHOUT
  15 ANY WARRANTIES OR REPRESENTATIONS; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17 See the GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License along with
  20 this program; if not, write to the Free Software Foundation, Inc.,
  21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22
  23 F01 Oct/02/02: Modify code for V0.11(move out back to back transfer)
  24 F02 Oct/28/02: Add SB device ID for 3147 and 3177.
  25  Comment :
  26        jul/09/2002 : only implement two kind of dongle currently.
  27        Oct/02/2002 : work on VT8231 and VT8233 .
  28        Aug/06/2003 : change driver format to pci driver .
  29
  30 2004-02-16: <sda@bdit.de>
  31 - Removed unneeded 'legacy' pci stuff.
  32 - Make sure SIR mode is set (hw_init()) before calling mode-dependant stuff.
  33 - On speed change from core, don't send SIR frame with new speed.
  34   Use current speed and change speeds later.
  35 - Make module-param dongle_id actually work.
  36 - New dongle_id 17 (0x11): TDFS4500. Single-ended SIR only.
  37   Tested with home-grown PCB on EPIA boards.
  38 - Code cleanup.
  39
  40  ********************************************************************/
  41 #include <linux/module.h>
  42 #include <linux/kernel.h>
  43 #include <linux/types.h>
  44 #include <linux/skbuff.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/ioport.h>
  47 #include <linux/delay.h>
  48 #include <linux/init.h>
  49 #include <linux/rtnetlink.h>
  50 #include <linux/pci.h>
  51 #include <linux/dma-mapping.h>
  52 #include <linux/gfp.h>
  53
  54 #include <asm/io.h>
  55 #include <asm/dma.h>
  56 #include <asm/byteorder.h>
  57
  58 #include <linux/pm.h>
  59
  60 #include <net/irda/wrapper.h>
  61 #include <net/irda/irda.h>
  62 #include <net/irda/irda_device.h>
  63
  64 #include "via-ircc.h"
  65
  66 #define VIA_MODULE_NAME "via-ircc"
  67 #define CHIP_IO_EXTENT 0x40
  68
  69 static char *driver_name = VIA_MODULE_NAME;
  70
  71 /* Module parameters */
  72 static int qos_mtt_bits = 0x07; /* 1 ms or more */
  73 static int dongle_id = 0;       /* default: probe */
  74
  75 /* We can't guess the type of connected dongle, user *must* supply it. */
  76 module_param(dongle_id, int, 0);
  77
  78 /* FIXME : we should not need this, because instances should be automatically
  79  * managed by the PCI layer. Especially that we seem to only be using the
  80  * first entry. Jean II */
  81 /* Max 4 instances for now */
  82 static struct via_ircc_cb *dev_self[] = { NULL, NULL, NULL, NULL };
  83
  84 /* Some prototypes */
  85 static int via_ircc_open(int i, chipio_t * info, unsigned int id);
  86 static int via_ircc_close(struct via_ircc_cb *self);
  87 static int via_ircc_dma_receive(struct via_ircc_cb *self);
  88 static int via_ircc_dma_receive_complete(struct via_ircc_cb *self,
  89                                          int iobase);
  90 static netdev_tx_t via_ircc_hard_xmit_sir(struct sk_buff *skb,
  91                                                 struct net_device *dev);
  92 static netdev_tx_t via_ircc_hard_xmit_fir(struct sk_buff *skb,
  93                                                 struct net_device *dev);
  94 static void via_hw_init(struct via_ircc_cb *self);
  95 static void via_ircc_change_speed(struct via_ircc_cb *self, __u32 baud);
  96 static irqreturn_t via_ircc_interrupt(int irq, void *dev_id);
  97 static int via_ircc_is_receiving(struct via_ircc_cb *self);
  98 static int via_ircc_read_dongle_id(int iobase);
  99
 100 static int via_ircc_net_open(struct net_device *dev);
 101 static int via_ircc_net_close(struct net_device *dev);
 102 static int via_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq,
 103                               int cmd);
 104 static void via_ircc_change_dongle_speed(int iobase, int speed,
 105                                          int dongle_id);
 106 static int RxTimerHandler(struct via_ircc_cb *self, int iobase);
 107 static void hwreset(struct via_ircc_cb *self);
 108 static int via_ircc_dma_xmit(struct via_ircc_cb *self, u16 iobase);
 109 static int upload_rxdata(struct via_ircc_cb *self, int iobase);
 110 static int __devinit via_init_one (struct pci_dev *pcidev, const struct pci_device_id *id);
 111 static void __devexit via_remove_one (struct pci_dev *pdev);
 112
 113 /* FIXME : Should use udelay() instead, even if we are x86 only - Jean II */
 114 static void iodelay(int udelay)
 115 {
 116         u8 data;
 117         int i;
 118
 119         for (i = 0; i < udelay; i++) {
 120                 data = inb(0x80);
 121         }
 122 }
 123
 124 static DEFINE_PCI_DEVICE_TABLE(via_pci_tbl) = {
 125         { PCI_VENDOR_ID_VIA, 0x8231, PCI_ANY_ID, PCI_ANY_ID,0,0,0 },
 126         { PCI_VENDOR_ID_VIA, 0x3109, PCI_ANY_ID, PCI_ANY_ID,0,0,1 },
 127         { PCI_VENDOR_ID_VIA, 0x3074, PCI_ANY_ID, PCI_ANY_ID,0,0,2 },
 128         { PCI_VENDOR_ID_VIA, 0x3147, PCI_ANY_ID, PCI_ANY_ID,0,0,3 },
 129         { PCI_VENDOR_ID_VIA, 0x3177, PCI_ANY_ID, PCI_ANY_ID,0,0,4 },
 130         { 0, }
 131 };
 132
 133 MODULE_DEVICE_TABLE(pci,via_pci_tbl);
 134
 135
 136 static struct pci_driver via_driver = {
 137         .name           = VIA_MODULE_NAME,
 138         .id_table       = via_pci_tbl,
 139         .probe          = via_init_one,
 140         .remove         = __devexit_p(via_remove_one),
 141 };
 142
 143
 144 /*
 145  * Function via_ircc_init ()
 146  *
 147  *    Initialize chip. Just find out chip type and resource.
 148  */
 149 static int __init via_ircc_init(void)
 150 {
 151         int rc;
 152
 153         IRDA_DEBUG(3, "%s()\n", __func__);
 154
 155         rc = pci_register_driver(&via_driver);
 156         if (rc < 0) {
 157                 IRDA_DEBUG(0, "%s(): error rc = %d, returning  -ENODEV...\n",
 158                            __func__, rc);
 159                 return -ENODEV;
 160         }
 161         return 0;
 162 }
 163
 164 static int __devinit via_init_one (struct pci_dev *pcidev, const struct pci_device_id *id)
 165 {
 166         int rc;
 167         u8 temp,oldPCI_40,oldPCI_44,bTmp,bTmp1;
 168         u16 Chipset,FirDRQ1,FirDRQ0,FirIRQ,FirIOBase;
 169         chipio_t info;
 170
 171         IRDA_DEBUG(2, "%s(): Device ID=(0X%X)\n", __func__, id->device);
 172
 173         rc = pci_enable_device (pcidev);
 174         if (rc) {
 175                 IRDA_DEBUG(0, "%s(): error rc = %d\n", __func__, rc);
 176                 return -ENODEV;
 177         }
 178
 179         // South Bridge exist
 180         if ( ReadLPCReg(0x20) != 0x3C )
 181                 Chipset=0x3096;
 182         else
 183                 Chipset=0x3076;
 184
 185         if (Chipset==0x3076) {
 186                 IRDA_DEBUG(2, "%s(): Chipset = 3076\n", __func__);
 187
 188                 WriteLPCReg(7,0x0c );
 189                 temp=ReadLPCReg(0x30);//check if BIOS Enable Fir
 190                 if((temp&0x01)==1) {   // BIOS close or no FIR
 191                         WriteLPCReg(0x1d, 0x82 );
 192                         WriteLPCReg(0x23,0x18);
 193                         temp=ReadLPCReg(0xF0);
 194                         if((temp&0x01)==0) {
 195                                 temp=(ReadLPCReg(0x74)&0x03);    //DMA
 196                                 FirDRQ0=temp + 4;
 197                                 temp=(ReadLPCReg(0x74)&0x0C) >> 2;
 198                                 FirDRQ1=temp + 4;
 199                         } else {
 200                                 temp=(ReadLPCReg(0x74)&0x0C) >> 2;    //DMA
 201                                 FirDRQ0=temp + 4;
 202                                 FirDRQ1=FirDRQ0;
 203                         }
 204                         FirIRQ=(ReadLPCReg(0x70)&0x0f);         //IRQ
 205                         FirIOBase=ReadLPCReg(0x60 ) << 8;       //IO Space :high byte
 206                         FirIOBase=FirIOBase| ReadLPCReg(0x61) ; //low byte
 207                         FirIOBase=FirIOBase  ;
 208                         info.fir_base=FirIOBase;
 209                         info.irq=FirIRQ;
 210                         info.dma=FirDRQ1;
 211                         info.dma2=FirDRQ0;
 212                         pci_read_config_byte(pcidev,0x40,&bTmp);
 213                         pci_write_config_byte(pcidev,0x40,((bTmp | 0x08) & 0xfe));
 214                         pci_read_config_byte(pcidev,0x42,&bTmp);
 215                         pci_write_config_byte(pcidev,0x42,(bTmp | 0xf0));
 216                         pci_write_config_byte(pcidev,0x5a,0xc0);
 217                         WriteLPCReg(0x28, 0x70 );
 218                         if (via_ircc_open(0, &info,0x3076) == 0)
 219                                 rc=0;
 220                 } else
 221                         rc = -ENODEV; //IR not turn on
 222         } else { //Not VT1211
 223                 IRDA_DEBUG(2, "%s(): Chipset = 3096\n", __func__);
 224
 225                 pci_read_config_byte(pcidev,0x67,&bTmp);//check if BIOS Enable Fir
 226                 if((bTmp&0x01)==1) {  // BIOS enable FIR
 227                         //Enable Double DMA clock
 228                         pci_read_config_byte(pcidev,0x42,&oldPCI_40);
 229                         pci_write_config_byte(pcidev,0x42,oldPCI_40 | 0x80);
 230                         pci_read_config_byte(pcidev,0x40,&oldPCI_40);
 231                         pci_write_config_byte(pcidev,0x40,oldPCI_40 & 0xf7);
 232                         pci_read_config_byte(pcidev,0x44,&oldPCI_44);
 233                         pci_write_config_byte(pcidev,0x44,0x4e);
 234   //---------- read configuration from Function0 of south bridge
 235                         if((bTmp&0x02)==0) {
 236                                 pci_read_config_byte(pcidev,0x44,&bTmp1); //DMA
 237                                 FirDRQ0 = (bTmp1 & 0x30) >> 4;
 238                                 pci_read_config_byte(pcidev,0x44,&bTmp1);
 239                                 FirDRQ1 = (bTmp1 & 0xc0) >> 6;
 240                         } else  {
 241                                 pci_read_config_byte(pcidev,0x44,&bTmp1);    //DMA
 242                                 FirDRQ0 = (bTmp1 & 0x30) >> 4 ;
 243                                 FirDRQ1=0;
 244                         }
 245                         pci_read_config_byte(pcidev,0x47,&bTmp1);  //IRQ
 246                         FirIRQ = bTmp1 & 0x0f;
 247
 248                         pci_read_config_byte(pcidev,0x69,&bTmp);
 249                         FirIOBase = bTmp << 8;//hight byte
 250                         pci_read_config_byte(pcidev,0x68,&bTmp);
 251                         FirIOBase = (FirIOBase | bTmp ) & 0xfff0;
 252   //-------------------------
 253                         info.fir_base=FirIOBase;
 254                         info.irq=FirIRQ;
 255                         info.dma=FirDRQ1;
 256                         info.dma2=FirDRQ0;
 257                         if (via_ircc_open(0, &info,0x3096) == 0)
 258                                 rc=0;
 259                 } else
 260                         rc = -ENODEV; //IR not turn on !!!!!
 261         }//Not VT1211
 262
 263         IRDA_DEBUG(2, "%s(): End - rc = %d\n", __func__, rc);
 264         return rc;
 265 }
 266
 267 /*
 268  * Function via_ircc_clean ()
 269  *
 270  *    Close all configured chips
 271  *
 272  */
 273 static void via_ircc_clean(void)
 274 {
 275         int i;
 276
 277         IRDA_DEBUG(3, "%s()\n", __func__);
 278
 279         for (i=0; i < ARRAY_SIZE(dev_self); i++) {
 280                 if (dev_self[i])
 281                         via_ircc_close(dev_self[i]);
 282         }
 283 }
 284
 285 static void __devexit via_remove_one (struct pci_dev *pdev)
 286 {
 287         IRDA_DEBUG(3, "%s()\n", __func__);
 288
 289         /* FIXME : This is ugly. We should use pci_get_drvdata(pdev);
 290          * to get our driver instance and call directly via_ircc_close().
 291          * See vlsi_ir for details...
 292          * Jean II */
 293         via_ircc_clean();
 294
 295         /* FIXME : This should be in via_ircc_close(), because here we may
 296          * theoritically disable still configured devices :-( - Jean II */
 297         pci_disable_device(pdev);
 298 }
 299
 300 static void __exit via_ircc_cleanup(void)
 301 {
 302         IRDA_DEBUG(3, "%s()\n", __func__);
 303
 304         /* FIXME : This should be redundant, as pci_unregister_driver()
 305          * should call via_remove_one() on each device.
 306          * Jean II */
 307         via_ircc_clean();
 308
 309         /* Cleanup all instances of the driver */
 310         pci_unregister_driver (&via_driver);
 311 }
 312
 313 static const struct net_device_ops via_ircc_sir_ops = {
 314         .ndo_start_xmit = via_ircc_hard_xmit_sir,
 315         .ndo_open = via_ircc_net_open,
 316         .ndo_stop = via_ircc_net_close,
 317         .ndo_do_ioctl = via_ircc_net_ioctl,
 318 };
 319 static const struct net_device_ops via_ircc_fir_ops = {
 320         .ndo_start_xmit = via_ircc_hard_xmit_fir,
 321         .ndo_open = via_ircc_net_open,
 322         .ndo_stop = via_ircc_net_close,
 323         .ndo_do_ioctl = via_ircc_net_ioctl,
 324 };
 325
 326 /*
 327  * Function via_ircc_open (iobase, irq)
 328  *
 329  *    Open driver instance
 330  *
 331  */
 332 static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id)
 333 {
 334         struct net_device *dev;
 335         struct via_ircc_cb *self;
 336         int err;
 337
 338         IRDA_DEBUG(3, "%s()\n", __func__);
 339
 340         if (i >= ARRAY_SIZE(dev_self))
 341                 return -ENOMEM;
 342
 343         /* Allocate new instance of the driver */
 344         dev = alloc_irdadev(sizeof(struct via_ircc_cb));
 345         if (dev == NULL)
 346                 return -ENOMEM;
 347
 348         self = netdev_priv(dev);
 349         self->netdev = dev;
 350         spin_lock_init(&self->lock);
 351
 352         /* FIXME : We should store our driver instance in the PCI layer,
 353          * using pci_set_drvdata(), not in this array.
 354          * See vlsi_ir for details... - Jean II */
 355         /* FIXME : 'i' is always 0 (see via_init_one()) :-( - Jean II */
 356         /* Need to store self somewhere */
 357         dev_self[i] = self;
 358         self->index = i;
 359         /* Initialize Resource */
 360         self->io.cfg_base = info->cfg_base;
 361         self->io.fir_base = info->fir_base;
 362         self->io.irq = info->irq;
 363         self->io.fir_ext = CHIP_IO_EXTENT;
 364         self->io.dma = info->dma;
 365         self->io.dma2 = info->dma2;
 366         self->io.fifo_size = 32;
 367         self->chip_id = id;
 368         self->st_fifo.len = 0;
 369         self->RxDataReady = 0;
 370
 371         /* Reserve the ioports that we need */
 372         if (!request_region(self->io.fir_base, self->io.fir_ext, driver_name)) {
 373                 IRDA_DEBUG(0, "%s(), can't get iobase of 0x%03x\n",
 374                            __func__, self->io.fir_base);
 375                 err = -ENODEV;
 376                 goto err_out1;
 377         }
 378
 379         /* Initialize QoS for this device */
 380         irda_init_max_qos_capabilies(&self->qos);
 381
 382         /* Check if user has supplied the dongle id or not */
 383         if (!dongle_id)
 384                 dongle_id = via_ircc_read_dongle_id(self->io.fir_base);
 385         self->io.dongle_id = dongle_id;
 386
 387         /* The only value we must override it the baudrate */
 388         /* Maximum speeds and capabilities are dongle-dependant. */
 389         switch( self->io.dongle_id ){
 390         case 0x0d:
 391                 self->qos.baud_rate.bits =
 392                     IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200 |
 393                     IR_576000 | IR_1152000 | (IR_4000000 << 8);
 394                 break;
 395         default:
 396                 self->qos.baud_rate.bits =
 397                     IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200;
 398                 break;
 399         }
 400
 401         /* Following was used for testing:
 402          *
 403          *   self->qos.baud_rate.bits = IR_9600;
 404          *
 405          * Is is no good, as it prohibits (error-prone) speed-changes.
 406          */
 407
 408         self->qos.min_turn_time.bits = qos_mtt_bits;
 409         irda_qos_bits_to_value(&self->qos);
 410
 411         /* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */
 412         self->rx_buff.truesize = 14384 + 2048;
 413         self->tx_buff.truesize = 14384 + 2048;
 414
 415         /* Allocate memory if needed */
 416         self->rx_buff.head =
 417                 dma_alloc_coherent(NULL, self->rx_buff.truesize,
 418                                    &self->rx_buff_dma, GFP_KERNEL);
 419         if (self->rx_buff.head == NULL) {
 420                 err = -ENOMEM;
 421                 goto err_out2;
 422         }
 423         memset(self->rx_buff.head, 0, self->rx_buff.truesize);
 424
 425         self->tx_buff.head =
 426                 dma_alloc_coherent(NULL, self->tx_buff.truesize,
 427                                    &self->tx_buff_dma, GFP_KERNEL);
 428         if (self->tx_buff.head == NULL) {
 429                 err = -ENOMEM;
 430                 goto err_out3;
 431         }
 432         memset(self->tx_buff.head, 0, self->tx_buff.truesize);
 433
 434         self->rx_buff.in_frame = FALSE;
 435         self->rx_buff.state = OUTSIDE_FRAME;
 436         self->tx_buff.data = self->tx_buff.head;
 437         self->rx_buff.data = self->rx_buff.head;
 438
 439         /* Reset Tx queue info */
 440         self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
 441         self->tx_fifo.tail = self->tx_buff.head;
 442
 443         /* Override the network functions we need to use */
 444         dev->netdev_ops = &via_ircc_sir_ops;
 445
 446         err = register_netdev(dev);
 447         if (err)
 448                 goto err_out4;
 449
 450         IRDA_MESSAGE("IrDA: Registered device %s (via-ircc)\n", dev->name);
 451
 452         /* Initialise the hardware..
 453         */
 454         self->io.speed = 9600;
 455         via_hw_init(self);
 456         return 0;
 457  err_out4:
 458         dma_free_coherent(NULL, self->tx_buff.truesize,
 459                           self->tx_buff.head, self->tx_buff_dma);
 460  err_out3:
 461         dma_free_coherent(NULL, self->rx_buff.truesize,
 462                           self->rx_buff.head, self->rx_buff_dma);
 463  err_out2:
 464         release_region(self->io.fir_base, self->io.fir_ext);
 465  err_out1:
 466         free_netdev(dev);
 467         dev_self[i] = NULL;
 468         return err;
 469 }
 470
 471 /*
 472  * Function via_ircc_close (self)
 473  *
 474  *    Close driver instance
 475  *
 476  */
 477 static int via_ircc_close(struct via_ircc_cb *self)
 478 {
 479         int iobase;
 480
 481         IRDA_DEBUG(3, "%s()\n", __func__);
 482
 483         IRDA_ASSERT(self != NULL, return -1;);
 484
 485         iobase = self->io.fir_base;
 486
 487         ResetChip(iobase, 5);   //hardware reset.
 488         /* Remove netdevice */
 489         unregister_netdev(self->netdev);
 490
 491         /* Release the PORT that this driver is using */
 492         IRDA_DEBUG(2, "%s(), Releasing Region %03x\n",
 493                    __func__, self->io.fir_base);
 494         release_region(self->io.fir_base, self->io.fir_ext);
 495         if (self->tx_buff.head)
 496                 dma_free_coherent(NULL, self->tx_buff.truesize,
 497                                   self->tx_buff.head, self->tx_buff_dma);
 498         if (self->rx_buff.head)
 499                 dma_free_coherent(NULL, self->rx_buff.truesize,
 500                                   self->rx_buff.head, self->rx_buff_dma);
 501         dev_self[self->index] = NULL;
 502
 503         free_netdev(self->netdev);
 504
 505         return 0;
 506 }
 507
 508 /*
 509  * Function via_hw_init(self)
 510  *
 511  *    Returns non-negative on success.
 512  *
 513  * Formerly via_ircc_setup
 514  */
 515 static void via_hw_init(struct via_ircc_cb *self)
 516 {
 517         int iobase = self->io.fir_base;
 518
 519         IRDA_DEBUG(3, "%s()\n", __func__);
 520
 521         SetMaxRxPacketSize(iobase, 0x0fff);     //set to max:4095
 522         // FIFO Init
 523         EnRXFIFOReadyInt(iobase, OFF);
 524         EnRXFIFOHalfLevelInt(iobase, OFF);
 525         EnTXFIFOHalfLevelInt(iobase, OFF);
 526         EnTXFIFOUnderrunEOMInt(iobase, ON);
 527         EnTXFIFOReadyInt(iobase, OFF);
 528         InvertTX(iobase, OFF);
 529         InvertRX(iobase, OFF);
 530
 531         if (ReadLPCReg(0x20) == 0x3c)
 532                 WriteLPCReg(0xF0, 0);   // for VT1211
 533         /* Int Init */
 534         EnRXSpecInt(iobase, ON);
 535
 536         /* The following is basically hwreset */
 537         /* If this is the case, why not just call hwreset() ? Jean II */
 538         ResetChip(iobase, 5);
 539         EnableDMA(iobase, OFF);
 540         EnableTX(iobase, OFF);
 541         EnableRX(iobase, OFF);
 542         EnRXDMA(iobase, OFF);
 543         EnTXDMA(iobase, OFF);
 544         RXStart(iobase, OFF);
 545         TXStart(iobase, OFF);
 546         InitCard(iobase);
 547         CommonInit(iobase);
 548         SIRFilter(iobase, ON);
 549         SetSIR(iobase, ON);
 550         CRC16(iobase, ON);
 551         EnTXCRC(iobase, 0);
 552         WriteReg(iobase, I_ST_CT_0, 0x00);
 553         SetBaudRate(iobase, 9600);
 554         SetPulseWidth(iobase, 12);
 555         SetSendPreambleCount(iobase, 0);
 556
 557         self->io.speed = 9600;
 558         self->st_fifo.len = 0;
 559
 560         via_ircc_change_dongle_speed(iobase, self->io.speed,
 561                                      self->io.dongle_id);
 562
 563         WriteReg(iobase, I_ST_CT_0, 0x80);
 564 }
 565
 566 /*
 567  * Function via_ircc_read_dongle_id (void)
 568  *
 569  */
 570 static int via_ircc_read_dongle_id(int iobase)
 571 {
 572         int dongle_id = 9;      /* Default to IBM */
 573
 574         IRDA_ERROR("via-ircc: dongle probing not supported, please specify dongle_id module parameter.\n");
 575         return dongle_id;
 576 }
 577
 578 /*
 579  * Function via_ircc_change_dongle_speed (iobase, speed, dongle_id)
 580  *    Change speed of the attach dongle
 581  *    only implement two type of dongle currently.
 582  */
 583 static void via_ircc_change_dongle_speed(int iobase, int speed,
 584                                          int dongle_id)
 585 {
 586         u8 mode = 0;
 587
 588         /* speed is unused, as we use IsSIROn()/IsMIROn() */
 589         speed = speed;
 590
 591         IRDA_DEBUG(1, "%s(): change_dongle_speed to %d for 0x%x, %d\n",
 592                    __func__, speed, iobase, dongle_id);
 593
 594         switch (dongle_id) {
 595
 596                 /* Note: The dongle_id's listed here are derived from
 597                  * nsc-ircc.c */
 598
 599         case 0x08:              /* HP HSDL-2300, HP HSDL-3600/HSDL-3610 */
 600                 UseOneRX(iobase, ON);   // use one RX pin   RX1,RX2
 601                 InvertTX(iobase, OFF);
 602                 InvertRX(iobase, OFF);
 603
 604                 EnRX2(iobase, ON);      //sir to rx2
 605                 EnGPIOtoRX2(iobase, OFF);
 606
 607                 if (IsSIROn(iobase)) {  //sir
 608                         // Mode select Off
 609                         SlowIRRXLowActive(iobase, ON);
 610                         udelay(1000);
 611                         SlowIRRXLowActive(iobase, OFF);
 612                 } else {
 613                         if (IsMIROn(iobase)) {  //mir
 614                                 // Mode select On
 615                                 SlowIRRXLowActive(iobase, OFF);
 616                                 udelay(20);
 617                         } else {        // fir
 618                                 if (IsFIROn(iobase)) {  //fir
 619                                         // Mode select On
 620                                         SlowIRRXLowActive(iobase, OFF);
 621                                         udelay(20);
 622                                 }
 623                         }
 624                 }
 625                 break;
 626
 627         case 0x09:              /* IBM31T1100 or Temic TFDS6000/TFDS6500 */
 628                 UseOneRX(iobase, ON);   //use ONE RX....RX1
 629                 InvertTX(iobase, OFF);
 630                 InvertRX(iobase, OFF);  // invert RX pin
 631
 632                 EnRX2(iobase, ON);
 633                 EnGPIOtoRX2(iobase, OFF);
 634                 if (IsSIROn(iobase)) {  //sir
 635                         // Mode select On
 636                         SlowIRRXLowActive(iobase, ON);
 637                         udelay(20);
 638                         // Mode select Off
 639                         SlowIRRXLowActive(iobase, OFF);
 640                 }
 641                 if (IsMIROn(iobase)) {  //mir
 642                         // Mode select On
 643                         SlowIRRXLowActive(iobase, OFF);
 644                         udelay(20);
 645                         // Mode select Off
 646                         SlowIRRXLowActive(iobase, ON);
 647                 } else {        // fir
 648                         if (IsFIROn(iobase)) {  //fir
 649                                 // Mode select On
 650                                 SlowIRRXLowActive(iobase, OFF);
 651                                 // TX On
 652                                 WriteTX(iobase, ON);
 653                                 udelay(20);
 654                                 // Mode select OFF
 655                                 SlowIRRXLowActive(iobase, ON);
 656                                 udelay(20);
 657                                 // TX Off
 658                                 WriteTX(iobase, OFF);
 659                         }
 660                 }
 661                 break;
 662
 663         case 0x0d:
 664                 UseOneRX(iobase, OFF);  // use two RX pin   RX1,RX2
 665                 InvertTX(iobase, OFF);
 666                 InvertRX(iobase, OFF);
 667                 SlowIRRXLowActive(iobase, OFF);
 668                 if (IsSIROn(iobase)) {  //sir
 669                         EnGPIOtoRX2(iobase, OFF);
 670                         WriteGIO(iobase, OFF);
 671                         EnRX2(iobase, OFF);     //sir to rx2
 672                 } else {        // fir mir
 673                         EnGPIOtoRX2(iobase, OFF);
 674                         WriteGIO(iobase, OFF);
 675                         EnRX2(iobase, OFF);     //fir to rx
 676                 }
 677                 break;
 678
 679         case 0x11:              /* Temic TFDS4500 */
 680
 681                 IRDA_DEBUG(2, "%s: Temic TFDS4500: One RX pin, TX normal, RX inverted.\n", __func__);
 682
 683                 UseOneRX(iobase, ON);   //use ONE RX....RX1
 684                 InvertTX(iobase, OFF);
 685                 InvertRX(iobase, ON);   // invert RX pin
 686
 687                 EnRX2(iobase, ON);      //sir to rx2
 688                 EnGPIOtoRX2(iobase, OFF);
 689
 690                 if( IsSIROn(iobase) ){  //sir
 691
 692                         // Mode select On
 693                         SlowIRRXLowActive(iobase, ON);
 694                         udelay(20);
 695                         // Mode select Off
 696                         SlowIRRXLowActive(iobase, OFF);
 697
 698                 } else{
 699                         IRDA_DEBUG(0, "%s: Warning: TFDS4500 not running in SIR mode !\n", __func__);
 700                 }
 701                 break;
 702
 703         case 0x0ff:             /* Vishay */
 704                 if (IsSIROn(iobase))
 705                         mode = 0;
 706                 else if (IsMIROn(iobase))
 707                         mode = 1;
 708                 else if (IsFIROn(iobase))
 709                         mode = 2;
 710                 else if (IsVFIROn(iobase))
 711                         mode = 5;       //VFIR-16
 712                 SI_SetMode(iobase, mode);
 713                 break;
 714
 715         default:
 716                 IRDA_ERROR("%s: Error: dongle_id %d unsupported !\n",
 717                            __func__, dongle_id);
 718         }
 719 }
 720
 721 /*
 722  * Function via_ircc_change_speed (self, baud)
 723  *
 724  *    Change the speed of the device
 725  *
 726  */
 727 static void via_ircc_change_speed(struct via_ircc_cb *self, __u32 speed)
 728 {
 729         struct net_device *dev = self->netdev;
 730         u16 iobase;
 731         u8 value = 0, bTmp;
 732
 733         iobase = self->io.fir_base;
 734         /* Update accounting for new speed */
 735         self->io.speed = speed;
 736         IRDA_DEBUG(1, "%s: change_speed to %d bps.\n", __func__, speed);
 737
 738         WriteReg(iobase, I_ST_CT_0, 0x0);
 739
 740         /* Controller mode sellection */
 741         switch (speed) {
 742         case 2400:
 743         case 9600:
 744         case 19200:
 745         case 38400:
 746         case 57600:
 747         case 115200:
 748                 value = (115200/speed)-1;
 749                 SetSIR(iobase, ON);
 750                 CRC16(iobase, ON);
 751                 break;
 752         case 576000:
 753                 /* FIXME: this can't be right, as it's the same as 115200,
 754                  * and 576000 is MIR, not SIR. */
 755                 value = 0;
 756                 SetSIR(iobase, ON);
 757                 CRC16(iobase, ON);
 758                 break;
 759         case 1152000:
 760                 value = 0;
 761                 SetMIR(iobase, ON);
 762                 /* FIXME: CRC ??? */
 763                 break;
 764         case 4000000:
 765                 value = 0;
 766                 SetFIR(iobase, ON);
 767                 SetPulseWidth(iobase, 0);
 768                 SetSendPreambleCount(iobase, 14);
 769                 CRC16(iobase, OFF);
 770                 EnTXCRC(iobase, ON);
 771                 break;
 772         case 16000000:
 773                 value = 0;
 774                 SetVFIR(iobase, ON);
 775                 /* FIXME: CRC ??? */
 776                 break;
 777         default:
 778                 value = 0;
 779                 break;
 780         }
 781
 782         /* Set baudrate to 0x19[2..7] */
 783         bTmp = (ReadReg(iobase, I_CF_H_1) & 0x03);
 784         bTmp |= value << 2;
 785         WriteReg(iobase, I_CF_H_1, bTmp);
 786
 787         /* Some dongles may need to be informed about speed changes. */
 788         via_ircc_change_dongle_speed(iobase, speed, self->io.dongle_id);
 789
 790         /* Set FIFO size to 64 */
 791         SetFIFO(iobase, 64);
 792
 793         /* Enable IR */
 794         WriteReg(iobase, I_ST_CT_0, 0x80);
 795
 796         // EnTXFIFOHalfLevelInt(iobase,ON);
 797
 798         /* Enable some interrupts so we can receive frames */
 799         //EnAllInt(iobase,ON);
 800
 801         if (IsSIROn(iobase)) {
 802                 SIRFilter(iobase, ON);
 803                 SIRRecvAny(iobase, ON);
 804         } else {
 805                 SIRFilter(iobase, OFF);
 806                 SIRRecvAny(iobase, OFF);
 807         }
 808
 809         if (speed > 115200) {
 810                 /* Install FIR xmit handler */
 811                 dev->netdev_ops = &via_ircc_fir_ops;
 812                 via_ircc_dma_receive(self);
 813         } else {
 814                 /* Install SIR xmit handler */
 815                 dev->netdev_ops = &via_ircc_sir_ops;
 816         }
 817         netif_wake_queue(dev);
 818 }
 819
 820 /*
 821  * Function via_ircc_hard_xmit (skb, dev)
 822  *
 823  *    Transmit the frame!
 824  *
 825  */
 826 static netdev_tx_t via_ircc_hard_xmit_sir(struct sk_buff *skb,
 827                                                 struct net_device *dev)
 828 {
 829         struct via_ircc_cb *self;
 830         unsigned long flags;
 831         u16 iobase;
 832         __u32 speed;
 833
 834         self = netdev_priv(dev);
 835         IRDA_ASSERT(self != NULL, return NETDEV_TX_OK;);
 836         iobase = self->io.fir_base;
 837
 838         netif_stop_queue(dev);
 839         /* Check if we need to change the speed */
 840         speed = irda_get_next_speed(skb);
 841         if ((speed != self->io.speed) && (speed != -1)) {
 842                 /* Check for empty frame */
 843                 if (!skb->len) {
 844                         via_ircc_change_speed(self, speed);
 845                         dev->trans_start = jiffies;
 846                         dev_kfree_skb(skb);
 847                         return NETDEV_TX_OK;
 848                 } else
 849                         self->new_speed = speed;
 850         }
 851         InitCard(iobase);
 852         CommonInit(iobase);
 853         SIRFilter(iobase, ON);
 854         SetSIR(iobase, ON);
 855         CRC16(iobase, ON);
 856         EnTXCRC(iobase, 0);
 857         WriteReg(iobase, I_ST_CT_0, 0x00);
 858
 859         spin_lock_irqsave(&self->lock, flags);
 860         self->tx_buff.data = self->tx_buff.head;
 861         self->tx_buff.len =
 862             async_wrap_skb(skb, self->tx_buff.data,
 863                            self->tx_buff.truesize);
 864
 865         dev->stats.tx_bytes += self->tx_buff.len;
 866         /* Send this frame with old speed */
 867         SetBaudRate(iobase, self->io.speed);
 868         SetPulseWidth(iobase, 12);
 869         SetSendPreambleCount(iobase, 0);
 870         WriteReg(iobase, I_ST_CT_0, 0x80);
 871
 872         EnableTX(iobase, ON);
 873         EnableRX(iobase, OFF);
 874
 875         ResetChip(iobase, 0);
 876         ResetChip(iobase, 1);
 877         ResetChip(iobase, 2);
 878         ResetChip(iobase, 3);
 879         ResetChip(iobase, 4);
 880
 881         EnAllInt(iobase, ON);
 882         EnTXDMA(iobase, ON);
 883         EnRXDMA(iobase, OFF);
 884
 885         irda_setup_dma(self->io.dma, self->tx_buff_dma, self->tx_buff.len,
 886                        DMA_TX_MODE);
 887
 888         SetSendByte(iobase, self->tx_buff.len);
 889         RXStart(iobase, OFF);
 890         TXStart(iobase, ON);
 891
 892         dev->trans_start = jiffies;
 893         spin_unlock_irqrestore(&self->lock, flags);
 894         dev_kfree_skb(skb);
 895         return NETDEV_TX_OK;
 896 }
 897
 898 static netdev_tx_t via_ircc_hard_xmit_fir(struct sk_buff *skb,
 899                                                 struct net_device *dev)
 900 {
 901         struct via_ircc_cb *self;
 902         u16 iobase;
 903         __u32 speed;
 904         unsigned long flags;
 905
 906         self = netdev_priv(dev);
 907         iobase = self->io.fir_base;
 908
 909         if (self->st_fifo.len)
 910                 return NETDEV_TX_OK;
 911         if (self->chip_id == 0x3076)
 912                 iodelay(1500);
 913         else
 914                 udelay(1500);
 915         netif_stop_queue(dev);
 916         speed = irda_get_next_speed(skb);
 917         if ((speed != self->io.speed) && (speed != -1)) {
 918                 if (!skb->len) {
 919                         via_ircc_change_speed(self, speed);
 920                         dev->trans_start = jiffies;
 921                         dev_kfree_skb(skb);
 922                         return NETDEV_TX_OK;
 923                 } else
 924                         self->new_speed = speed;
 925         }
 926         spin_lock_irqsave(&self->lock, flags);
 927         self->tx_fifo.queue[self->tx_fifo.free].start = self->tx_fifo.tail;
 928         self->tx_fifo.queue[self->tx_fifo.free].len = skb->len;
 929
 930         self->tx_fifo.tail += skb->len;
 931         dev->stats.tx_bytes += skb->len;
 932         skb_copy_from_linear_data(skb,
 933                       self->tx_fifo.queue[self->tx_fifo.free].start, skb->len);
 934         self->tx_fifo.len++;
 935         self->tx_fifo.free++;
 936 //F01   if (self->tx_fifo.len == 1) {
 937         via_ircc_dma_xmit(self, iobase);
 938 //F01   }
 939 //F01   if (self->tx_fifo.free < (MAX_TX_WINDOW -1 )) netif_wake_queue(self->netdev);
 940         dev->trans_start = jiffies;
 941         dev_kfree_skb(skb);
 942         spin_unlock_irqrestore(&self->lock, flags);
 943         return NETDEV_TX_OK;
 944
 945 }
 946
 947 static int via_ircc_dma_xmit(struct via_ircc_cb *self, u16 iobase)
 948 {
 949         EnTXDMA(iobase, OFF);
 950         self->io.direction = IO_XMIT;
 951         EnPhys(iobase, ON);
 952         EnableTX(iobase, ON);
 953         EnableRX(iobase, OFF);
 954         ResetChip(iobase, 0);
 955         ResetChip(iobase, 1);
 956         ResetChip(iobase, 2);
 957         ResetChip(iobase, 3);
 958         ResetChip(iobase, 4);
 959         EnAllInt(iobase, ON);
 960         EnTXDMA(iobase, ON);
 961         EnRXDMA(iobase, OFF);
 962         irda_setup_dma(self->io.dma,
 963                        ((u8 *)self->tx_fifo.queue[self->tx_fifo.ptr].start -
 964                         self->tx_buff.head) + self->tx_buff_dma,
 965                        self->tx_fifo.queue[self->tx_fifo.ptr].len, DMA_TX_MODE);
 966         IRDA_DEBUG(1, "%s: tx_fifo.ptr=%x,len=%x,tx_fifo.len=%x..\n",
 967                    __func__, self->tx_fifo.ptr,
 968                    self->tx_fifo.queue[self->tx_fifo.ptr].len,
 969                    self->tx_fifo.len);
 970
 971         SetSendByte(iobase, self->tx_fifo.queue[self->tx_fifo.ptr].len);
 972         RXStart(iobase, OFF);
 973         TXStart(iobase, ON);
 974         return 0;
 975
 976 }
 977
 978 /*
 979  * Function via_ircc_dma_xmit_complete (self)
 980  *
 981  *    The transfer of a frame in finished. This function will only be called
 982  *    by the interrupt handler
 983  *
 984  */
 985 static int via_ircc_dma_xmit_complete(struct via_ircc_cb *self)
 986 {
 987         int iobase;
 988         int ret = TRUE;
 989         u8 Tx_status;
 990
 991         IRDA_DEBUG(3, "%s()\n", __func__);
 992
 993         iobase = self->io.fir_base;
 994         /* Disable DMA */
 995 //      DisableDmaChannel(self->io.dma);
 996         /* Check for underrrun! */
 997         /* Clear bit, by writing 1 into it */
 998         Tx_status = GetTXStatus(iobase);
 999         if (Tx_status & 0x08) {
1000                 self->netdev->stats.tx_errors++;
1001                 self->netdev->stats.tx_fifo_errors++;
1002                 hwreset(self);
1003 // how to clear underrrun ?
1004         } else {
1005                 self->netdev->stats.tx_packets++;
1006                 ResetChip(iobase, 3);
1007                 ResetChip(iobase, 4);
1008         }
1009         /* Check if we need to change the speed */
1010         if (self->new_speed) {
1011                 via_ircc_change_speed(self, self->new_speed);
1012                 self->new_speed = 0;
1013         }
1014
1015         /* Finished with this frame, so prepare for next */
1016         if (IsFIROn(iobase)) {
1017                 if (self->tx_fifo.len) {
1018                         self->tx_fifo.len--;
1019                         self->tx_fifo.ptr++;
1020                 }
1021         }
1022         IRDA_DEBUG(1,
1023                    "%s: tx_fifo.len=%x ,tx_fifo.ptr=%x,tx_fifo.free=%x...\n",
1024                    __func__,
1025                    self->tx_fifo.len, self->tx_fifo.ptr, self->tx_fifo.free);
1026 /* F01_S
1027         // Any frames to be sent back-to-back?
1028         if (self->tx_fifo.len) {
1029                 // Not finished yet!
1030                 via_ircc_dma_xmit(self, iobase);
1031                 ret = FALSE;
1032         } else {
1033 F01_E*/
1034         // Reset Tx FIFO info
1035         self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
1036         self->tx_fifo.tail = self->tx_buff.head;
1037 //F01   }
1038
1039         // Make sure we have room for more frames
1040 //F01   if (self->tx_fifo.free < (MAX_TX_WINDOW -1 )) {
1041         // Not busy transmitting anymore
1042         // Tell the network layer, that we can accept more frames
1043         netif_wake_queue(self->netdev);
1044 //F01   }
1045         return ret;
1046 }
1047
1048 /*
1049  * Function via_ircc_dma_receive (self)
1050  *
1051  *    Set configuration for receive a frame.
1052  *
1053  */
1054 static int via_ircc_dma_receive(struct via_ircc_cb *self)
1055 {
1056         int iobase;
1057
1058         iobase = self->io.fir_base;
1059
1060         IRDA_DEBUG(3, "%s()\n", __func__);
1061
1062         self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
1063         self->tx_fifo.tail = self->tx_buff.head;
1064         self->RxDataReady = 0;
1065         self->io.direction = IO_RECV;
1066         self->rx_buff.data = self->rx_buff.head;
1067         self->st_fifo.len = self->st_fifo.pending_bytes = 0;
1068         self->st_fifo.tail = self->st_fifo.head = 0;
1069
1070         EnPhys(iobase, ON);
1071         EnableTX(iobase, OFF);
1072         EnableRX(iobase, ON);
1073
1074         ResetChip(iobase, 0);
1075         ResetChip(iobase, 1);
1076         ResetChip(iobase, 2);
1077         ResetChip(iobase, 3);
1078         ResetChip(iobase, 4);
1079
1080         EnAllInt(iobase, ON);
1081         EnTXDMA(iobase, OFF);
1082         EnRXDMA(iobase, ON);
1083         irda_setup_dma(self->io.dma2, self->rx_buff_dma,
1084                   self->rx_buff.truesize, DMA_RX_MODE);
1085         TXStart(iobase, OFF);
1086         RXStart(iobase, ON);
1087
1088         return 0;
1089 }
1090
1091 /*
1092  * Function via_ircc_dma_receive_complete (self)
1093  *
1094  *    Controller Finished with receiving frames,
1095  *    and this routine is call by ISR
1096  *
1097  */
1098 static int via_ircc_dma_receive_complete(struct via_ircc_cb *self,
1099                                          int iobase)
1100 {
1101         struct st_fifo *st_fifo;
1102         struct sk_buff *skb;
1103         int len, i;
1104         u8 status = 0;
1105
1106         iobase = self->io.fir_base;
1107         st_fifo = &self->st_fifo;
1108
1109         if (self->io.speed < 4000000) { //Speed below FIR
1110                 len = GetRecvByte(iobase, self);
1111                 skb = dev_alloc_skb(len + 1);
1112                 if (skb == NULL)
1113                         return FALSE;
1114                 // Make sure IP header gets aligned
1115                 skb_reserve(skb, 1);
1116                 skb_put(skb, len - 2);
1117                 if (self->chip_id == 0x3076) {
1118                         for (i = 0; i < len - 2; i++)
1119                                 skb->data[i] = self->rx_buff.data[i * 2];
1120                 } else {
1121                         if (self->chip_id == 0x3096) {
1122                                 for (i = 0; i < len - 2; i++)
1123                                         skb->data[i] =
1124                                             self->rx_buff.data[i];
1125                         }
1126                 }
1127                 // Move to next frame
1128                 self->rx_buff.data += len;
1129                 self->netdev->stats.rx_bytes += len;
1130                 self->netdev->stats.rx_packets++;
1131                 skb->dev = self->netdev;
1132                 skb_reset_mac_header(skb);
1133                 skb->protocol = htons(ETH_P_IRDA);
1134                 netif_rx(skb);
1135                 return TRUE;
1136         }
1137
1138         else {                  //FIR mode
1139                 len = GetRecvByte(iobase, self);
1140                 if (len == 0)
1141                         return TRUE;    //interrupt only, data maybe move by RxT
1142                 if (((len - 4) < 2) || ((len - 4) > 2048)) {
1143                         IRDA_DEBUG(1, "%s(): Trouble:len=%x,CurCount=%x,LastCount=%x..\n",
1144                                    __func__, len, RxCurCount(iobase, self),
1145                                    self->RxLastCount);
1146                         hwreset(self);
1147                         return FALSE;
1148                 }
1149                 IRDA_DEBUG(2, "%s(): fifo.len=%x,len=%x,CurCount=%x..\n",
1150                            __func__,
1151                            st_fifo->len, len - 4, RxCurCount(iobase, self));
1152
1153                 st_fifo->entries[st_fifo->tail].status = status;
1154                 st_fifo->entries[st_fifo->tail].len = len;
1155                 st_fifo->pending_bytes += len;
1156                 st_fifo->tail++;
1157                 st_fifo->len++;
1158                 if (st_fifo->tail > MAX_RX_WINDOW)
1159                         st_fifo->tail = 0;
1160                 self->RxDataReady = 0;
1161
1162                 // It maybe have MAX_RX_WINDOW package receive by
1163                 // receive_complete before Timer IRQ
1164 /* F01_S
1165           if (st_fifo->len < (MAX_RX_WINDOW+2 )) {
1166                   RXStart(iobase,ON);
1167                   SetTimer(iobase,4);
1168           }
1169           else    {
1170 F01_E */
1171                 EnableRX(iobase, OFF);
1172                 EnRXDMA(iobase, OFF);
1173                 RXStart(iobase, OFF);
1174 //F01_S
1175                 // Put this entry back in fifo
1176                 if (st_fifo->head > MAX_RX_WINDOW)
1177                         st_fifo->head = 0;
1178                 status = st_fifo->entries[st_fifo->head].status;
1179                 len = st_fifo->entries[st_fifo->head].len;
1180                 st_fifo->head++;
1181                 st_fifo->len--;
1182
1183                 skb = dev_alloc_skb(len + 1 - 4);
1184                 /*
1185                  * if frame size,data ptr,or skb ptr are wrong ,the get next
1186                  * entry.
1187                  */
1188                 if ((skb == NULL) || (skb->data == NULL) ||
1189                     (self->rx_buff.data == NULL) || (len < 6)) {
1190                         self->netdev->stats.rx_dropped++;
1191                         return TRUE;
1192                 }
1193                 skb_reserve(skb, 1);
1194                 skb_put(skb, len - 4);
1195
1196                 skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4);
1197                 IRDA_DEBUG(2, "%s(): len=%x.rx_buff=%p\n", __func__,
1198                            len - 4, self->rx_buff.data);
1199
1200                 // Move to next frame
1201                 self->rx_buff.data += len;
1202                 self->netdev->stats.rx_bytes += len;
1203                 self->netdev->stats.rx_packets++;
1204                 skb->dev = self->netdev;
1205                 skb_reset_mac_header(skb);
1206                 skb->protocol = htons(ETH_P_IRDA);
1207                 netif_rx(skb);
1208
1209 //F01_E
1210         }                       //FIR
1211         return TRUE;
1212
1213 }
1214
1215 /*
1216  * if frame is received , but no INT ,then use this routine to upload frame.
1217  */
1218 static int upload_rxdata(struct via_ircc_cb *self, int iobase)
1219 {
1220         struct sk_buff *skb;
1221         int len;
1222         struct st_fifo *st_fifo;
1223         st_fifo = &self->st_fifo;
1224
1225         len = GetRecvByte(iobase, self);
1226
1227         IRDA_DEBUG(2, "%s(): len=%x\n", __func__, len);
1228
1229         if ((len - 4) < 2) {
1230                 self->netdev->stats.rx_dropped++;
1231                 return FALSE;
1232         }
1233
1234         skb = dev_alloc_skb(len + 1);
1235         if (skb == NULL) {
1236                 self->netdev->stats.rx_dropped++;
1237                 return FALSE;
1238         }
1239         skb_reserve(skb, 1);
1240         skb_put(skb, len - 4 + 1);
1241         skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4 + 1);
1242         st_fifo->tail++;
1243         st_fifo->len++;
1244         if (st_fifo->tail > MAX_RX_WINDOW)
1245                 st_fifo->tail = 0;
1246         // Move to next frame
1247         self->rx_buff.data += len;
1248         self->netdev->stats.rx_bytes += len;
1249         self->netdev->stats.rx_packets++;
1250         skb->dev = self->netdev;
1251         skb_reset_mac_header(skb);
1252         skb->protocol = htons(ETH_P_IRDA);
1253         netif_rx(skb);
1254         if (st_fifo->len < (MAX_RX_WINDOW + 2)) {
1255                 RXStart(iobase, ON);
1256         } else {
1257                 EnableRX(iobase, OFF);
1258                 EnRXDMA(iobase, OFF);
1259                 RXStart(iobase, OFF);
1260         }
1261         return TRUE;
1262 }
1263
1264 /*
1265  * Implement back to back receive , use this routine to upload data.
1266  */
1267
1268 static int RxTimerHandler(struct via_ircc_cb *self, int iobase)
1269 {
1270         struct st_fifo *st_fifo;
1271         struct sk_buff *skb;
1272         int len;
1273         u8 status;
1274
1275         st_fifo = &self->st_fifo;
1276
1277         if (CkRxRecv(iobase, self)) {
1278                 // if still receiving ,then return ,don't upload frame
1279                 self->RetryCount = 0;
1280                 SetTimer(iobase, 20);
1281                 self->RxDataReady++;
1282                 return FALSE;
1283         } else
1284                 self->RetryCount++;
1285
1286         if ((self->RetryCount >= 1) ||
1287             ((st_fifo->pending_bytes + 2048) > self->rx_buff.truesize) ||
1288             (st_fifo->len >= (MAX_RX_WINDOW))) {
1289                 while (st_fifo->len > 0) {      //upload frame
1290                         // Put this entry back in fifo
1291                         if (st_fifo->head > MAX_RX_WINDOW)
1292                                 st_fifo->head = 0;
1293                         status = st_fifo->entries[st_fifo->head].status;
1294                         len = st_fifo->entries[st_fifo->head].len;
1295                         st_fifo->head++;
1296                         st_fifo->len--;
1297
1298                         skb = dev_alloc_skb(len + 1 - 4);
1299                         /*
1300                          * if frame size, data ptr, or skb ptr are wrong,
1301                          * then get next entry.
1302                          */
1303                         if ((skb == NULL) || (skb->data == NULL) ||
1304                             (self->rx_buff.data == NULL) || (len < 6)) {
1305                                 self->netdev->stats.rx_dropped++;
1306                                 continue;
1307                         }
1308                         skb_reserve(skb, 1);
1309                         skb_put(skb, len - 4);
1310                         skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4);
1311
1312                         IRDA_DEBUG(2, "%s(): len=%x.head=%x\n", __func__,
1313                                    len - 4, st_fifo->head);
1314
1315                         // Move to next frame
1316                         self->rx_buff.data += len;
1317                         self->netdev->stats.rx_bytes += len;
1318                         self->netdev->stats.rx_packets++;
1319                         skb->dev = self->netdev;
1320                         skb_reset_mac_header(skb);
1321                         skb->protocol = htons(ETH_P_IRDA);
1322                         netif_rx(skb);
1323                 }               //while
1324                 self->RetryCount = 0;
1325
1326                 IRDA_DEBUG(2,
1327                            "%s(): End of upload HostStatus=%x,RxStatus=%x\n",
1328                            __func__,
1329                            GetHostStatus(iobase), GetRXStatus(iobase));
1330
1331                 /*
1332                  * if frame is receive complete at this routine ,then upload
1333                  * frame.
1334                  */
1335                 if ((GetRXStatus(iobase) & 0x10) &&
1336                     (RxCurCount(iobase, self) != self->RxLastCount)) {
1337                         upload_rxdata(self, iobase);
1338                         if (irda_device_txqueue_empty(self->netdev))
1339                                 via_ircc_dma_receive(self);
1340                 }
1341         }                       // timer detect complete
1342         else
1343                 SetTimer(iobase, 4);
1344         return TRUE;
1345
1346 }
1347
1348
1349
1350 /*
1351  * Function via_ircc_interrupt (irq, dev_id)
1352  *
1353  *    An interrupt from the chip has arrived. Time to do some work
1354  *
1355  */
1356 static irqreturn_t via_ircc_interrupt(int dummy, void *dev_id)
1357 {
1358         struct net_device *dev = dev_id;
1359         struct via_ircc_cb *self = netdev_priv(dev);
1360         int iobase;
1361         u8 iHostIntType, iRxIntType, iTxIntType;
1362
1363         iobase = self->io.fir_base;
1364         spin_lock(&self->lock);
1365         iHostIntType = GetHostStatus(iobase);
1366
1367         IRDA_DEBUG(4, "%s(): iHostIntType %02x:  %s %s %s  %02x\n",
1368                    __func__, iHostIntType,
1369                    (iHostIntType & 0x40) ? "Timer" : "",
1370                    (iHostIntType & 0x20) ? "Tx" : "",
1371                    (iHostIntType & 0x10) ? "Rx" : "",
1372                    (iHostIntType & 0x0e) >> 1);
1373
1374         if ((iHostIntType & 0x40) != 0) {       //Timer Event
1375                 self->EventFlag.TimeOut++;
1376                 ClearTimerInt(iobase, 1);
1377                 if (self->io.direction == IO_XMIT) {
1378                         via_ircc_dma_xmit(self, iobase);
1379                 }
1380                 if (self->io.direction == IO_RECV) {
1381                         /*
1382                          * frame ready hold too long, must reset.
1383                          */
1384                         if (self->RxDataReady > 30) {
1385                                 hwreset(self);
1386                                 if (irda_device_txqueue_empty(self->netdev)) {
1387                                         via_ircc_dma_receive(self);
1388                                 }
1389                         } else {        // call this to upload frame.
1390                                 RxTimerHandler(self, iobase);
1391                         }
1392                 }               //RECV
1393         }                       //Timer Event
1394         if ((iHostIntType & 0x20) != 0) {       //Tx Event
1395                 iTxIntType = GetTXStatus(iobase);
1396
1397                 IRDA_DEBUG(4, "%s(): iTxIntType %02x:  %s %s %s %s\n",
1398                            __func__, iTxIntType,
1399                            (iTxIntType & 0x08) ? "FIFO underr." : "",
1400                            (iTxIntType & 0x04) ? "EOM" : "",
1401                            (iTxIntType & 0x02) ? "FIFO ready" : "",
1402                            (iTxIntType & 0x01) ? "Early EOM" : "");
1403
1404                 if (iTxIntType & 0x4) {
1405                         self->EventFlag.EOMessage++;    // read and will auto clean
1406                         if (via_ircc_dma_xmit_complete(self)) {
1407                                 if (irda_device_txqueue_empty
1408                                     (self->netdev)) {
1409                                         via_ircc_dma_receive(self);
1410                                 }
1411                         } else {
1412                                 self->EventFlag.Unknown++;
1413                         }
1414                 }               //EOP
1415         }                       //Tx Event
1416         //----------------------------------------
1417         if ((iHostIntType & 0x10) != 0) {       //Rx Event
1418                 /* Check if DMA has finished */
1419                 iRxIntType = GetRXStatus(iobase);
1420
1421                 IRDA_DEBUG(4, "%s(): iRxIntType %02x:  %s %s %s %s %s %s %s\n",
1422                            __func__, iRxIntType,
1423                            (iRxIntType & 0x80) ? "PHY err."     : "",
1424                            (iRxIntType & 0x40) ? "CRC err"      : "",
1425                            (iRxIntType & 0x20) ? "FIFO overr."  : "",
1426                            (iRxIntType & 0x10) ? "EOF"          : "",
1427                            (iRxIntType & 0x08) ? "RxData"       : "",
1428                            (iRxIntType & 0x02) ? "RxMaxLen"     : "",
1429                            (iRxIntType & 0x01) ? "SIR bad"      : "");
1430                 if (!iRxIntType)
1431                         IRDA_DEBUG(3, "%s(): RxIRQ =0\n", __func__);
1432
1433                 if (iRxIntType & 0x10) {
1434                         if (via_ircc_dma_receive_complete(self, iobase)) {
1435 //F01       if(!(IsFIROn(iobase)))  via_ircc_dma_receive(self);
1436                                 via_ircc_dma_receive(self);
1437                         }
1438                 }               // No ERR
1439                 else {          //ERR
1440                         IRDA_DEBUG(4, "%s(): RxIRQ ERR:iRxIntType=%x,HostIntType=%x,CurCount=%x,RxLastCount=%x_____\n",
1441                                    __func__, iRxIntType, iHostIntType,
1442                                    RxCurCount(iobase, self),
1443                                    self->RxLastCount);
1444
1445                         if (iRxIntType & 0x20) {        //FIFO OverRun ERR
1446                                 ResetChip(iobase, 0);
1447                                 ResetChip(iobase, 1);
1448                         } else {        //PHY,CRC ERR
1449
1450                                 if (iRxIntType != 0x08)
1451                                         hwreset(self);  //F01
1452                         }
1453                         via_ircc_dma_receive(self);
1454                 }               //ERR
1455
1456         }                       //Rx Event
1457         spin_unlock(&self->lock);
1458         return IRQ_RETVAL(iHostIntType);
1459 }
1460
1461 static void hwreset(struct via_ircc_cb *self)
1462 {
1463         int iobase;
1464         iobase = self->io.fir_base;
1465
1466         IRDA_DEBUG(3, "%s()\n", __func__);
1467
1468         ResetChip(iobase, 5);
1469         EnableDMA(iobase, OFF);
1470         EnableTX(iobase, OFF);
1471         EnableRX(iobase, OFF);
1472         EnRXDMA(iobase, OFF);
1473         EnTXDMA(iobase, OFF);
1474         RXStart(iobase, OFF);
1475         TXStart(iobase, OFF);
1476         InitCard(iobase);
1477         CommonInit(iobase);
1478         SIRFilter(iobase, ON);
1479         SetSIR(iobase, ON);
1480         CRC16(iobase, ON);
1481         EnTXCRC(iobase, 0);
1482         WriteReg(iobase, I_ST_CT_0, 0x00);
1483         SetBaudRate(iobase, 9600);
1484         SetPulseWidth(iobase, 12);
1485         SetSendPreambleCount(iobase, 0);
1486         WriteReg(iobase, I_ST_CT_0, 0x80);
1487
1488         /* Restore speed. */
1489         via_ircc_change_speed(self, self->io.speed);
1490
1491         self->st_fifo.len = 0;
1492 }
1493
1494 /*
1495  * Function via_ircc_is_receiving (self)
1496  *
1497  *    Return TRUE is we are currently receiving a frame
1498  *
1499  */
1500 static int via_ircc_is_receiving(struct via_ircc_cb *self)
1501 {
1502         int status = FALSE;
1503         int iobase;
1504
1505         IRDA_ASSERT(self != NULL, return FALSE;);
1506
1507         iobase = self->io.fir_base;
1508         if (CkRxRecv(iobase, self))
1509                 status = TRUE;
1510
1511         IRDA_DEBUG(2, "%s(): status=%x....\n", __func__, status);
1512
1513         return status;
1514 }
1515
1516
1517 /*
1518  * Function via_ircc_net_open (dev)
1519  *
1520  *    Start the device
1521  *
1522  */
1523 static int via_ircc_net_open(struct net_device *dev)
1524 {
1525         struct via_ircc_cb *self;
1526         int iobase;
1527         char hwname[32];
1528
1529         IRDA_DEBUG(3, "%s()\n", __func__);
1530
1531         IRDA_ASSERT(dev != NULL, return -1;);
1532         self = netdev_priv(dev);
1533         dev->stats.rx_packets = 0;
1534         IRDA_ASSERT(self != NULL, return 0;);
1535         iobase = self->io.fir_base;
1536         if (request_irq(self->io.irq, via_ircc_interrupt, 0, dev->name, dev)) {
1537                 IRDA_WARNING("%s, unable to allocate irq=%d\n", driver_name,
1538                              self->io.irq);
1539                 return -EAGAIN;
1540         }
1541         /*
1542          * Always allocate the DMA channel after the IRQ, and clean up on
1543          * failure.
1544          */
1545         if (request_dma(self->io.dma, dev->name)) {
1546                 IRDA_WARNING("%s, unable to allocate dma=%d\n", driver_name,
1547                              self->io.dma);
1548                 free_irq(self->io.irq, self);
1549                 return -EAGAIN;
1550         }
1551         if (self->io.dma2 != self->io.dma) {
1552                 if (request_dma(self->io.dma2, dev->name)) {
1553                         IRDA_WARNING("%s, unable to allocate dma2=%d\n",
1554                                      driver_name, self->io.dma2);
1555                         free_irq(self->io.irq, self);
1556                         free_dma(self->io.dma);
1557                         return -EAGAIN;
1558                 }
1559         }
1560
1561
1562         /* turn on interrupts */
1563         EnAllInt(iobase, ON);
1564         EnInternalLoop(iobase, OFF);
1565         EnExternalLoop(iobase, OFF);
1566
1567         /* */
1568         via_ircc_dma_receive(self);
1569
1570         /* Ready to play! */
1571         netif_start_queue(dev);
1572
1573         /*
1574          * Open new IrLAP layer instance, now that everything should be
1575          * initialized properly
1576          */
1577         sprintf(hwname, "VIA @ 0x%x", iobase);
1578         self->irlap = irlap_open(dev, &self->qos, hwname);
1579
1580         self->RxLastCount = 0;
1581
1582         return 0;
1583 }
1584
1585 /*
1586  * Function via_ircc_net_close (dev)
1587  *
1588  *    Stop the device
1589  *
1590  */
1591 static int via_ircc_net_close(struct net_device *dev)
1592 {
1593         struct via_ircc_cb *self;
1594         int iobase;
1595
1596         IRDA_DEBUG(3, "%s()\n", __func__);
1597
1598         IRDA_ASSERT(dev != NULL, return -1;);
1599         self = netdev_priv(dev);
1600         IRDA_ASSERT(self != NULL, return 0;);
1601
1602         /* Stop device */
1603         netif_stop_queue(dev);
1604         /* Stop and remove instance of IrLAP */
1605         if (self->irlap)
1606                 irlap_close(self->irlap);
1607         self->irlap = NULL;
1608         iobase = self->io.fir_base;
1609         EnTXDMA(iobase, OFF);
1610         EnRXDMA(iobase, OFF);
1611         DisableDmaChannel(self->io.dma);
1612
1613         /* Disable interrupts */
1614         EnAllInt(iobase, OFF);
1615         free_irq(self->io.irq, dev);
1616         free_dma(self->io.dma);
1617         if (self->io.dma2 != self->io.dma)
1618                 free_dma(self->io.dma2);
1619
1620         return 0;
1621 }
1622
1623 /*
1624  * Function via_ircc_net_ioctl (dev, rq, cmd)
1625  *
1626  *    Process IOCTL commands for this device
1627  *
1628  */
1629 static int via_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq,
1630                               int cmd)
1631 {
1632         struct if_irda_req *irq = (struct if_irda_req *) rq;
1633         struct via_ircc_cb *self;
1634         unsigned long flags;
1635         int ret = 0;
1636
1637         IRDA_ASSERT(dev != NULL, return -1;);
1638         self = netdev_priv(dev);
1639         IRDA_ASSERT(self != NULL, return -1;);
1640         IRDA_DEBUG(1, "%s(), %s, (cmd=0x%X)\n", __func__, dev->name,
1641                    cmd);
1642         /* Disable interrupts & save flags */
1643         spin_lock_irqsave(&self->lock, flags);
1644         switch (cmd) {
1645         case SIOCSBANDWIDTH:    /* Set bandwidth */
1646                 if (!capable(CAP_NET_ADMIN)) {
1647                         ret = -EPERM;
1648                         goto out;
1649                 }
1650                 via_ircc_change_speed(self, irq->ifr_baudrate);
1651                 break;
1652         case SIOCSMEDIABUSY:    /* Set media busy */
1653                 if (!capable(CAP_NET_ADMIN)) {
1654                         ret = -EPERM;
1655                         goto out;
1656                 }
1657                 irda_device_set_media_busy(self->netdev, TRUE);
1658                 break;
1659         case SIOCGRECEIVING:    /* Check if we are receiving right now */
1660                 irq->ifr_receiving = via_ircc_is_receiving(self);
1661                 break;
1662         default:
1663                 ret = -EOPNOTSUPP;
1664         }
1665       out:
1666         spin_unlock_irqrestore(&self->lock, flags);
1667         return ret;
1668 }
1669
1670 MODULE_AUTHOR("VIA Technologies,inc");
1671 MODULE_DESCRIPTION("VIA IrDA Device Driver");
1672 MODULE_LICENSE("GPL");
1673
1674 module_init(via_ircc_init);
1675 module_exit(via_ircc_cleanup);