开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
w83977af_ir.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：33k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

w83977af_ir.c：源码内容
  1. /*********************************************************************
  2.  *                
  3.  * Filename:      w83977af_ir.c
  4.  * Version:       1.0
  5.  * Description:   FIR driver for the Winbond W83977AF Super I/O chip
  6.  * Status:        Experimental.
  7.  * Author:        Paul VanderSpek
  8.  * Created at:    Wed Nov  4 11:46:16 1998
  9.  * Modified at:   Fri Jan 28 12:10:59 2000
  10.  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11.  * 
  12.  *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>
  13.  *     Copyright (c) 1998-1999 Rebel.com
  14.  *      
  15.  *     This program is free software; you can redistribute it and/or 
  16.  *     modify it under the terms of the GNU General Public License as 
  17.  *     published by the Free Software Foundation; either version 2 of 
  18.  *     the License, or (at your option) any later version.
  19.  *  
  20.  *     Neither Paul VanderSpek nor Rebel.com admit liability nor provide
  21.  *     warranty for any of this software. This material is provided "AS-IS"
  22.  *     and at no charge.
  23.  *     
  24.  *     If you find bugs in this file, its very likely that the same bug
  25.  *     will also be in pc87108.c since the implementations are quite
  26.  *     similar.
  27.  *
  28.  *     Notice that all functions that needs to access the chip in _any_
  29.  *     way, must save BSR register on entry, and restore it on exit. 
  30.  *     It is _very_ important to follow this policy!
  31.  *
  32.  *         __u8 bank;
  33.  *     
  34.  *         bank = inb( iobase+BSR);
  35.  *  
  36.  *         do_your_stuff_here();
  37.  *
  38.  *         outb( bank, iobase+BSR);
  39.  *
  40.  ********************************************************************/
  42. #include <linux/module.h>
  43. #include <linux/config.h> 
  44. #include <linux/kernel.h>
  45. #include <linux/types.h>
  46. #include <linux/skbuff.h>
  47. #include <linux/netdevice.h>
  48. #include <linux/ioport.h>
  49. #include <linux/delay.h>
  50. #include <linux/slab.h>
  51. #include <linux/init.h>
  52. #include <linux/rtnetlink.h>
  54. #include <asm/io.h>
  55. #include <asm/dma.h>
  56. #include <asm/byteorder.h>
  58. #include <net/irda/irda.h>
  59. #include <net/irda/irmod.h>
  60. #include <net/irda/wrapper.h>
  61. #include <net/irda/irda_device.h>
  62. #include <net/irda/w83977af.h>
  63. #include <net/irda/w83977af_ir.h>
  65. #ifdef  CONFIG_ARCH_NETWINDER            /* Adjust to NetWinder differences */
  66. #undef  CONFIG_NETWINDER_TX_DMA_PROBLEMS /* Not needed */
  67. #define CONFIG_NETWINDER_RX_DMA_PROBLEMS /* Must have this one! */
  68. #endif
  69. #undef  CONFIG_USE_INTERNAL_TIMER  /* Just cannot make that timer work */
  70. #define CONFIG_USE_W977_PNP        /* Currently needed */
  71. #define PIO_MAX_SPEED       115200 
  73. static char *driver_name = "w83977af_ir";
  74. static int  qos_mtt_bits = 0x07;   /* 1 ms or more */
  76. #define CHIP_IO_EXTENT 8
  78. static unsigned int io[] = { 0x180, ~0, ~0, ~0 };
  79. #ifdef CONFIG_ARCH_NETWINDER             /* Adjust to NetWinder differences */
  80. static unsigned int irq[] = { 6, 0, 0, 0 };
  81. #else
  82. static unsigned int irq[] = { 11, 0, 0, 0 };
  83. #endif
  84. static unsigned int dma[] = { 1, 0, 0, 0 };
  85. static unsigned int efbase[] = { W977_EFIO_BASE, W977_EFIO2_BASE };
  86. static unsigned int efio = W977_EFIO_BASE;
  88. static struct w83977af_ir *dev_self[] = { NULL, NULL, NULL, NULL};
  90. /* Some prototypes */
  91. static int  w83977af_open(int i, unsigned int iobase, unsigned int irq, 
  92.                           unsigned int dma);
  93. static int  w83977af_close(struct w83977af_ir *self);
  94. static int  w83977af_probe(int iobase, int irq, int dma);
  95. static int  w83977af_dma_receive(struct w83977af_ir *self); 
  96. static int  w83977af_dma_receive_complete(struct w83977af_ir *self);
  97. static int  w83977af_hard_xmit(struct sk_buff *skb, struct net_device *dev);
  98. static int  w83977af_pio_write(int iobase, __u8 *buf, int len, int fifo_size);
  99. static void w83977af_dma_write(struct w83977af_ir *self, int iobase);
  100. static void w83977af_change_speed(struct w83977af_ir *self, __u32 speed);
  101. static void w83977af_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  102. static int  w83977af_is_receiving(struct w83977af_ir *self);
  104. static int  w83977af_net_init(struct net_device *dev);
  105. static int  w83977af_net_open(struct net_device *dev);
  106. static int  w83977af_net_close(struct net_device *dev);
  107. static int  w83977af_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  108. static struct net_device_stats *w83977af_net_get_stats(struct net_device *dev);
  110. /*
  111.  * Function w83977af_init ()
  112.  *
  113.  *    Initialize chip. Just try to find out how many chips we are dealing with
  114.  *    and where they are
  115.  */
  116. int __init w83977af_init(void)
  117. {
  118.         int i;
  120. IRDA_DEBUG(0, __FUNCTION__ "()n");
  122. for (i=0; (io[i] < 2000) && (i < 4); i++) { 
  123. int ioaddr = io[i];
  124. if (check_region(ioaddr, CHIP_IO_EXTENT) < 0)
  125. continue;
  126. if (w83977af_open(i, io[i], irq[i], dma[i]) == 0)
  127. return 0;
  128. }
  129. return -ENODEV;
  130. }
  132. /*
  133.  * Function w83977af_cleanup ()
  134.  *
  135.  *    Close all configured chips
  136.  *
  137.  */
  138. #ifdef MODULE
  139. void w83977af_cleanup(void)
  140. {
  141. int i;
  143.         IRDA_DEBUG(4, __FUNCTION__ "()n");
  145. for (i=0; i < 4; i++) {
  146. if (dev_self[i])
  147. w83977af_close(dev_self[i]);
  148. }
  149. }
  150. #endif /* MODULE */
  152. /*
  153.  * Function w83977af_open (iobase, irq)
  154.  *
  155.  *    Open driver instance
  156.  *
  157.  */
  158. int w83977af_open(int i, unsigned int iobase, unsigned int irq, 
  159.   unsigned int dma)
  160. {
  161. struct net_device *dev;
  162.         struct w83977af_ir *self;
  163. void *ret;
  164. int err;
  166. IRDA_DEBUG(0, __FUNCTION__ "()n");
  168. if (w83977af_probe(iobase, irq, dma) == -1)
  169. return -1;
  171. /*
  172.  *  Allocate new instance of the driver
  173.  */
  174. self = kmalloc(sizeof(struct w83977af_ir), GFP_KERNEL);
  175. if (self == NULL) {
  176. printk( KERN_ERR "IrDA: Can't allocate memory for "
  177. "IrDA control block!n");
  178. return -ENOMEM;
  179. }
  180. memset(self, 0, sizeof(struct w83977af_ir));
  181.    
  182. /* Need to store self somewhere */
  183. dev_self[i] = self;
  185. /* Initialize IO */
  186. self->io.fir_base   = iobase;
  187.         self->io.irq       = irq;
  188.         self->io.fir_ext   = CHIP_IO_EXTENT;
  189.         self->io.dma       = dma;
  190.         self->io.fifo_size = 32;
  192. /* Lock the port that we need */
  193. ret = request_region(self->io.fir_base, self->io.fir_ext, driver_name);
  194. if (!ret) { 
  195. IRDA_DEBUG(0, __FUNCTION__ "(), can't get iobase of 0x%03xn",
  196.       self->io.fir_base);
  197. /* w83977af_cleanup( self);  */
  198. return -ENODEV;
  199. }
  201. /* Initialize QoS for this device */
  202. irda_init_max_qos_capabilies(&self->qos);
  204. /* The only value we must override it the baudrate */
  206. /* FIXME: The HP HDLS-1100 does not support 1152000! */
  207. self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
  208. IR_115200/*|IR_576000|IR_1152000|(IR_4000000 << 8)*/;
  210. /* The HP HDLS-1100 needs 1 ms according to the specs */
  211. self->qos.min_turn_time.bits = qos_mtt_bits;
  212. irda_qos_bits_to_value(&self->qos);
  214. self->flags = IFF_FIR|IFF_MIR|IFF_SIR|IFF_DMA|IFF_PIO;
  216. /* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */
  217. self->rx_buff.truesize = 14384; 
  218. self->tx_buff.truesize = 4000;
  220. /* Allocate memory if needed */
  221. self->rx_buff.head = (__u8 *) kmalloc(self->rx_buff.truesize,
  222.       GFP_KERNEL|GFP_DMA);
  223. if (self->rx_buff.head == NULL)
  224. return -ENOMEM;
  226. memset(self->rx_buff.head, 0, self->rx_buff.truesize);
  228. self->tx_buff.head = (__u8 *) kmalloc(self->tx_buff.truesize, 
  229.       GFP_KERNEL|GFP_DMA);
  230. if (self->tx_buff.head == NULL) {
  231. kfree(self->rx_buff.head);
  232. return -ENOMEM;
  233. }
  234. memset(self->tx_buff.head, 0, self->tx_buff.truesize);
  236. self->rx_buff.in_frame = FALSE;
  237. self->rx_buff.state = OUTSIDE_FRAME;
  238. self->tx_buff.data = self->tx_buff.head;
  239. self->rx_buff.data = self->rx_buff.head;
  241. if (!(dev = dev_alloc("irda%d", &err))) {
  242. ERROR(__FUNCTION__ "(), dev_alloc() failed!n");
  243. return -ENOMEM;
  244. }
  245. dev->priv = (void *) self;
  246. self->netdev = dev;
  248. /* Override the network functions we need to use */
  249. dev->init            = w83977af_net_init;
  250. dev->hard_start_xmit = w83977af_hard_xmit;
  251. dev->open            = w83977af_net_open;
  252. dev->stop            = w83977af_net_close;
  253. dev->do_ioctl        = w83977af_net_ioctl;
  254. dev->get_stats      = w83977af_net_get_stats;
  256. rtnl_lock();
  257. err = register_netdevice(dev);
  258. rtnl_unlock();
  259. if (err) {
  260. ERROR(__FUNCTION__ "(), register_netdevice() failed!n");
  261. return -1;
  262. }
  263. MESSAGE("IrDA: Registered device %sn", dev->name);
  265. return 0;
  266. }
  268. /*
  269.  * Function w83977af_close (self)
  270.  *
  271.  *    Close driver instance
  272.  *
  273.  */
  274. static int w83977af_close(struct w83977af_ir *self)
  275. {
  276. int iobase;
  278. IRDA_DEBUG(0, __FUNCTION__ "()n");
  280.         iobase = self->io.fir_base;
  282. #ifdef CONFIG_USE_W977_PNP
  283. /* enter PnP configuration mode */
  284. w977_efm_enter(efio);
  286. w977_select_device(W977_DEVICE_IR, efio);
  288. /* Deactivate device */
  289. w977_write_reg(0x30, 0x00, efio);
  291. w977_efm_exit(efio);
  292. #endif /* CONFIG_USE_W977_PNP */
  294. /* Remove netdevice */
  295. if (self->netdev) {
  296. rtnl_lock();
  297. unregister_netdevice(self->netdev);
  298. rtnl_unlock();
  299. }
  301. /* Release the PORT that this driver is using */
  302. IRDA_DEBUG(0 , __FUNCTION__ "(), Releasing Region %03xn", 
  303.       self->io.fir_base);
  304. release_region(self->io.fir_base, self->io.fir_ext);
  306. if (self->tx_buff.head)
  307. kfree(self->tx_buff.head);
  309. if (self->rx_buff.head)
  310. kfree(self->rx_buff.head);
  312. kfree(self);
  314. return 0;
  315. }
  317. int w83977af_probe( int iobase, int irq, int dma)
  318. {
  319.    int version;
  320. int i;
  321.   
  322.   for (i=0; i < 2; i++) {
  323.   IRDA_DEBUG( 0, __FUNCTION__ "()n");
  324. #ifdef CONFIG_USE_W977_PNP
  325.   /* Enter PnP configuration mode */
  326. w977_efm_enter(efbase[i]);
  327.   
  328.   w977_select_device(W977_DEVICE_IR, efbase[i]);
  329.   
  330.   /* Configure PnP port, IRQ, and DMA channel */
  331.   w977_write_reg(0x60, (iobase >> 8) & 0xff, efbase[i]);
  332.   w977_write_reg(0x61, (iobase) & 0xff, efbase[i]);
  333.   
  334.   w977_write_reg(0x70, irq, efbase[i]);
  335. #ifdef CONFIG_ARCH_NETWINDER
  336. /* Netwinder uses 1 higher than Linux */
  337.   w977_write_reg(0x74, dma+1, efbase[i]);
  338. #else
  339.   w977_write_reg(0x74, dma, efbase[i]);   
  340. #endif /*CONFIG_ARCH_NETWINDER */
  341.   w977_write_reg(0x75, 0x04, efbase[i]);  /* Disable Tx DMA */
  342.   
  343.   /* Set append hardware CRC, enable IR bank selection */
  344.   w977_write_reg(0xf0, APEDCRC|ENBNKSEL, efbase[i]);
  345.   
  346.   /* Activate device */
  347.   w977_write_reg(0x30, 0x01, efbase[i]);
  348.   
  349.   w977_efm_exit(efbase[i]);
  350. #endif /* CONFIG_USE_W977_PNP */
  351.    /* Disable Advanced mode */
  352.    switch_bank(iobase, SET2);
  353.    outb(iobase+2, 0x00);  
  354.  
  355.   /* Turn on UART (global) interrupts */
  356.   switch_bank(iobase, SET0);
  357.    outb(HCR_EN_IRQ, iobase+HCR);
  358.   
  359.    /* Switch to advanced mode */
  360.    switch_bank(iobase, SET2);
  361.    outb(inb(iobase+ADCR1) | ADCR1_ADV_SL, iobase+ADCR1);
  362.   
  363.    /* Set default IR-mode */
  364.    switch_bank(iobase, SET0);
  365.    outb(HCR_SIR, iobase+HCR);
  366.   
  367.    /* Read the Advanced IR ID */
  368.    switch_bank(iobase, SET3);
  369.    version = inb(iobase+AUID);
  370.   
  371.    /* Should be 0x1? */
  372.    if (0x10 == (version & 0xf0)) {
  373.   efio = efbase[i];
  374.  
  375.   /* Set FIFO size to 32 */
  376.   switch_bank(iobase, SET2);
  377.   outb(ADCR2_RXFS32|ADCR2_TXFS32, iobase+ADCR2);
  378.  
  379.   /* Set FIFO threshold to TX17, RX16 */
  380.   switch_bank(iobase, SET0);
  381.   outb(UFR_RXTL|UFR_TXTL|UFR_TXF_RST|UFR_RXF_RST|
  382.      UFR_EN_FIFO,iobase+UFR);
  383.  
  384.   /* Receiver frame length */
  385.   switch_bank(iobase, SET4);
  386. outb(2048 & 0xff, iobase+6);
  387. outb((2048 >> 8) & 0x1f, iobase+7);
  389. /* 
  390.  * Init HP HSDL-1100 transceiver. 
  391.  * 
  392.  * Set IRX_MSL since we have 2 * receive paths IRRX, 
  393.  * and IRRXH. Clear IRSL0D since we want IRSL0 * to 
  394.  * be a input pin used for IRRXH 
  395.  *
  396.  *   IRRX  pin 37 connected to receiver 
  397.  *   IRTX  pin 38 connected to transmitter
  398.  *   FIRRX pin 39 connected to receiver      (IRSL0) 
  399.  *   CIRRX pin 40 connected to pin 37
  400.  */
  401. switch_bank(iobase, SET7);
  402. outb(0x40, iobase+7);
  404. MESSAGE("W83977AF (IR) driver loaded. "
  405. "Version: 0x%02xn", version);
  407. return 0;
  408. } else {
  409. /* Try next extented function register address */
  410. IRDA_DEBUG( 0, __FUNCTION__ "(), Wrong chip version");
  411. }
  412.    }   
  413. return -1;
  414. }
  416. void w83977af_change_speed(struct w83977af_ir *self, __u32 speed)
  417. {
  418. int ir_mode = HCR_SIR;
  419. int iobase; 
  420. __u8 set;
  422. iobase = self->io.fir_base;
  424. /* Update accounting for new speed */
  425. self->io.speed = speed;
  427. /* Save current bank */
  428. set = inb(iobase+SSR);
  430. /* Disable interrupts */
  431. switch_bank(iobase, SET0);
  432. outb(0, iobase+ICR);
  434. /* Select Set 2 */
  435. switch_bank(iobase, SET2);
  436. outb(0x00, iobase+ABHL);
  438. switch (speed) {
  439. case 9600:   outb(0x0c, iobase+ABLL); break;
  440. case 19200:  outb(0x06, iobase+ABLL); break;
  441. case 38400:  outb(0x03, iobase+ABLL); break;
  442. case 57600:  outb(0x02, iobase+ABLL); break;
  443. case 115200: outb(0x01, iobase+ABLL); break;
  444. case 576000:
  445. ir_mode = HCR_MIR_576;
  446. IRDA_DEBUG(0, __FUNCTION__ "(), handling baud of 576000n");
  447. break;
  448. case 1152000:
  449. ir_mode = HCR_MIR_1152;
  450. IRDA_DEBUG(0, __FUNCTION__ "(), handling baud of 1152000n");
  451. break;
  452. case 4000000:
  453. ir_mode = HCR_FIR;
  454. IRDA_DEBUG(0, __FUNCTION__ "(), handling baud of 4000000n");
  455. break;
  456. default:
  457. ir_mode = HCR_FIR;
  458. IRDA_DEBUG(0, __FUNCTION__ "(), unknown baud rate of %dn", speed);
  459. break;
  460. }
  462. /* Set speed mode */
  463. switch_bank(iobase, SET0);
  464. outb(ir_mode, iobase+HCR);
  466. /* set FIFO size to 32 */
  467. switch_bank(iobase, SET2);
  468. outb(ADCR2_RXFS32|ADCR2_TXFS32, iobase+ADCR2);
  470. /* set FIFO threshold to TX17, RX16 */
  471. switch_bank(iobase, SET0);
  472. outb(0x00, iobase+UFR);        /* Reset */
  473. outb(UFR_EN_FIFO, iobase+UFR); /* First we must enable FIFO */
  474. outb(0xa7, iobase+UFR);
  476. netif_wake_queue(self->netdev);
  478. /* Enable some interrupts so we can receive frames */
  479. switch_bank(iobase, SET0);
  480. if (speed > PIO_MAX_SPEED) {
  481. outb(ICR_EFSFI, iobase+ICR);
  482. w83977af_dma_receive(self);
  483. } else
  484. outb(ICR_ERBRI, iobase+ICR);
  485.     
  486. /* Restore SSR */
  487. outb(set, iobase+SSR);
  488. }
  490. /*
  491.  * Function w83977af_hard_xmit (skb, dev)
  492.  *
  493.  *    Sets up a DMA transfer to send the current frame.
  494.  *
  495.  */
  496. int w83977af_hard_xmit(struct sk_buff *skb, struct net_device *dev)
  497. {
  498. struct w83977af_ir *self;
  499. __s32 speed;
  500. int iobase;
  501. __u8 set;
  502. int mtt;
  504. self = (struct w83977af_ir *) dev->priv;
  506. iobase = self->io.fir_base;
  508. IRDA_DEBUG(4, __FUNCTION__ "(%ld), skb->len=%dn", jiffies, 
  509.    (int) skb->len);
  511. /* Lock transmit buffer */
  512. netif_stop_queue(dev);
  514. /* Check if we need to change the speed */
  515. speed = irda_get_next_speed(skb);
  516. if ((speed != self->io.speed) && (speed != -1)) {
  517. /* Check for empty frame */
  518. if (!skb->len) {
  519. w83977af_change_speed(self, speed); 
  520. dev_kfree_skb(skb);
  521. return 0;
  522. } else
  523. self->new_speed = speed;
  524. }
  526. /* Save current set */
  527. set = inb(iobase+SSR);
  529. /* Decide if we should use PIO or DMA transfer */
  530. if (self->io.speed > PIO_MAX_SPEED) {
  531. self->tx_buff.data = self->tx_buff.head;
  532. memcpy(self->tx_buff.data, skb->data, skb->len);
  533. self->tx_buff.len = skb->len;
  535. mtt = irda_get_mtt(skb);
  536. #ifdef CONFIG_USE_INTERNAL_TIMER
  537.         if (mtt > 50) {
  538. /* Adjust for timer resolution */
  539. mtt /= 1000+1;
  541. /* Setup timer */
  542. switch_bank(iobase, SET4);
  543. outb(mtt & 0xff, iobase+TMRL);
  544. outb((mtt >> 8) & 0x0f, iobase+TMRH);
  546. /* Start timer */
  547. outb(IR_MSL_EN_TMR, iobase+IR_MSL);
  548. self->io.direction = IO_XMIT;
  550. /* Enable timer interrupt */
  551. switch_bank(iobase, SET0);
  552. outb(ICR_ETMRI, iobase+ICR);
  553. } else {
  554. #endif
  555. IRDA_DEBUG(4,__FUNCTION__ "(%ld), mtt=%dn", jiffies, mtt);
  556. if (mtt)
  557. udelay(mtt);
  559. /* Enable DMA interrupt */
  560. switch_bank(iobase, SET0);
  561.   outb(ICR_EDMAI, iobase+ICR);
  562.       w83977af_dma_write(self, iobase);
  563. #ifdef CONFIG_USE_INTERNAL_TIMER
  564. }
  565. #endif
  566. } else {
  567. self->tx_buff.data = self->tx_buff.head;
  568. self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, 
  569.    self->tx_buff.truesize);
  571. /* Add interrupt on tx low level (will fire immediately) */
  572. switch_bank(iobase, SET0);
  573. outb(ICR_ETXTHI, iobase+ICR);
  574. }
  575. dev_kfree_skb(skb);
  577. /* Restore set register */
  578. outb(set, iobase+SSR);
  580. return 0;
  581. }
  583. /*
  584.  * Function w83977af_dma_write (self, iobase)
  585.  *
  586.  *    Send frame using DMA
  587.  *
  588.  */
  589. static void w83977af_dma_write(struct w83977af_ir *self, int iobase)
  590. {
  591. __u8 set;
  592. #ifdef CONFIG_NETWINDER_TX_DMA_PROBLEMS
  593. unsigned long flags;
  594. __u8 hcr;
  595. #endif
  596.         IRDA_DEBUG(4, __FUNCTION__ "(), len=%dn", self->tx_buff.len);
  598. /* Save current set */
  599. set = inb(iobase+SSR);
  601. /* Disable DMA */
  602. switch_bank(iobase, SET0);
  603. outb(inb(iobase+HCR) & ~HCR_EN_DMA, iobase+HCR);
  605. /* Choose transmit DMA channel  */ 
  606. switch_bank(iobase, SET2);
  607. outb(ADCR1_D_CHSW|/*ADCR1_DMA_F|*/ADCR1_ADV_SL, iobase+ADCR1);
  608. #ifdef CONFIG_NETWINDER_TX_DMA_PROBLEMS
  609. save_flags(flags);
  610. cli();
  612. disable_dma(self->io.dma);
  613. clear_dma_ff(self->io.dma);
  614. set_dma_mode(self->io.dma, DMA_MODE_READ);
  615. set_dma_addr(self->io.dma, virt_to_bus(self->tx_buff.data));
  616. set_dma_count(self->io.dma, self->tx_buff.len);
  617. #else
  618. setup_dma(self->io.dma, self->tx_buff.data, self->tx_buff.len, 
  619.   DMA_MODE_WRITE);
  620. #endif
  621. self->io.direction = IO_XMIT;
  623. /* Enable DMA */
  624.   switch_bank(iobase, SET0);
  625. #ifdef CONFIG_NETWINDER_TX_DMA_PROBLEMS
  626. hcr = inb(iobase+HCR);
  627. outb(hcr | HCR_EN_DMA, iobase+HCR);
  628. enable_dma(self->io.dma);
  629. restore_flags(flags);
  630. #else
  631. outb(inb(iobase+HCR) | HCR_EN_DMA | HCR_TX_WT, iobase+HCR);
  632. #endif
  634. /* Restore set register */
  635. outb(set, iobase+SSR);
  636. }
  638. /*
  639.  * Function w83977af_pio_write (iobase, buf, len, fifo_size)
  640.  *
  641.  *    
  642.  *
  643.  */
  644. static int w83977af_pio_write(int iobase, __u8 *buf, int len, int fifo_size)
  645. {
  646. int actual = 0;
  647. __u8 set;
  649. IRDA_DEBUG(4, __FUNCTION__ "()n");
  651. /* Save current bank */
  652. set = inb(iobase+SSR);
  654. switch_bank(iobase, SET0);
  655. if (!(inb_p(iobase+USR) & USR_TSRE)) {
  656. IRDA_DEBUG(4, __FUNCTION__ 
  657.    "(), warning, FIFO not empty yet!n");
  659. fifo_size -= 17;
  660. IRDA_DEBUG(4, __FUNCTION__ "%d bytes left in tx fifon", 
  661.    fifo_size);
  662. }
  664. /* Fill FIFO with current frame */
  665. while ((fifo_size-- > 0) && (actual < len)) {
  666. /* Transmit next byte */
  667. outb(buf[actual++], iobase+TBR);
  668. }
  669.         
  670. IRDA_DEBUG(4, __FUNCTION__ "(), fifo_size %d ; %d sent of %dn", 
  671.    fifo_size, actual, len);
  673. /* Restore bank */
  674. outb(set, iobase+SSR);
  676. return actual;
  677. }
  679. /*
  680.  * Function w83977af_dma_xmit_complete (self)
  681.  *
  682.  *    The transfer of a frame in finished. So do the necessary things
  683.  *
  684.  *    
  685.  */
  686. void w83977af_dma_xmit_complete(struct w83977af_ir *self)
  687. {
  688. int iobase;
  689. __u8 set;
  691. IRDA_DEBUG(4, __FUNCTION__ "(%ld)n", jiffies);
  693. ASSERT(self != NULL, return;);
  695. iobase = self->io.fir_base;
  697. /* Save current set */
  698. set = inb(iobase+SSR);
  700. /* Disable DMA */
  701. switch_bank(iobase, SET0);
  702. outb(inb(iobase+HCR) & ~HCR_EN_DMA, iobase+HCR);
  704. /* Check for underrrun! */
  705. if (inb(iobase+AUDR) & AUDR_UNDR) {
  706. IRDA_DEBUG(0, __FUNCTION__ "(), Transmit underrun!n");
  708. self->stats.tx_errors++;
  709. self->stats.tx_fifo_errors++;
  711. /* Clear bit, by writing 1 to it */
  712. outb(AUDR_UNDR, iobase+AUDR);
  713. } else
  714. self->stats.tx_packets++;
  717. if (self->new_speed) {
  718. w83977af_change_speed(self, self->new_speed);
  719. self->new_speed = 0;
  720. }
  722. /* Unlock tx_buff and request another frame */
  723. /* Tell the network layer, that we want more frames */
  724. netif_wake_queue(self->netdev);
  726. /* Restore set */
  727. outb(set, iobase+SSR);
  728. }
  730. /*
  731.  * Function w83977af_dma_receive (self)
  732.  *
  733.  *    Get ready for receiving a frame. The device will initiate a DMA
  734.  *    if it starts to receive a frame.
  735.  *
  736.  */
  737. int w83977af_dma_receive(struct w83977af_ir *self) 
  738. {
  739. int iobase;
  740. __u8 set;
  741. #ifdef CONFIG_NETWINDER_RX_DMA_PROBLEMS
  742. unsigned long flags;
  743. __u8 hcr;
  744. #endif
  745. ASSERT(self != NULL, return -1;);
  747. IRDA_DEBUG(4, __FUNCTION__ "n");
  749. iobase= self->io.fir_base;
  751. /* Save current set */
  752. set = inb(iobase+SSR);
  754. /* Disable DMA */
  755. switch_bank(iobase, SET0);
  756. outb(inb(iobase+HCR) & ~HCR_EN_DMA, iobase+HCR);
  758. /* Choose DMA Rx, DMA Fairness, and Advanced mode */
  759. switch_bank(iobase, SET2);
  760. outb((inb(iobase+ADCR1) & ~ADCR1_D_CHSW)/*|ADCR1_DMA_F*/|ADCR1_ADV_SL,
  761.      iobase+ADCR1);
  763. self->io.direction = IO_RECV;
  764. self->rx_buff.data = self->rx_buff.head;
  766. #ifdef CONFIG_NETWINDER_RX_DMA_PROBLEMS
  767. save_flags(flags);
  768. cli();
  770. disable_dma(self->io.dma);
  771. clear_dma_ff(self->io.dma);
  772. set_dma_mode(self->io.dma, DMA_MODE_READ);
  773. set_dma_addr(self->io.dma, virt_to_bus(self->rx_buff.data));
  774. set_dma_count(self->io.dma, self->rx_buff.truesize);
  775. #else
  776. setup_dma(self->io.dma, self->rx_buff.data, self->rx_buff.truesize, 
  777.   DMA_MODE_READ);
  778. #endif
  779. /* 
  780.  * Reset Rx FIFO. This will also flush the ST_FIFO, it's very 
  781.  * important that we don't reset the Tx FIFO since it might not
  782.  * be finished transmitting yet
  783.  */
  784. switch_bank(iobase, SET0);
  785. outb(UFR_RXTL|UFR_TXTL|UFR_RXF_RST|UFR_EN_FIFO, iobase+UFR);
  786. self->st_fifo.len = self->st_fifo.tail = self->st_fifo.head = 0;
  788. /* Enable DMA */
  789. switch_bank(iobase, SET0);
  790. #ifdef CONFIG_NETWINDER_RX_DMA_PROBLEMS
  791. hcr = inb(iobase+HCR);
  792. outb(hcr | HCR_EN_DMA, iobase+HCR);
  793. enable_dma(self->io.dma);
  794. restore_flags(flags);
  795. #else
  796. outb(inb(iobase+HCR) | HCR_EN_DMA, iobase+HCR);
  797. #endif
  798. /* Restore set */
  799. outb(set, iobase+SSR);
  801. return 0;
  802. }
  804. /*
  805.  * Function w83977af_receive_complete (self)
  806.  *
  807.  *    Finished with receiving a frame
  808.  *
  809.  */
  810. int w83977af_dma_receive_complete(struct w83977af_ir *self)
  811. {
  812. struct sk_buff *skb;
  813. struct st_fifo *st_fifo;
  814. int len;
  815. int iobase;
  816. __u8 set;
  817. __u8 status;
  819. IRDA_DEBUG(4, __FUNCTION__ "n");
  821. st_fifo = &self->st_fifo;
  823. iobase = self->io.fir_base;
  825. /* Save current set */
  826. set = inb(iobase+SSR);
  828. iobase = self->io.fir_base;
  830. /* Read status FIFO */
  831. switch_bank(iobase, SET5);
  832. while ((status = inb(iobase+FS_FO)) & FS_FO_FSFDR) {
  833. st_fifo->entries[st_fifo->tail].status = status;
  835. st_fifo->entries[st_fifo->tail].len  = inb(iobase+RFLFL);
  836. st_fifo->entries[st_fifo->tail].len |= inb(iobase+RFLFH) << 8;
  838. st_fifo->tail++;
  839. st_fifo->len++;
  840. }
  842. while (st_fifo->len) {
  843. /* Get first entry */
  844. status = st_fifo->entries[st_fifo->head].status;
  845. len    = st_fifo->entries[st_fifo->head].len;
  846. st_fifo->head++;
  847. st_fifo->len--;
  849. /* Check for errors */
  850. if (status & FS_FO_ERR_MSK) {
  851. if (status & FS_FO_LST_FR) {
  852. /* Add number of lost frames to stats */
  853. self->stats.rx_errors += len;
  854. } else {
  855. /* Skip frame */
  856. self->stats.rx_errors++;
  858. self->rx_buff.data += len;
  860. if (status & FS_FO_MX_LEX)
  861. self->stats.rx_length_errors++;
  863. if (status & FS_FO_PHY_ERR) 
  864. self->stats.rx_frame_errors++;
  866. if (status & FS_FO_CRC_ERR) 
  867. self->stats.rx_crc_errors++;
  868. }
  869. /* The errors below can be reported in both cases */
  870. if (status & FS_FO_RX_OV)
  871. self->stats.rx_fifo_errors++;
  873. if (status & FS_FO_FSF_OV)
  874. self->stats.rx_fifo_errors++;
  876. } else {
  877. /* Check if we have transferred all data to memory */
  878. switch_bank(iobase, SET0);
  879. if (inb(iobase+USR) & USR_RDR) {
  880. #ifdef CONFIG_USE_INTERNAL_TIMER
  881. /* Put this entry back in fifo */
  882. st_fifo->head--;
  883. st_fifo->len++;
  884. st_fifo->entries[st_fifo->head].status = status;
  885. st_fifo->entries[st_fifo->head].len = len;
  887. /* Restore set register */
  888. outb(set, iobase+SSR);
  890. return FALSE;  /* I'll be back! */
  891. #else
  892. udelay(80); /* Should be enough!? */
  893. #endif
  894. }
  896. skb = dev_alloc_skb(len+1);
  897. if (skb == NULL)  {
  898. printk(KERN_INFO __FUNCTION__ 
  899.        "(), memory squeeze, dropping frame.n");
  900. /* Restore set register */
  901. outb(set, iobase+SSR);
  903. return FALSE;
  904. }
  906. /*  Align to 20 bytes */
  907. skb_reserve(skb, 1); 
  909. /* Copy frame without CRC */
  910. if (self->io.speed < 4000000) {
  911. skb_put(skb, len-2);
  912. memcpy(skb->data, self->rx_buff.data, len-2);
  913. } else {
  914. skb_put(skb, len-4);
  915. memcpy(skb->data, self->rx_buff.data, len-4);
  916. }
  918. /* Move to next frame */
  919. self->rx_buff.data += len;
  920. self->stats.rx_packets++;
  922. skb->dev = self->netdev;
  923. skb->mac.raw  = skb->data;
  924. skb->protocol = htons(ETH_P_IRDA);
  925. netif_rx(skb);
  926. }
  927. }
  928. /* Restore set register */
  929. outb(set, iobase+SSR);
  931. return TRUE;
  932. }
  934. /*
  935.  * Function pc87108_pio_receive (self)
  936.  *
  937.  *    Receive all data in receiver FIFO
  938.  *
  939.  */
  940. static void w83977af_pio_receive(struct w83977af_ir *self) 
  941. {
  942. __u8 byte = 0x00;
  943. int iobase;
  945. IRDA_DEBUG(4, __FUNCTION__ "()n");
  947. ASSERT(self != NULL, return;);
  949. iobase = self->io.fir_base;
  951. /*  Receive all characters in Rx FIFO */
  952. do {
  953. byte = inb(iobase+RBR);
  954. async_unwrap_char(self->netdev, &self->stats, &self->rx_buff, 
  955.   byte);
  956. } while (inb(iobase+USR) & USR_RDR); /* Data available */
  957. }
  959. /*
  960.  * Function w83977af_sir_interrupt (self, eir)
  961.  *
  962.  *    Handle SIR interrupt
  963.  *
  964.  */
  965. static __u8 w83977af_sir_interrupt(struct w83977af_ir *self, int isr)
  966. {
  967. int actual;
  968. __u8 new_icr = 0;
  969. __u8 set;
  970. int iobase;
  972. IRDA_DEBUG(4, __FUNCTION__ "(), isr=%#xn", isr);
  974. iobase = self->io.fir_base;
  975. /* Transmit FIFO low on data */
  976. if (isr & ISR_TXTH_I) {
  977. /* Write data left in transmit buffer */
  978. actual = w83977af_pio_write(self->io.fir_base, 
  979.     self->tx_buff.data, 
  980.     self->tx_buff.len, 
  981.     self->io.fifo_size);
  983. self->tx_buff.data += actual;
  984. self->tx_buff.len  -= actual;
  986. self->io.direction = IO_XMIT;
  988. /* Check if finished */
  989. if (self->tx_buff.len > 0) {
  990. new_icr |= ICR_ETXTHI;
  991. } else {
  992. set = inb(iobase+SSR);
  993. switch_bank(iobase, SET0);
  994. outb(AUDR_SFEND, iobase+AUDR);
  995. outb(set, iobase+SSR); 
  997. self->stats.tx_packets++;
  999. /* Feed me more packets */
  1000. netif_wake_queue(self->netdev);
  1001. new_icr |= ICR_ETBREI;
  1002. }
  1003. }
  1004. /* Check if transmission has completed */
  1005. if (isr & ISR_TXEMP_I) {
  1006. /* Check if we need to change the speed? */
  1007. if (self->new_speed) {
  1008. IRDA_DEBUG(2, __FUNCTION__ 
  1009.    "(), Changing speed!n");
  1010. w83977af_change_speed(self, self->new_speed);
  1011. self->new_speed = 0;
  1012. }
  1014. /* Turn around and get ready to receive some data */
  1015. self->io.direction = IO_RECV;
  1016. new_icr |= ICR_ERBRI;
  1017. }
  1019. /* Rx FIFO threshold or timeout */
  1020. if (isr & ISR_RXTH_I) {
  1021. w83977af_pio_receive(self);
  1023. /* Keep receiving */
  1024. new_icr |= ICR_ERBRI;
  1025. }
  1026. return new_icr;
  1027. }
  1029. /*
  1030.  * Function pc87108_fir_interrupt (self, eir)
  1031.  *
  1032.  *    Handle MIR/FIR interrupt
  1033.  *
  1034.  */
  1035. static __u8 w83977af_fir_interrupt(struct w83977af_ir *self, int isr)
  1036. {
  1037. __u8 new_icr = 0;
  1038. __u8 set;
  1039. int iobase;
  1041. iobase = self->io.fir_base;
  1042. set = inb(iobase+SSR);
  1044. /* End of frame detected in FIFO */
  1045. if (isr & (ISR_FEND_I|ISR_FSF_I)) {
  1046. if (w83977af_dma_receive_complete(self)) {
  1048. /* Wait for next status FIFO interrupt */
  1049. new_icr |= ICR_EFSFI;
  1050. } else {
  1051. /* DMA not finished yet */
  1053. /* Set timer value, resolution 1 ms */
  1054. switch_bank(iobase, SET4);
  1055. outb(0x01, iobase+TMRL); /* 1 ms */
  1056. outb(0x00, iobase+TMRH);
  1058. /* Start timer */
  1059. outb(IR_MSL_EN_TMR, iobase+IR_MSL);
  1061. new_icr |= ICR_ETMRI;
  1062. }
  1063. }
  1064. /* Timer finished */
  1065. if (isr & ISR_TMR_I) {
  1066. /* Disable timer */
  1067. switch_bank(iobase, SET4);
  1068. outb(0, iobase+IR_MSL);
  1070. /* Clear timer event */
  1071. /* switch_bank(iobase, SET0); */
  1072. /*  outb(ASCR_CTE, iobase+ASCR); */
  1074. /* Check if this is a TX timer interrupt */
  1075. if (self->io.direction == IO_XMIT) {
  1076. w83977af_dma_write(self, iobase);
  1078. new_icr |= ICR_EDMAI;
  1079. } else {
  1080. /* Check if DMA has now finished */
  1081. w83977af_dma_receive_complete(self);
  1083. new_icr |= ICR_EFSFI;
  1084. }
  1085. }
  1086. /* Finished with DMA */
  1087. if (isr & ISR_DMA_I) {
  1088. w83977af_dma_xmit_complete(self);
  1090. /* Check if there are more frames to be transmitted */
  1091. /* if (irda_device_txqueue_empty(self)) { */
  1093. /* Prepare for receive 
  1094.  * 
  1095.  * ** Netwinder Tx DMA likes that we do this anyway **
  1096.  */
  1097. w83977af_dma_receive(self);
  1098. new_icr = ICR_EFSFI;
  1099.        /* } */
  1100. }
  1102. /* Restore set */
  1103. outb(set, iobase+SSR);
  1105. return new_icr;
  1106. }
  1108. /*
  1109.  * Function w83977af_interrupt (irq, dev_id, regs)
  1110.  *
  1111.  *    An interrupt from the chip has arrived. Time to do some work
  1112.  *
  1113.  */
  1114. static void w83977af_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1115. {
  1116. struct net_device *dev = (struct net_device *) dev_id;
  1117. struct w83977af_ir *self;
  1118. __u8 set, icr, isr;
  1119. int iobase;
  1121. if (!dev) {
  1122. printk(KERN_WARNING "%s: irq %d for unknown device.n", 
  1123. driver_name, irq);
  1124. return;
  1125. }
  1126. self = (struct w83977af_ir *) dev->priv;
  1128. iobase = self->io.fir_base;
  1130. /* Save current bank */
  1131. set = inb(iobase+SSR);
  1132. switch_bank(iobase, SET0);
  1134. icr = inb(iobase+ICR); 
  1135. isr = inb(iobase+ISR) & icr; /* Mask out the interesting ones */ 
  1137. outb(0, iobase+ICR); /* Disable interrupts */
  1139. if (isr) {
  1140. /* Dispatch interrupt handler for the current speed */
  1141. if (self->io.speed > PIO_MAX_SPEED )
  1142. icr = w83977af_fir_interrupt(self, isr);
  1143. else
  1144. icr = w83977af_sir_interrupt(self, isr);
  1145. }
  1147. outb(icr, iobase+ICR);    /* Restore (new) interrupts */
  1148. outb(set, iobase+SSR);    /* Restore bank register */
  1150. }
  1152. /*
  1153.  * Function w83977af_is_receiving (self)
  1154.  *
  1155.  *    Return TRUE is we are currently receiving a frame
  1156.  *
  1157.  */
  1158. static int w83977af_is_receiving(struct w83977af_ir *self)
  1159. {
  1160. int status = FALSE;
  1161. int iobase;
  1162. __u8 set;
  1164. ASSERT(self != NULL, return FALSE;);
  1166. if (self->io.speed > 115200) {
  1167. iobase = self->io.fir_base;
  1169. /* Check if rx FIFO is not empty */
  1170. set = inb(iobase+SSR);
  1171. switch_bank(iobase, SET2);
  1172. if ((inb(iobase+RXFDTH) & 0x3f) != 0) {
  1173. /* We are receiving something */
  1174. status =  TRUE;
  1175. }
  1176. outb(set, iobase+SSR);
  1177. } else 
  1178. status = (self->rx_buff.state != OUTSIDE_FRAME);
  1180. return status;
  1181. }
  1183. /*
  1184.  * Function w83977af_net_init (dev)
  1185.  *
  1186.  *    
  1187.  *
  1188.  */
  1189. static int w83977af_net_init(struct net_device *dev)
  1190. {
  1191. IRDA_DEBUG(0, __FUNCTION__ "()n");
  1193. /* Set up to be a normal IrDA network device driver */
  1194. irda_device_setup(dev);
  1196. /* Insert overrides below this line! */
  1198. return 0;
  1199. }
  1202. /*
  1203.  * Function w83977af_net_open (dev)
  1204.  *
  1205.  *    Start the device
  1206.  *
  1207.  */
  1208. static int w83977af_net_open(struct net_device *dev)
  1209. {
  1210. struct w83977af_ir *self;
  1211. int iobase;
  1212. char hwname[32];
  1213. __u8 set;
  1215. IRDA_DEBUG(0, __FUNCTION__ "()n");
  1217. ASSERT(dev != NULL, return -1;);
  1218. self = (struct w83977af_ir *) dev->priv;
  1220. ASSERT(self != NULL, return 0;);
  1222. iobase = self->io.fir_base;
  1224. if (request_irq(self->io.irq, w83977af_interrupt, 0, dev->name, 
  1225. (void *) dev)) {
  1226. return -EAGAIN;
  1227. }
  1228. /*
  1229.  * Always allocate the DMA channel after the IRQ,
  1230.  * and clean up on failure.
  1231.  */
  1232. if (request_dma(self->io.dma, dev->name)) {
  1233. free_irq(self->io.irq, self);
  1234. return -EAGAIN;
  1235. }
  1237. /* Save current set */
  1238. set = inb(iobase+SSR);
  1240.   /* Enable some interrupts so we can receive frames again */
  1241.   switch_bank(iobase, SET0);
  1242.   if (self->io.speed > 115200) {
  1243.   outb(ICR_EFSFI, iobase+ICR);
  1244.   w83977af_dma_receive(self);
  1245.   } else
  1246.   outb(ICR_ERBRI, iobase+ICR);
  1248. /* Restore bank register */
  1249. outb(set, iobase+SSR);
  1251. /* Ready to play! */
  1252. netif_start_queue(dev);
  1254. /* Give self a hardware name */
  1255. sprintf(hwname, "w83977af @ 0x%03x", self->io.fir_base);
  1257. /* 
  1258.  * Open new IrLAP layer instance, now that everything should be
  1259.  * initialized properly 
  1260.  */
  1261. self->irlap = irlap_open(dev, &self->qos, hwname);
  1263. MOD_INC_USE_COUNT;
  1265. return 0;
  1266. }
  1268. /*
  1269.  * Function w83977af_net_close (dev)
  1270.  *
  1271.  *    Stop the device
  1272.  *
  1273.  */
  1274. static int w83977af_net_close(struct net_device *dev)
  1275. {
  1276. struct w83977af_ir *self;
  1277. int iobase;
  1278. __u8 set;
  1280. IRDA_DEBUG(0, __FUNCTION__ "()n");
  1282. ASSERT(dev != NULL, return -1;);
  1284. self = (struct w83977af_ir *) dev->priv;
  1286. ASSERT(self != NULL, return 0;);
  1288. iobase = self->io.fir_base;
  1290. /* Stop device */
  1291. netif_stop_queue(dev);
  1293. /* Stop and remove instance of IrLAP */
  1294. if (self->irlap)
  1295. irlap_close(self->irlap);
  1296. self->irlap = NULL;
  1298. disable_dma(self->io.dma);
  1300. /* Save current set */
  1301. set = inb(iobase+SSR);
  1303. /* Disable interrupts */
  1304. switch_bank(iobase, SET0);
  1305. outb(0, iobase+ICR); 
  1307. free_irq(self->io.irq, dev);
  1308. free_dma(self->io.dma);
  1310. /* Restore bank register */
  1311. outb(set, iobase+SSR);
  1313. MOD_DEC_USE_COUNT;
  1315. return 0;
  1316. }
  1318. /*
  1319.  * Function w83977af_net_ioctl (dev, rq, cmd)
  1320.  *
  1321.  *    Process IOCTL commands for this device
  1322.  *
  1323.  */
  1324. static int w83977af_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1325. {
  1326. struct if_irda_req *irq = (struct if_irda_req *) rq;
  1327. struct w83977af_ir *self;
  1328. unsigned long flags;
  1329. int ret = 0;
  1331. ASSERT(dev != NULL, return -1;);
  1333. self = dev->priv;
  1335. ASSERT(self != NULL, return -1;);
  1337. IRDA_DEBUG(2, __FUNCTION__ "(), %s, (cmd=0x%X)n", dev->name, cmd);
  1339. /* Disable interrupts & save flags */
  1340. save_flags(flags);
  1341. cli();
  1343. switch (cmd) {
  1344. case SIOCSBANDWIDTH: /* Set bandwidth */
  1345. if (!capable(CAP_NET_ADMIN)) {
  1346. ret = -EPERM;
  1347. break;
  1348. }
  1349. w83977af_change_speed(self, irq->ifr_baudrate);
  1350. break;
  1351. case SIOCSMEDIABUSY: /* Set media busy */
  1352. if (!capable(CAP_NET_ADMIN)) {
  1353. ret = -EPERM;
  1354. goto out;
  1355. }
  1356. irda_device_set_media_busy(self->netdev, TRUE);
  1357. break;
  1358. case SIOCGRECEIVING: /* Check if we are receiving right now */
  1359. irq->ifr_receiving = w83977af_is_receiving(self);
  1360. break;
  1361. default:
  1362. ret = -EOPNOTSUPP;
  1363. }
  1364. out:
  1365. restore_flags(flags);
  1366. return ret;
  1367. }
  1369. static struct net_device_stats *w83977af_net_get_stats(struct net_device *dev)
  1370. {
  1371. struct w83977af_ir *self = (struct w83977af_ir *) dev->priv;
  1373. return &self->stats;
  1374. }
  1376. #ifdef MODULE
  1378. MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
  1379. MODULE_DESCRIPTION("Winbond W83977AF IrDA Device Driver");
  1380. MODULE_LICENSE("GPL");
  1383. MODULE_PARM(qos_mtt_bits, "i");
  1384. MODULE_PARM_DESC(qos_mtt_bits, "Mimimum Turn Time");
  1385. MODULE_PARM(io, "1-4i");
  1386. MODULE_PARM_DESC(io, "Base I/O addresses");
  1387. MODULE_PARM(irq, "1-4i");
  1388. MODULE_PARM_DESC(irq, "IRQ lines");
  1390. /*
  1391.  * Function init_module (void)
  1392.  *
  1393.  *    
  1394.  *
  1395.  */
  1396. int init_module(void)
  1397. {
  1398. return w83977af_init();
  1399. }
  1401. /*
  1402.  * Function cleanup_module (void)
  1403.  *
  1404.  *    
  1405.  *
  1406.  */
  1407. void cleanup_module(void)
  1408. {
  1409. w83977af_cleanup();
  1410. }
  1411. #endif /* MODULE */