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/slab.h>
  49 #include <linux/init.h>
  50 #include <linux/rtnetlink.h>
  51 #include <linux/pci.h>
  52 #include <linux/dma-mapping.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 int via_ircc_hard_xmit_sir(struct sk_buff *skb,
  91                                   struct net_device *dev);
  92 static int 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 struct pci_device_id 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 /*
 314  * Function via_ircc_open (iobase, irq)
 315  *
 316  *    Open driver instance
 317  *
 318  */
 319 static __devinit int via_ircc_open(int i, chipio_t * info, unsigned int id)
 320 {
 321         struct net_device *dev;
 322         struct via_ircc_cb *self;
 323         int err;
 324
 325         IRDA_DEBUG(3, "%s()\n", __func__);
 326
 327         if (i >= ARRAY_SIZE(dev_self))
 328                 return -ENOMEM;
 329
 330         /* Allocate new instance of the driver */
 331         dev = alloc_irdadev(sizeof(struct via_ircc_cb));
 332         if (dev == NULL)
 333                 return -ENOMEM;
 334
 335         self = netdev_priv(dev);
 336         self->netdev = dev;
 337         spin_lock_init(&self->lock);
 338
 339         /* FIXME : We should store our driver instance in the PCI layer,
 340          * using pci_set_drvdata(), not in this array.
 341          * See vlsi_ir for details... - Jean II */
 342         /* FIXME : 'i' is always 0 (see via_init_one()) :-( - Jean II */
 343         /* Need to store self somewhere */
 344         dev_self[i] = self;
 345         self->index = i;
 346         /* Initialize Resource */
 347         self->io.cfg_base = info->cfg_base;
 348         self->io.fir_base = info->fir_base;
 349         self->io.irq = info->irq;
 350         self->io.fir_ext = CHIP_IO_EXTENT;
 351         self->io.dma = info->dma;
 352         self->io.dma2 = info->dma2;
 353         self->io.fifo_size = 32;
 354         self->chip_id = id;
 355         self->st_fifo.len = 0;
 356         self->RxDataReady = 0;
 357
 358         /* Reserve the ioports that we need */
 359         if (!request_region(self->io.fir_base, self->io.fir_ext, driver_name)) {
 360                 IRDA_DEBUG(0, "%s(), can't get iobase of 0x%03x\n",
 361                            __func__, self->io.fir_base);
 362                 err = -ENODEV;
 363                 goto err_out1;
 364         }
 365
 366         /* Initialize QoS for this device */
 367         irda_init_max_qos_capabilies(&self->qos);
 368
 369         /* Check if user has supplied the dongle id or not */
 370         if (!dongle_id)
 371                 dongle_id = via_ircc_read_dongle_id(self->io.fir_base);
 372         self->io.dongle_id = dongle_id;
 373
 374         /* The only value we must override it the baudrate */
 375         /* Maximum speeds and capabilities are dongle-dependant. */
 376         switch( self->io.dongle_id ){
 377         case 0x0d:
 378                 self->qos.baud_rate.bits =
 379                     IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200 |
 380                     IR_576000 | IR_1152000 | (IR_4000000 << 8);
 381                 break;
 382         default:
 383                 self->qos.baud_rate.bits =
 384                     IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200;
 385                 break;
 386         }
 387
 388         /* Following was used for testing:
 389          *
 390          *   self->qos.baud_rate.bits = IR_9600;
 391          *
 392          * Is is no good, as it prohibits (error-prone) speed-changes.
 393          */
 394
 395         self->qos.min_turn_time.bits = qos_mtt_bits;
 396         irda_qos_bits_to_value(&self->qos);
 397
 398         /* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */
 399         self->rx_buff.truesize = 14384 + 2048;
 400         self->tx_buff.truesize = 14384 + 2048;
 401
 402         /* Allocate memory if needed */
 403         self->rx_buff.head =
 404                 dma_alloc_coherent(NULL, self->rx_buff.truesize,
 405                                    &self->rx_buff_dma, GFP_KERNEL);
 406         if (self->rx_buff.head == NULL) {
 407                 err = -ENOMEM;
 408                 goto err_out2;
 409         }
 410         memset(self->rx_buff.head, 0, self->rx_buff.truesize);
 411
 412         self->tx_buff.head =
 413                 dma_alloc_coherent(NULL, self->tx_buff.truesize,
 414                                    &self->tx_buff_dma, GFP_KERNEL);
 415         if (self->tx_buff.head == NULL) {
 416                 err = -ENOMEM;
 417                 goto err_out3;
 418         }
 419         memset(self->tx_buff.head, 0, self->tx_buff.truesize);
 420
 421         self->rx_buff.in_frame = FALSE;
 422         self->rx_buff.state = OUTSIDE_FRAME;
 423         self->tx_buff.data = self->tx_buff.head;
 424         self->rx_buff.data = self->rx_buff.head;
 425
 426         /* Reset Tx queue info */
 427         self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
 428         self->tx_fifo.tail = self->tx_buff.head;
 429
 430         /* Override the network functions we need to use */
 431         dev->hard_start_xmit = via_ircc_hard_xmit_sir;
 432         dev->open = via_ircc_net_open;
 433         dev->stop = via_ircc_net_close;
 434         dev->do_ioctl = via_ircc_net_ioctl;
 435
 436         err = register_netdev(dev);
 437         if (err)
 438                 goto err_out4;
 439
 440         IRDA_MESSAGE("IrDA: Registered device %s (via-ircc)\n", dev->name);
 441
 442         /* Initialise the hardware..
 443         */
 444         self->io.speed = 9600;
 445         via_hw_init(self);
 446         return 0;
 447  err_out4:
 448         dma_free_coherent(NULL, self->tx_buff.truesize,
 449                           self->tx_buff.head, self->tx_buff_dma);
 450  err_out3:
 451         dma_free_coherent(NULL, self->rx_buff.truesize,
 452                           self->rx_buff.head, self->rx_buff_dma);
 453  err_out2:
 454         release_region(self->io.fir_base, self->io.fir_ext);
 455  err_out1:
 456         free_netdev(dev);
 457         dev_self[i] = NULL;
 458         return err;
 459 }
 460
 461 /*
 462  * Function via_ircc_close (self)
 463  *
 464  *    Close driver instance
 465  *
 466  */
 467 static int via_ircc_close(struct via_ircc_cb *self)
 468 {
 469         int iobase;
 470
 471         IRDA_DEBUG(3, "%s()\n", __func__);
 472
 473         IRDA_ASSERT(self != NULL, return -1;);
 474
 475         iobase = self->io.fir_base;
 476
 477         ResetChip(iobase, 5);   //hardware reset.
 478         /* Remove netdevice */
 479         unregister_netdev(self->netdev);
 480
 481         /* Release the PORT that this driver is using */
 482         IRDA_DEBUG(2, "%s(), Releasing Region %03x\n",
 483                    __func__, self->io.fir_base);
 484         release_region(self->io.fir_base, self->io.fir_ext);
 485         if (self->tx_buff.head)
 486                 dma_free_coherent(NULL, self->tx_buff.truesize,
 487                                   self->tx_buff.head, self->tx_buff_dma);
 488         if (self->rx_buff.head)
 489                 dma_free_coherent(NULL, self->rx_buff.truesize,
 490                                   self->rx_buff.head, self->rx_buff_dma);
 491         dev_self[self->index] = NULL;
 492
 493         free_netdev(self->netdev);
 494
 495         return 0;
 496 }
 497
 498 /*
 499  * Function via_hw_init(self)
 500  *
 501  *    Returns non-negative on success.
 502  *
 503  * Formerly via_ircc_setup
 504  */
 505 static void via_hw_init(struct via_ircc_cb *self)
 506 {
 507         int iobase = self->io.fir_base;
 508
 509         IRDA_DEBUG(3, "%s()\n", __func__);
 510
 511         SetMaxRxPacketSize(iobase, 0x0fff);     //set to max:4095
 512         // FIFO Init
 513         EnRXFIFOReadyInt(iobase, OFF);
 514         EnRXFIFOHalfLevelInt(iobase, OFF);
 515         EnTXFIFOHalfLevelInt(iobase, OFF);
 516         EnTXFIFOUnderrunEOMInt(iobase, ON);
 517         EnTXFIFOReadyInt(iobase, OFF);
 518         InvertTX(iobase, OFF);
 519         InvertRX(iobase, OFF);
 520
 521         if (ReadLPCReg(0x20) == 0x3c)
 522                 WriteLPCReg(0xF0, 0);   // for VT1211
 523         /* Int Init */
 524         EnRXSpecInt(iobase, ON);
 525
 526         /* The following is basically hwreset */
 527         /* If this is the case, why not just call hwreset() ? Jean II */
 528         ResetChip(iobase, 5);
 529         EnableDMA(iobase, OFF);
 530         EnableTX(iobase, OFF);
 531         EnableRX(iobase, OFF);
 532         EnRXDMA(iobase, OFF);
 533         EnTXDMA(iobase, OFF);
 534         RXStart(iobase, OFF);
 535         TXStart(iobase, OFF);
 536         InitCard(iobase);
 537         CommonInit(iobase);
 538         SIRFilter(iobase, ON);
 539         SetSIR(iobase, ON);
 540         CRC16(iobase, ON);
 541         EnTXCRC(iobase, 0);
 542         WriteReg(iobase, I_ST_CT_0, 0x00);
 543         SetBaudRate(iobase, 9600);
 544         SetPulseWidth(iobase, 12);
 545         SetSendPreambleCount(iobase, 0);
 546
 547         self->io.speed = 9600;
 548         self->st_fifo.len = 0;
 549
 550         via_ircc_change_dongle_speed(iobase, self->io.speed,
 551                                      self->io.dongle_id);
 552
 553         WriteReg(iobase, I_ST_CT_0, 0x80);
 554 }
 555
 556 /*
 557  * Function via_ircc_read_dongle_id (void)
 558  *
 559  */
 560 static int via_ircc_read_dongle_id(int iobase)
 561 {
 562         int dongle_id = 9;      /* Default to IBM */
 563
 564         IRDA_ERROR("via-ircc: dongle probing not supported, please specify dongle_id module parameter.\n");
 565         return dongle_id;
 566 }
 567
 568 /*
 569  * Function via_ircc_change_dongle_speed (iobase, speed, dongle_id)
 570  *    Change speed of the attach dongle
 571  *    only implement two type of dongle currently.
 572  */
 573 static void via_ircc_change_dongle_speed(int iobase, int speed,
 574                                          int dongle_id)
 575 {
 576         u8 mode = 0;
 577
 578         /* speed is unused, as we use IsSIROn()/IsMIROn() */
 579         speed = speed;
 580
 581         IRDA_DEBUG(1, "%s(): change_dongle_speed to %d for 0x%x, %d\n",
 582                    __func__, speed, iobase, dongle_id);
 583
 584         switch (dongle_id) {
 585
 586                 /* Note: The dongle_id's listed here are derived from
 587                  * nsc-ircc.c */
 588
 589         case 0x08:              /* HP HSDL-2300, HP HSDL-3600/HSDL-3610 */
 590                 UseOneRX(iobase, ON);   // use one RX pin   RX1,RX2
 591                 InvertTX(iobase, OFF);
 592                 InvertRX(iobase, OFF);
 593
 594                 EnRX2(iobase, ON);      //sir to rx2
 595                 EnGPIOtoRX2(iobase, OFF);
 596
 597                 if (IsSIROn(iobase)) {  //sir
 598                         // Mode select Off
 599                         SlowIRRXLowActive(iobase, ON);
 600                         udelay(1000);
 601                         SlowIRRXLowActive(iobase, OFF);
 602                 } else {
 603                         if (IsMIROn(iobase)) {  //mir
 604                                 // Mode select On
 605                                 SlowIRRXLowActive(iobase, OFF);
 606                                 udelay(20);
 607                         } else {        // fir
 608                                 if (IsFIROn(iobase)) {  //fir
 609                                         // Mode select On
 610                                         SlowIRRXLowActive(iobase, OFF);
 611                                         udelay(20);
 612                                 }
 613                         }
 614                 }
 615                 break;
 616
 617         case 0x09:              /* IBM31T1100 or Temic TFDS6000/TFDS6500 */
 618                 UseOneRX(iobase, ON);   //use ONE RX....RX1
 619                 InvertTX(iobase, OFF);
 620                 InvertRX(iobase, OFF);  // invert RX pin
 621
 622                 EnRX2(iobase, ON);
 623                 EnGPIOtoRX2(iobase, OFF);
 624                 if (IsSIROn(iobase)) {  //sir
 625                         // Mode select On
 626                         SlowIRRXLowActive(iobase, ON);
 627                         udelay(20);
 628                         // Mode select Off
 629                         SlowIRRXLowActive(iobase, OFF);
 630                 }
 631                 if (IsMIROn(iobase)) {  //mir
 632                         // Mode select On
 633                         SlowIRRXLowActive(iobase, OFF);
 634                         udelay(20);
 635                         // Mode select Off
 636                         SlowIRRXLowActive(iobase, ON);
 637                 } else {        // fir
 638                         if (IsFIROn(iobase)) {  //fir
 639                                 // Mode select On
 640                                 SlowIRRXLowActive(iobase, OFF);
 641                                 // TX On
 642                                 WriteTX(iobase, ON);
 643                                 udelay(20);
 644                                 // Mode select OFF
 645                                 SlowIRRXLowActive(iobase, ON);
 646                                 udelay(20);
 647                                 // TX Off
 648                                 WriteTX(iobase, OFF);
 649                         }
 650                 }
 651                 break;
 652
 653         case 0x0d:
 654                 UseOneRX(iobase, OFF);  // use two RX pin   RX1,RX2
 655                 InvertTX(iobase, OFF);
 656                 InvertRX(iobase, OFF);
 657                 SlowIRRXLowActive(iobase, OFF);
 658                 if (IsSIROn(iobase)) {  //sir
 659                         EnGPIOtoRX2(iobase, OFF);
 660                         WriteGIO(iobase, OFF);
 661                         EnRX2(iobase, OFF);     //sir to rx2
 662                 } else {        // fir mir
 663                         EnGPIOtoRX2(iobase, OFF);
 664                         WriteGIO(iobase, OFF);
 665                         EnRX2(iobase, OFF);     //fir to rx
 666                 }
 667                 break;
 668
 669         case 0x11:              /* Temic TFDS4500 */
 670
 671                 IRDA_DEBUG(2, "%s: Temic TFDS4500: One RX pin, TX normal, RX inverted.\n", __func__);
 672
 673                 UseOneRX(iobase, ON);   //use ONE RX....RX1
 674                 InvertTX(iobase, OFF);
 675                 InvertRX(iobase, ON);   // invert RX pin
 676
 677                 EnRX2(iobase, ON);      //sir to rx2
 678                 EnGPIOtoRX2(iobase, OFF);
 679
 680                 if( IsSIROn(iobase) ){  //sir
 681
 682                         // Mode select On
 683                         SlowIRRXLowActive(iobase, ON);
 684                         udelay(20);
 685                         // Mode select Off
 686                         SlowIRRXLowActive(iobase, OFF);
 687
 688                 } else{
 689                         IRDA_DEBUG(0, "%s: Warning: TFDS4500 not running in SIR mode !\n", __func__);
 690                 }
 691                 break;
 692
 693         case 0x0ff:             /* Vishay */
 694                 if (IsSIROn(iobase))
 695                         mode = 0;
 696                 else if (IsMIROn(iobase))
 697                         mode = 1;
 698                 else if (IsFIROn(iobase))
 699                         mode = 2;
 700                 else if (IsVFIROn(iobase))
 701                         mode = 5;       //VFIR-16
 702                 SI_SetMode(iobase, mode);
 703                 break;
 704
 705         default:
 706                 IRDA_ERROR("%s: Error: dongle_id %d unsupported !\n",
 707                            __func__, dongle_id);
 708         }
 709 }
 710
 711 /*
 712  * Function via_ircc_change_speed (self, baud)
 713  *
 714  *    Change the speed of the device
 715  *
 716  */
 717 static void via_ircc_change_speed(struct via_ircc_cb *self, __u32 speed)
 718 {
 719         struct net_device *dev = self->netdev;
 720         u16 iobase;
 721         u8 value = 0, bTmp;
 722
 723         iobase = self->io.fir_base;
 724         /* Update accounting for new speed */
 725         self->io.speed = speed;
 726         IRDA_DEBUG(1, "%s: change_speed to %d bps.\n", __func__, speed);
 727
 728         WriteReg(iobase, I_ST_CT_0, 0x0);
 729
 730         /* Controller mode sellection */
 731         switch (speed) {
 732         case 2400:
 733         case 9600:
 734         case 19200:
 735         case 38400:
 736         case 57600:
 737         case 115200:
 738                 value = (115200/speed)-1;
 739                 SetSIR(iobase, ON);
 740                 CRC16(iobase, ON);
 741                 break;
 742         case 576000:
 743                 /* FIXME: this can't be right, as it's the same as 115200,
 744                  * and 576000 is MIR, not SIR. */
 745                 value = 0;
 746                 SetSIR(iobase, ON);
 747                 CRC16(iobase, ON);
 748                 break;
 749         case 1152000:
 750                 value = 0;
 751                 SetMIR(iobase, ON);
 752                 /* FIXME: CRC ??? */
 753                 break;
 754         case 4000000:
 755                 value = 0;
 756                 SetFIR(iobase, ON);
 757                 SetPulseWidth(iobase, 0);
 758                 SetSendPreambleCount(iobase, 14);
 759                 CRC16(iobase, OFF);
 760                 EnTXCRC(iobase, ON);
 761                 break;
 762         case 16000000:
 763                 value = 0;
 764                 SetVFIR(iobase, ON);
 765                 /* FIXME: CRC ??? */
 766                 break;
 767         default:
 768                 value = 0;
 769                 break;
 770         }
 771
 772         /* Set baudrate to 0x19[2..7] */
 773         bTmp = (ReadReg(iobase, I_CF_H_1) & 0x03);
 774         bTmp |= value << 2;
 775         WriteReg(iobase, I_CF_H_1, bTmp);
 776
 777         /* Some dongles may need to be informed about speed changes. */
 778         via_ircc_change_dongle_speed(iobase, speed, self->io.dongle_id);
 779
 780         /* Set FIFO size to 64 */
 781         SetFIFO(iobase, 64);
 782
 783         /* Enable IR */
 784         WriteReg(iobase, I_ST_CT_0, 0x80);
 785
 786         // EnTXFIFOHalfLevelInt(iobase,ON);
 787
 788         /* Enable some interrupts so we can receive frames */
 789         //EnAllInt(iobase,ON);
 790
 791         if (IsSIROn(iobase)) {
 792                 SIRFilter(iobase, ON);
 793                 SIRRecvAny(iobase, ON);
 794         } else {
 795                 SIRFilter(iobase, OFF);
 796                 SIRRecvAny(iobase, OFF);
 797         }
 798
 799         if (speed > 115200) {
 800                 /* Install FIR xmit handler */
 801                 dev->hard_start_xmit = via_ircc_hard_xmit_fir;
 802                 via_ircc_dma_receive(self);
 803         } else {
 804                 /* Install SIR xmit handler */
 805                 dev->hard_start_xmit = via_ircc_hard_xmit_sir;
 806         }
 807         netif_wake_queue(dev);
 808 }
 809
 810 /*
 811  * Function via_ircc_hard_xmit (skb, dev)
 812  *
 813  *    Transmit the frame!
 814  *
 815  */
 816 static int via_ircc_hard_xmit_sir(struct sk_buff *skb,
 817                                   struct net_device *dev)
 818 {
 819         struct via_ircc_cb *self;
 820         unsigned long flags;
 821         u16 iobase;
 822         __u32 speed;
 823
 824         self = netdev_priv(dev);
 825         IRDA_ASSERT(self != NULL, return 0;);
 826         iobase = self->io.fir_base;
 827
 828         netif_stop_queue(dev);
 829         /* Check if we need to change the speed */
 830         speed = irda_get_next_speed(skb);
 831         if ((speed != self->io.speed) && (speed != -1)) {
 832                 /* Check for empty frame */
 833                 if (!skb->len) {
 834                         via_ircc_change_speed(self, speed);
 835                         dev->trans_start = jiffies;
 836                         dev_kfree_skb(skb);
 837                         return 0;
 838                 } else
 839                         self->new_speed = speed;
 840         }
 841         InitCard(iobase);
 842         CommonInit(iobase);
 843         SIRFilter(iobase, ON);
 844         SetSIR(iobase, ON);
 845         CRC16(iobase, ON);
 846         EnTXCRC(iobase, 0);
 847         WriteReg(iobase, I_ST_CT_0, 0x00);
 848
 849         spin_lock_irqsave(&self->lock, flags);
 850         self->tx_buff.data = self->tx_buff.head;
 851         self->tx_buff.len =
 852             async_wrap_skb(skb, self->tx_buff.data,
 853                            self->tx_buff.truesize);
 854
 855         dev->stats.tx_bytes += self->tx_buff.len;
 856         /* Send this frame with old speed */
 857         SetBaudRate(iobase, self->io.speed);
 858         SetPulseWidth(iobase, 12);
 859         SetSendPreambleCount(iobase, 0);
 860         WriteReg(iobase, I_ST_CT_0, 0x80);
 861
 862         EnableTX(iobase, ON);
 863         EnableRX(iobase, OFF);
 864
 865         ResetChip(iobase, 0);
 866         ResetChip(iobase, 1);
 867         ResetChip(iobase, 2);
 868         ResetChip(iobase, 3);
 869         ResetChip(iobase, 4);
 870
 871         EnAllInt(iobase, ON);
 872         EnTXDMA(iobase, ON);
 873         EnRXDMA(iobase, OFF);
 874
 875         irda_setup_dma(self->io.dma, self->tx_buff_dma, self->tx_buff.len,
 876                        DMA_TX_MODE);
 877
 878         SetSendByte(iobase, self->tx_buff.len);
 879         RXStart(iobase, OFF);
 880         TXStart(iobase, ON);
 881
 882         dev->trans_start = jiffies;
 883         spin_unlock_irqrestore(&self->lock, flags);
 884         dev_kfree_skb(skb);
 885         return 0;
 886 }
 887
 888 static int via_ircc_hard_xmit_fir(struct sk_buff *skb,
 889                                   struct net_device *dev)
 890 {
 891         struct via_ircc_cb *self;
 892         u16 iobase;
 893         __u32 speed;
 894         unsigned long flags;
 895
 896         self = netdev_priv(dev);
 897         iobase = self->io.fir_base;
 898
 899         if (self->st_fifo.len)
 900                 return 0;
 901         if (self->chip_id == 0x3076)
 902                 iodelay(1500);
 903         else
 904                 udelay(1500);
 905         netif_stop_queue(dev);
 906         speed = irda_get_next_speed(skb);
 907         if ((speed != self->io.speed) && (speed != -1)) {
 908                 if (!skb->len) {
 909                         via_ircc_change_speed(self, speed);
 910                         dev->trans_start = jiffies;
 911                         dev_kfree_skb(skb);
 912                         return 0;
 913                 } else
 914                         self->new_speed = speed;
 915         }
 916         spin_lock_irqsave(&self->lock, flags);
 917         self->tx_fifo.queue[self->tx_fifo.free].start = self->tx_fifo.tail;
 918         self->tx_fifo.queue[self->tx_fifo.free].len = skb->len;
 919
 920         self->tx_fifo.tail += skb->len;
 921         dev->stats.tx_bytes += skb->len;
 922         skb_copy_from_linear_data(skb,
 923                       self->tx_fifo.queue[self->tx_fifo.free].start, skb->len);
 924         self->tx_fifo.len++;
 925         self->tx_fifo.free++;
 926 //F01   if (self->tx_fifo.len == 1) {
 927         via_ircc_dma_xmit(self, iobase);
 928 //F01   }
 929 //F01   if (self->tx_fifo.free < (MAX_TX_WINDOW -1 )) netif_wake_queue(self->netdev);
 930         dev->trans_start = jiffies;
 931         dev_kfree_skb(skb);
 932         spin_unlock_irqrestore(&self->lock, flags);
 933         return 0;
 934
 935 }
 936
 937 static int via_ircc_dma_xmit(struct via_ircc_cb *self, u16 iobase)
 938 {
 939         EnTXDMA(iobase, OFF);
 940         self->io.direction = IO_XMIT;
 941         EnPhys(iobase, ON);
 942         EnableTX(iobase, ON);
 943         EnableRX(iobase, OFF);
 944         ResetChip(iobase, 0);
 945         ResetChip(iobase, 1);
 946         ResetChip(iobase, 2);
 947         ResetChip(iobase, 3);
 948         ResetChip(iobase, 4);
 949         EnAllInt(iobase, ON);
 950         EnTXDMA(iobase, ON);
 951         EnRXDMA(iobase, OFF);
 952         irda_setup_dma(self->io.dma,
 953                        ((u8 *)self->tx_fifo.queue[self->tx_fifo.ptr].start -
 954                         self->tx_buff.head) + self->tx_buff_dma,
 955                        self->tx_fifo.queue[self->tx_fifo.ptr].len, DMA_TX_MODE);
 956         IRDA_DEBUG(1, "%s: tx_fifo.ptr=%x,len=%x,tx_fifo.len=%x..\n",
 957                    __func__, self->tx_fifo.ptr,
 958                    self->tx_fifo.queue[self->tx_fifo.ptr].len,
 959                    self->tx_fifo.len);
 960
 961         SetSendByte(iobase, self->tx_fifo.queue[self->tx_fifo.ptr].len);
 962         RXStart(iobase, OFF);
 963         TXStart(iobase, ON);
 964         return 0;
 965
 966 }
 967
 968 /*
 969  * Function via_ircc_dma_xmit_complete (self)
 970  *
 971  *    The transfer of a frame in finished. This function will only be called
 972  *    by the interrupt handler
 973  *
 974  */
 975 static int via_ircc_dma_xmit_complete(struct via_ircc_cb *self)
 976 {
 977         int iobase;
 978         int ret = TRUE;
 979         u8 Tx_status;
 980
 981         IRDA_DEBUG(3, "%s()\n", __func__);
 982
 983         iobase = self->io.fir_base;
 984         /* Disable DMA */
 985 //      DisableDmaChannel(self->io.dma);
 986         /* Check for underrrun! */
 987         /* Clear bit, by writing 1 into it */
 988         Tx_status = GetTXStatus(iobase);
 989         if (Tx_status & 0x08) {
 990                 self->netdev->stats.tx_errors++;
 991                 self->netdev->stats.tx_fifo_errors++;
 992                 hwreset(self);
 993 // how to clear underrrun ?
 994         } else {
 995                 self->netdev->stats.tx_packets++;
 996                 ResetChip(iobase, 3);
 997                 ResetChip(iobase, 4);
 998         }
 999         /* Check if we need to change the speed */
1000         if (self->new_speed) {
1001                 via_ircc_change_speed(self, self->new_speed);
1002                 self->new_speed = 0;
1003         }
1004
1005         /* Finished with this frame, so prepare for next */
1006         if (IsFIROn(iobase)) {
1007                 if (self->tx_fifo.len) {
1008                         self->tx_fifo.len--;
1009                         self->tx_fifo.ptr++;
1010                 }
1011         }
1012         IRDA_DEBUG(1,
1013                    "%s: tx_fifo.len=%x ,tx_fifo.ptr=%x,tx_fifo.free=%x...\n",
1014                    __func__,
1015                    self->tx_fifo.len, self->tx_fifo.ptr, self->tx_fifo.free);
1016 /* F01_S
1017         // Any frames to be sent back-to-back?
1018         if (self->tx_fifo.len) {
1019                 // Not finished yet!
1020                 via_ircc_dma_xmit(self, iobase);
1021                 ret = FALSE;
1022         } else {
1023 F01_E*/
1024         // Reset Tx FIFO info
1025         self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
1026         self->tx_fifo.tail = self->tx_buff.head;
1027 //F01   }
1028
1029         // Make sure we have room for more frames
1030 //F01   if (self->tx_fifo.free < (MAX_TX_WINDOW -1 )) {
1031         // Not busy transmitting anymore
1032         // Tell the network layer, that we can accept more frames
1033         netif_wake_queue(self->netdev);
1034 //F01   }
1035         return ret;
1036 }
1037
1038 /*
1039  * Function via_ircc_dma_receive (self)
1040  *
1041  *    Set configuration for receive a frame.
1042  *
1043  */
1044 static int via_ircc_dma_receive(struct via_ircc_cb *self)
1045 {
1046         int iobase;
1047
1048         iobase = self->io.fir_base;
1049
1050         IRDA_DEBUG(3, "%s()\n", __func__);
1051
1052         self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
1053         self->tx_fifo.tail = self->tx_buff.head;
1054         self->RxDataReady = 0;
1055         self->io.direction = IO_RECV;
1056         self->rx_buff.data = self->rx_buff.head;
1057         self->st_fifo.len = self->st_fifo.pending_bytes = 0;
1058         self->st_fifo.tail = self->st_fifo.head = 0;
1059
1060         EnPhys(iobase, ON);
1061         EnableTX(iobase, OFF);
1062         EnableRX(iobase, ON);
1063
1064         ResetChip(iobase, 0);
1065         ResetChip(iobase, 1);
1066         ResetChip(iobase, 2);
1067         ResetChip(iobase, 3);
1068         ResetChip(iobase, 4);
1069
1070         EnAllInt(iobase, ON);
1071         EnTXDMA(iobase, OFF);
1072         EnRXDMA(iobase, ON);
1073         irda_setup_dma(self->io.dma2, self->rx_buff_dma,
1074                   self->rx_buff.truesize, DMA_RX_MODE);
1075         TXStart(iobase, OFF);
1076         RXStart(iobase, ON);
1077
1078         return 0;
1079 }
1080
1081 /*
1082  * Function via_ircc_dma_receive_complete (self)
1083  *
1084  *    Controller Finished with receiving frames,
1085  *    and this routine is call by ISR
1086  *
1087  */
1088 static int via_ircc_dma_receive_complete(struct via_ircc_cb *self,
1089                                          int iobase)
1090 {
1091         struct st_fifo *st_fifo;
1092         struct sk_buff *skb;
1093         int len, i;
1094         u8 status = 0;
1095
1096         iobase = self->io.fir_base;
1097         st_fifo = &self->st_fifo;
1098
1099         if (self->io.speed < 4000000) { //Speed below FIR
1100                 len = GetRecvByte(iobase, self);
1101                 skb = dev_alloc_skb(len + 1);
1102                 if (skb == NULL)
1103                         return FALSE;
1104                 // Make sure IP header gets aligned
1105                 skb_reserve(skb, 1);
1106                 skb_put(skb, len - 2);
1107                 if (self->chip_id == 0x3076) {
1108                         for (i = 0; i < len - 2; i++)
1109                                 skb->data[i] = self->rx_buff.data[i * 2];
1110                 } else {
1111                         if (self->chip_id == 0x3096) {
1112                                 for (i = 0; i < len - 2; i++)
1113                                         skb->data[i] =
1114                                             self->rx_buff.data[i];
1115                         }
1116                 }
1117                 // Move to next frame
1118                 self->rx_buff.data += len;
1119                 self->netdev->stats.rx_bytes += len;
1120                 self->netdev->stats.rx_packets++;
1121                 skb->dev = self->netdev;
1122                 skb_reset_mac_header(skb);
1123                 skb->protocol = htons(ETH_P_IRDA);
1124                 netif_rx(skb);
1125                 return TRUE;
1126         }
1127
1128         else {                  //FIR mode
1129                 len = GetRecvByte(iobase, self);
1130                 if (len == 0)
1131                         return TRUE;    //interrupt only, data maybe move by RxT
1132                 if (((len - 4) < 2) || ((len - 4) > 2048)) {
1133                         IRDA_DEBUG(1, "%s(): Trouble:len=%x,CurCount=%x,LastCount=%x..\n",
1134                                    __func__, len, RxCurCount(iobase, self),
1135                                    self->RxLastCount);
1136                         hwreset(self);
1137                         return FALSE;
1138                 }
1139                 IRDA_DEBUG(2, "%s(): fifo.len=%x,len=%x,CurCount=%x..\n",
1140                            __func__,
1141                            st_fifo->len, len - 4, RxCurCount(iobase, self));
1142
1143                 st_fifo->entries[st_fifo->tail].status = status;
1144                 st_fifo->entries[st_fifo->tail].len = len;
1145                 st_fifo->pending_bytes += len;
1146                 st_fifo->tail++;
1147                 st_fifo->len++;
1148                 if (st_fifo->tail > MAX_RX_WINDOW)
1149                         st_fifo->tail = 0;
1150                 self->RxDataReady = 0;
1151
1152                 // It maybe have MAX_RX_WINDOW package receive by
1153                 // receive_complete before Timer IRQ
1154 /* F01_S
1155           if (st_fifo->len < (MAX_RX_WINDOW+2 )) {
1156                   RXStart(iobase,ON);
1157                   SetTimer(iobase,4);
1158           }
1159           else    {
1160 F01_E */
1161                 EnableRX(iobase, OFF);
1162                 EnRXDMA(iobase, OFF);
1163                 RXStart(iobase, OFF);
1164 //F01_S
1165                 // Put this entry back in fifo
1166                 if (st_fifo->head > MAX_RX_WINDOW)
1167                         st_fifo->head = 0;
1168                 status = st_fifo->entries[st_fifo->head].status;
1169                 len = st_fifo->entries[st_fifo->head].len;
1170                 st_fifo->head++;
1171                 st_fifo->len--;
1172
1173                 skb = dev_alloc_skb(len + 1 - 4);
1174                 /*
1175                  * if frame size,data ptr,or skb ptr are wrong ,the get next
1176                  * entry.
1177                  */
1178                 if ((skb == NULL) || (skb->data == NULL)
1179                     || (self->rx_buff.data == NULL) || (len < 6)) {
1180                         self->netdev->stats.rx_dropped++;
1181                         return TRUE;
1182                 }
1183                 skb_reserve(skb, 1);
1184                 skb_put(skb, len - 4);
1185
1186                 skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4);
1187                 IRDA_DEBUG(2, "%s(): len=%x.rx_buff=%p\n", __func__,
1188                            len - 4, self->rx_buff.data);
1189
1190                 // Move to next frame
1191                 self->rx_buff.data += len;
1192                 self->netdev->stats.rx_bytes += len;
1193                 self->netdev->stats.rx_packets++;
1194                 skb->dev = self->netdev;
1195                 skb_reset_mac_header(skb);
1196                 skb->protocol = htons(ETH_P_IRDA);
1197                 netif_rx(skb);
1198
1199 //F01_E
1200         }                       //FIR
1201         return TRUE;
1202
1203 }
1204
1205 /*
1206  * if frame is received , but no INT ,then use this routine to upload frame.
1207  */
1208 static int upload_rxdata(struct via_ircc_cb *self, int iobase)
1209 {
1210         struct sk_buff *skb;
1211         int len;
1212         struct st_fifo *st_fifo;
1213         st_fifo = &self->st_fifo;
1214
1215         len = GetRecvByte(iobase, self);
1216
1217         IRDA_DEBUG(2, "%s(): len=%x\n", __func__, len);
1218
1219         if ((len - 4) < 2) {
1220                 self->netdev->stats.rx_dropped++;
1221                 return FALSE;
1222         }
1223
1224         skb = dev_alloc_skb(len + 1);
1225         if (skb == NULL) {
1226                 self->netdev->stats.rx_dropped++;
1227                 return FALSE;
1228         }
1229         skb_reserve(skb, 1);
1230         skb_put(skb, len - 4 + 1);
1231         skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4 + 1);
1232         st_fifo->tail++;
1233         st_fifo->len++;
1234         if (st_fifo->tail > MAX_RX_WINDOW)
1235                 st_fifo->tail = 0;
1236         // Move to next frame
1237         self->rx_buff.data += len;
1238         self->netdev->stats.rx_bytes += len;
1239         self->netdev->stats.rx_packets++;
1240         skb->dev = self->netdev;
1241         skb_reset_mac_header(skb);
1242         skb->protocol = htons(ETH_P_IRDA);
1243         netif_rx(skb);
1244         if (st_fifo->len < (MAX_RX_WINDOW + 2)) {
1245                 RXStart(iobase, ON);
1246         } else {
1247                 EnableRX(iobase, OFF);
1248                 EnRXDMA(iobase, OFF);
1249                 RXStart(iobase, OFF);
1250         }
1251         return TRUE;
1252 }
1253
1254 /*
1255  * Implement back to back receive , use this routine to upload data.
1256  */
1257
1258 static int RxTimerHandler(struct via_ircc_cb *self, int iobase)
1259 {
1260         struct st_fifo *st_fifo;
1261         struct sk_buff *skb;
1262         int len;
1263         u8 status;
1264
1265         st_fifo = &self->st_fifo;
1266
1267         if (CkRxRecv(iobase, self)) {
1268                 // if still receiving ,then return ,don't upload frame
1269                 self->RetryCount = 0;
1270                 SetTimer(iobase, 20);
1271                 self->RxDataReady++;
1272                 return FALSE;
1273         } else
1274                 self->RetryCount++;
1275
1276         if ((self->RetryCount >= 1) ||
1277             ((st_fifo->pending_bytes + 2048) > self->rx_buff.truesize)
1278             || (st_fifo->len >= (MAX_RX_WINDOW))) {
1279                 while (st_fifo->len > 0) {      //upload frame
1280                         // Put this entry back in fifo
1281                         if (st_fifo->head > MAX_RX_WINDOW)
1282                                 st_fifo->head = 0;
1283                         status = st_fifo->entries[st_fifo->head].status;
1284                         len = st_fifo->entries[st_fifo->head].len;
1285                         st_fifo->head++;
1286                         st_fifo->len--;
1287
1288                         skb = dev_alloc_skb(len + 1 - 4);
1289                         /*
1290                          * if frame size, data ptr, or skb ptr are wrong,
1291                          * then get next entry.
1292                          */
1293                         if ((skb == NULL) || (skb->data == NULL)
1294                             || (self->rx_buff.data == NULL) || (len < 6)) {
1295                                 self->netdev->stats.rx_dropped++;
1296                                 continue;
1297                         }
1298                         skb_reserve(skb, 1);
1299                         skb_put(skb, len - 4);
1300                         skb_copy_to_linear_data(skb, self->rx_buff.data, len - 4);
1301
1302                         IRDA_DEBUG(2, "%s(): len=%x.head=%x\n", __func__,
1303                                    len - 4, st_fifo->head);
1304
1305                         // Move to next frame
1306                         self->rx_buff.data += len;
1307                         self->netdev->stats.rx_bytes += len;
1308                         self->netdev->stats.rx_packets++;
1309                         skb->dev = self->netdev;
1310                         skb_reset_mac_header(skb);
1311                         skb->protocol = htons(ETH_P_IRDA);
1312                         netif_rx(skb);
1313                 }               //while
1314                 self->RetryCount = 0;
1315
1316                 IRDA_DEBUG(2,
1317                            "%s(): End of upload HostStatus=%x,RxStatus=%x\n",
1318                            __func__,
1319                            GetHostStatus(iobase), GetRXStatus(iobase));
1320
1321                 /*
1322                  * if frame is receive complete at this routine ,then upload
1323                  * frame.
1324                  */
1325                 if ((GetRXStatus(iobase) & 0x10)
1326                     && (RxCurCount(iobase, self) != self->RxLastCount)) {
1327                         upload_rxdata(self, iobase);
1328                         if (irda_device_txqueue_empty(self->netdev))
1329                                 via_ircc_dma_receive(self);
1330                 }
1331         }                       // timer detect complete
1332         else
1333                 SetTimer(iobase, 4);
1334         return TRUE;
1335
1336 }
1337
1338
1339
1340 /*
1341  * Function via_ircc_interrupt (irq, dev_id)
1342  *
1343  *    An interrupt from the chip has arrived. Time to do some work
1344  *
1345  */
1346 static irqreturn_t via_ircc_interrupt(int dummy, void *dev_id)
1347 {
1348         struct net_device *dev = dev_id;
1349         struct via_ircc_cb *self = netdev_priv(dev);
1350         int iobase;
1351         u8 iHostIntType, iRxIntType, iTxIntType;
1352
1353         iobase = self->io.fir_base;
1354         spin_lock(&self->lock);
1355         iHostIntType = GetHostStatus(iobase);
1356
1357         IRDA_DEBUG(4, "%s(): iHostIntType %02x:  %s %s %s  %02x\n",
1358                    __func__, iHostIntType,
1359                    (iHostIntType & 0x40) ? "Timer" : "",
1360                    (iHostIntType & 0x20) ? "Tx" : "",
1361                    (iHostIntType & 0x10) ? "Rx" : "",
1362                    (iHostIntType & 0x0e) >> 1);
1363
1364         if ((iHostIntType & 0x40) != 0) {       //Timer Event
1365                 self->EventFlag.TimeOut++;
1366                 ClearTimerInt(iobase, 1);
1367                 if (self->io.direction == IO_XMIT) {
1368                         via_ircc_dma_xmit(self, iobase);
1369                 }
1370                 if (self->io.direction == IO_RECV) {
1371                         /*
1372                          * frame ready hold too long, must reset.
1373                          */
1374                         if (self->RxDataReady > 30) {
1375                                 hwreset(self);
1376                                 if (irda_device_txqueue_empty(self->netdev)) {
1377                                         via_ircc_dma_receive(self);
1378                                 }
1379                         } else {        // call this to upload frame.
1380                                 RxTimerHandler(self, iobase);
1381                         }
1382                 }               //RECV
1383         }                       //Timer Event
1384         if ((iHostIntType & 0x20) != 0) {       //Tx Event
1385                 iTxIntType = GetTXStatus(iobase);
1386
1387                 IRDA_DEBUG(4, "%s(): iTxIntType %02x:  %s %s %s %s\n",
1388                            __func__, iTxIntType,
1389                            (iTxIntType & 0x08) ? "FIFO underr." : "",
1390                            (iTxIntType & 0x04) ? "EOM" : "",
1391                            (iTxIntType & 0x02) ? "FIFO ready" : "",
1392                            (iTxIntType & 0x01) ? "Early EOM" : "");
1393
1394                 if (iTxIntType & 0x4) {
1395                         self->EventFlag.EOMessage++;    // read and will auto clean
1396                         if (via_ircc_dma_xmit_complete(self)) {
1397                                 if (irda_device_txqueue_empty
1398                                     (self->netdev)) {
1399                                         via_ircc_dma_receive(self);
1400                                 }
1401                         } else {
1402                                 self->EventFlag.Unknown++;
1403                         }
1404                 }               //EOP
1405         }                       //Tx Event
1406         //----------------------------------------
1407         if ((iHostIntType & 0x10) != 0) {       //Rx Event
1408                 /* Check if DMA has finished */
1409                 iRxIntType = GetRXStatus(iobase);
1410
1411                 IRDA_DEBUG(4, "%s(): iRxIntType %02x:  %s %s %s %s %s %s %s\n",
1412                            __func__, iRxIntType,
1413                            (iRxIntType & 0x80) ? "PHY err."     : "",
1414                            (iRxIntType & 0x40) ? "CRC err"      : "",
1415                            (iRxIntType & 0x20) ? "FIFO overr."  : "",
1416                            (iRxIntType & 0x10) ? "EOF"          : "",
1417                            (iRxIntType & 0x08) ? "RxData"       : "",
1418                            (iRxIntType & 0x02) ? "RxMaxLen"     : "",
1419                            (iRxIntType & 0x01) ? "SIR bad"      : "");
1420                 if (!iRxIntType)
1421                         IRDA_DEBUG(3, "%s(): RxIRQ =0\n", __func__);
1422
1423                 if (iRxIntType & 0x10) {
1424                         if (via_ircc_dma_receive_complete(self, iobase)) {
1425 //F01       if(!(IsFIROn(iobase)))  via_ircc_dma_receive(self);
1426                                 via_ircc_dma_receive(self);
1427                         }
1428                 }               // No ERR
1429                 else {          //ERR
1430                         IRDA_DEBUG(4, "%s(): RxIRQ ERR:iRxIntType=%x,HostIntType=%x,CurCount=%x,RxLastCount=%x_____\n",
1431                                    __func__, iRxIntType, iHostIntType,
1432                                    RxCurCount(iobase, self),
1433                                    self->RxLastCount);
1434
1435                         if (iRxIntType & 0x20) {        //FIFO OverRun ERR
1436                                 ResetChip(iobase, 0);
1437                                 ResetChip(iobase, 1);
1438                         } else {        //PHY,CRC ERR
1439
1440                                 if (iRxIntType != 0x08)
1441                                         hwreset(self);  //F01
1442                         }
1443                         via_ircc_dma_receive(self);
1444                 }               //ERR
1445
1446         }                       //Rx Event
1447         spin_unlock(&self->lock);
1448         return IRQ_RETVAL(iHostIntType);
1449 }
1450
1451 static void hwreset(struct via_ircc_cb *self)
1452 {
1453         int iobase;
1454         iobase = self->io.fir_base;
1455
1456         IRDA_DEBUG(3, "%s()\n", __func__);
1457
1458         ResetChip(iobase, 5);
1459         EnableDMA(iobase, OFF);
1460         EnableTX(iobase, OFF);
1461         EnableRX(iobase, OFF);
1462         EnRXDMA(iobase, OFF);
1463         EnTXDMA(iobase, OFF);
1464         RXStart(iobase, OFF);
1465         TXStart(iobase, OFF);
1466         InitCard(iobase);
1467         CommonInit(iobase);
1468         SIRFilter(iobase, ON);
1469         SetSIR(iobase, ON);
1470         CRC16(iobase, ON);
1471         EnTXCRC(iobase, 0);
1472         WriteReg(iobase, I_ST_CT_0, 0x00);
1473         SetBaudRate(iobase, 9600);
1474         SetPulseWidth(iobase, 12);
1475         SetSendPreambleCount(iobase, 0);
1476         WriteReg(iobase, I_ST_CT_0, 0x80);
1477
1478         /* Restore speed. */
1479         via_ircc_change_speed(self, self->io.speed);
1480
1481         self->st_fifo.len = 0;
1482 }
1483
1484 /*
1485  * Function via_ircc_is_receiving (self)
1486  *
1487  *    Return TRUE is we are currently receiving a frame
1488  *
1489  */
1490 static int via_ircc_is_receiving(struct via_ircc_cb *self)
1491 {
1492         int status = FALSE;
1493         int iobase;
1494
1495         IRDA_ASSERT(self != NULL, return FALSE;);
1496
1497         iobase = self->io.fir_base;
1498         if (CkRxRecv(iobase, self))
1499                 status = TRUE;
1500
1501         IRDA_DEBUG(2, "%s(): status=%x....\n", __func__, status);
1502
1503         return status;
1504 }
1505
1506
1507 /*
1508  * Function via_ircc_net_open (dev)
1509  *
1510  *    Start the device
1511  *
1512  */
1513 static int via_ircc_net_open(struct net_device *dev)
1514 {
1515         struct via_ircc_cb *self;
1516         int iobase;
1517         char hwname[32];
1518
1519         IRDA_DEBUG(3, "%s()\n", __func__);
1520
1521         IRDA_ASSERT(dev != NULL, return -1;);
1522         self = netdev_priv(dev);
1523         dev->stats.rx_packets = 0;
1524         IRDA_ASSERT(self != NULL, return 0;);
1525         iobase = self->io.fir_base;
1526         if (request_irq(self->io.irq, via_ircc_interrupt, 0, dev->name, dev)) {
1527                 IRDA_WARNING("%s, unable to allocate irq=%d\n", driver_name,
1528                              self->io.irq);
1529                 return -EAGAIN;
1530         }
1531         /*
1532          * Always allocate the DMA channel after the IRQ, and clean up on
1533          * failure.
1534          */
1535         if (request_dma(self->io.dma, dev->name)) {
1536                 IRDA_WARNING("%s, unable to allocate dma=%d\n", driver_name,
1537                              self->io.dma);
1538                 free_irq(self->io.irq, self);
1539                 return -EAGAIN;
1540         }
1541         if (self->io.dma2 != self->io.dma) {
1542                 if (request_dma(self->io.dma2, dev->name)) {
1543                         IRDA_WARNING("%s, unable to allocate dma2=%d\n",
1544                                      driver_name, self->io.dma2);
1545                         free_irq(self->io.irq, self);
1546                         free_dma(self->io.dma);
1547                         return -EAGAIN;
1548                 }
1549         }
1550
1551
1552         /* turn on interrupts */
1553         EnAllInt(iobase, ON);
1554         EnInternalLoop(iobase, OFF);
1555         EnExternalLoop(iobase, OFF);
1556
1557         /* */
1558         via_ircc_dma_receive(self);
1559
1560         /* Ready to play! */
1561         netif_start_queue(dev);
1562
1563         /*
1564          * Open new IrLAP layer instance, now that everything should be
1565          * initialized properly
1566          */
1567         sprintf(hwname, "VIA @ 0x%x", iobase);
1568         self->irlap = irlap_open(dev, &self->qos, hwname);
1569
1570         self->RxLastCount = 0;
1571
1572         return 0;
1573 }
1574
1575 /*
1576  * Function via_ircc_net_close (dev)
1577  *
1578  *    Stop the device
1579  *
1580  */
1581 static int via_ircc_net_close(struct net_device *dev)
1582 {
1583         struct via_ircc_cb *self;
1584         int iobase;
1585
1586         IRDA_DEBUG(3, "%s()\n", __func__);
1587
1588         IRDA_ASSERT(dev != NULL, return -1;);
1589         self = netdev_priv(dev);
1590         IRDA_ASSERT(self != NULL, return 0;);
1591
1592         /* Stop device */
1593         netif_stop_queue(dev);
1594         /* Stop and remove instance of IrLAP */
1595         if (self->irlap)
1596                 irlap_close(self->irlap);
1597         self->irlap = NULL;
1598         iobase = self->io.fir_base;
1599         EnTXDMA(iobase, OFF);
1600         EnRXDMA(iobase, OFF);
1601         DisableDmaChannel(self->io.dma);
1602
1603         /* Disable interrupts */
1604         EnAllInt(iobase, OFF);
1605         free_irq(self->io.irq, dev);
1606         free_dma(self->io.dma);
1607         if (self->io.dma2 != self->io.dma)
1608                 free_dma(self->io.dma2);
1609
1610         return 0;
1611 }
1612
1613 /*
1614  * Function via_ircc_net_ioctl (dev, rq, cmd)
1615  *
1616  *    Process IOCTL commands for this device
1617  *
1618  */
1619 static int via_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq,
1620                               int cmd)
1621 {
1622         struct if_irda_req *irq = (struct if_irda_req *) rq;
1623         struct via_ircc_cb *self;
1624         unsigned long flags;
1625         int ret = 0;
1626
1627         IRDA_ASSERT(dev != NULL, return -1;);
1628         self = netdev_priv(dev);
1629         IRDA_ASSERT(self != NULL, return -1;);
1630         IRDA_DEBUG(1, "%s(), %s, (cmd=0x%X)\n", __func__, dev->name,
1631                    cmd);
1632         /* Disable interrupts & save flags */
1633         spin_lock_irqsave(&self->lock, flags);
1634         switch (cmd) {
1635         case SIOCSBANDWIDTH:    /* Set bandwidth */
1636                 if (!capable(CAP_NET_ADMIN)) {
1637                         ret = -EPERM;
1638                         goto out;
1639                 }
1640                 via_ircc_change_speed(self, irq->ifr_baudrate);
1641                 break;
1642         case SIOCSMEDIABUSY:    /* Set media busy */
1643                 if (!capable(CAP_NET_ADMIN)) {
1644                         ret = -EPERM;
1645                         goto out;
1646                 }
1647                 irda_device_set_media_busy(self->netdev, TRUE);
1648                 break;
1649         case SIOCGRECEIVING:    /* Check if we are receiving right now */
1650                 irq->ifr_receiving = via_ircc_is_receiving(self);
1651                 break;
1652         default:
1653                 ret = -EOPNOTSUPP;
1654         }
1655       out:
1656         spin_unlock_irqrestore(&self->lock, flags);
1657         return ret;
1658 }
1659
1660 MODULE_AUTHOR("VIA Technologies,inc");
1661 MODULE_DESCRIPTION("VIA IrDA Device Driver");
1662 MODULE_LICENSE("GPL");
1663
1664 module_init(via_ircc_init);
1665 module_exit(via_ircc_cleanup);