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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
au1k_ir.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：20k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

au1k_ir.c：源码内容
  1. /*
  2.  *
  3.  * Alchemy Semi Au1000 IrDA driver
  4.  *
  5.  * Copyright 2001 MontaVista Software Inc.
  6.  * Author: MontaVista Software, Inc.
  7.  *          ppopov@mvista.com or source@mvista.com
  8.  *
  9.  * ########################################################################
  10.  *
  11.  *  This program is free software; you can distribute it and/or modify it
  12.  *  under the terms of the GNU General Public License (Version 2) as
  13.  *  published by the Free Software Foundation.
  14.  *
  15.  *  This program is distributed in the hope it will be useful, but WITHOUT
  16.  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17.  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18.  *  for more details.
  19.  *
  20.  *  You should have received a copy of the GNU General Public License along
  21.  *  with this program; if not, write to the Free Software Foundation, Inc.,
  22.  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  23.  *
  24.  * ########################################################################
  25.  *
  26.  * 
  27.  */
  29. #ifndef __mips__
  30. #error This driver only works with MIPS architectures!
  31. #endif
  34. #include <linux/config.h>
  35. #include <linux/module.h>
  36. #include <linux/types.h>
  37. #include <linux/init.h>
  38. #include <linux/errno.h>
  39. #include <linux/netdevice.h>
  40. #include <linux/slab.h>
  41. #include <linux/rtnetlink.h>
  42. #include <linux/interrupt.h>
  43. #include <linux/pm.h>
  45. #include <asm/irq.h>
  46. #include <asm/bitops.h>
  47. #include <asm/io.h>
  48. #include <asm/au1000.h>
  49. #include <asm/pb1000.h>
  51. #include <net/irda/irda.h>
  52. #include <net/irda/irmod.h>
  53. #include <net/irda/wrapper.h>
  54. #include <net/irda/irda_device.h>
  55. #include "net/irda/au1000_ircc.h"
  57. static int au1k_irda_net_init(struct net_device *);
  58. static int au1k_irda_start(struct net_device *);
  59. static int au1k_irda_stop(struct net_device *dev);
  60. static int au1k_irda_hard_xmit(struct sk_buff *, struct net_device *);
  61. static int au1k_irda_rx(struct net_device *);
  62. static void au1k_irda_interrupt(int, void *, struct pt_regs *);
  63. static void au1k_tx_timeout(struct net_device *);
  64. static struct net_device_stats *au1k_irda_stats(struct net_device *);
  65. static int au1k_irda_ioctl(struct net_device *, struct ifreq *, int);
  66. static int au1k_irda_set_speed(struct net_device *dev, int speed);
  68. static void *dma_alloc(size_t, dma_addr_t *);
  69. static void dma_free(void *, size_t);
  71. static int qos_mtt_bits = 0x07;  /* 1 ms or more */
  72. static struct net_device *ir_devs[NUM_IR_IFF];
  73. static char version[] __devinitdata =
  74.     "au1k_ircc:1.0 ppopov@mvista.comn";
  76. #define RUN_AT(x) (jiffies + (x))
  78. /*
  79.  * IrDA peripheral bug. You have to read the register
  80.  * twice to get the right value.
  81.  */
  82. u32 read_ir_reg(u32 addr) 
  83. { 
  84. readl(addr);
  85. return readl(addr);
  86. }
  89. /*
  90.  * Buffer allocation/deallocation routines. The buffer descriptor returned
  91.  * has the virtual and dma address of a buffer suitable for 
  92.  * both, receive and transmit operations.
  93.  */
  94. static db_dest_t *GetFreeDB(struct au1k_private *aup)
  95. {
  96. db_dest_t *pDB;
  97. pDB = aup->pDBfree;
  99. if (pDB) {
  100. aup->pDBfree = pDB->pnext;
  101. }
  102. return pDB;
  103. }
  105. static void ReleaseDB(struct au1k_private *aup, db_dest_t *pDB)
  106. {
  107. db_dest_t *pDBfree = aup->pDBfree;
  108. if (pDBfree)
  109. pDBfree->pnext = pDB;
  110. aup->pDBfree = pDB;
  111. }
  114. /*
  115.   DMA memory allocation, derived from pci_alloc_consistent.
  116.   However, the Au1000 data cache is coherent (when programmed
  117.   so), therefore we return KSEG0 address, not KSEG1.
  118. */
  119. static void *dma_alloc(size_t size, dma_addr_t * dma_handle)
  120. {
  121. void *ret;
  122. int gfp = GFP_ATOMIC | GFP_DMA;
  124. ret = (void *) __get_free_pages(gfp, get_order(size));
  126. if (ret != NULL) {
  127. memset(ret, 0, size);
  128. *dma_handle = virt_to_bus(ret);
  129. ret = KSEG0ADDR(ret);
  130. }
  131. return ret;
  132. }
  135. static void dma_free(void *vaddr, size_t size)
  136. {
  137. vaddr = KSEG0ADDR(vaddr);
  138. free_pages((unsigned long) vaddr, get_order(size));
  139. }
  142. static void 
  143. setup_hw_rings(struct au1k_private *aup, u32 rx_base, u32 tx_base)
  144. {
  145. int i;
  146. for (i=0; i<NUM_IR_DESC; i++) {
  147. aup->rx_ring[i] = (volatile ring_dest_t *) 
  148. (rx_base + sizeof(ring_dest_t)*i);
  149. }
  150. for (i=0; i<NUM_IR_DESC; i++) {
  151. aup->tx_ring[i] = (volatile ring_dest_t *) 
  152. (tx_base + sizeof(ring_dest_t)*i);
  153. }
  154. }
  157. /* 
  158.  * Device has already been stopped at this point.
  159.  */
  160. static void au1k_irda_net_uninit(struct net_device *dev)
  161. {
  162. dev->hard_start_xmit = NULL;
  163. dev->open            = NULL;
  164. dev->stop            = NULL;
  165. dev->do_ioctl        = NULL;
  166. dev->get_stats       = NULL;
  167. dev->priv            = NULL;
  168. }
  171. static int au1k_irda_init(void)
  172. {
  173. static unsigned version_printed = 0;
  174. struct net_device *dev;
  175. int err;
  177. if (version_printed++ == 0) printk(version);
  179. rtnl_lock();
  180. dev = dev_alloc("irda%d", &err);
  181. if (dev) {
  182. dev->irq = AU1000_IRDA_RX_INT; /* TX has its own interrupt */
  183. dev->init = au1k_irda_net_init;
  184. dev->uninit = au1k_irda_net_uninit;
  185. err = register_netdevice(dev);
  187. if (err)
  188. kfree(dev);
  189. else
  190. ir_devs[0] = dev;
  191. printk(KERN_INFO "IrDA: Registered device %sn", dev->name);
  192. }
  193. rtnl_unlock();
  194. return err;
  195. }
  197. static int au1k_irda_init_iobuf(iobuff_t *io, int size)
  198. {
  199. io->head = kmalloc(size, GFP_KERNEL);
  200. if (io->head != NULL) {
  201. io->truesize = size;
  202. io->in_frame = FALSE;
  203. io->state    = OUTSIDE_FRAME;
  204. io->data     = io->head;
  205. }
  206. return io->head ? 0 : -ENOMEM;
  207. }
  209. static int au1k_irda_net_init(struct net_device *dev)
  210. {
  211. struct au1k_private *aup = NULL;
  212. int i, retval = 0, err;
  213. db_dest_t *pDB, *pDBfree;
  214. unsigned long temp;
  216. dev->priv = kmalloc(sizeof(struct au1k_private), GFP_KERNEL);
  217. if (dev->priv == NULL) {
  218. retval = -ENOMEM;
  219. goto out;
  220. }
  221. memset(dev->priv, 0, sizeof(struct au1k_private));
  222. aup = dev->priv;
  224. err = au1k_irda_init_iobuf(&aup->rx_buff, 14384);
  225. if (err)
  226. goto out;
  228. dev->open = au1k_irda_start;
  229. dev->hard_start_xmit = au1k_irda_hard_xmit;
  230. dev->stop = au1k_irda_stop;
  231. dev->get_stats = au1k_irda_stats;
  232. dev->do_ioctl = au1k_irda_ioctl;
  233. dev->tx_timeout = au1k_tx_timeout;
  235. irda_device_setup(dev);
  236. irda_init_max_qos_capabilies(&aup->qos);
  238. /* The only value we must override it the baudrate */
  239. aup->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
  240. IR_115200|IR_576000 |(IR_4000000 << 8);
  242. aup->qos.min_turn_time.bits = qos_mtt_bits;
  243. irda_qos_bits_to_value(&aup->qos);
  246. /* Tx ring follows rx ring + 512 bytes */
  247. /* we need a 1k aligned buffer */
  248. aup->rx_ring[0] = (ring_dest_t *)
  249. dma_alloc(2*MAX_NUM_IR_DESC*(sizeof(ring_dest_t)), &temp);
  251. /* allocate the data buffers */
  252. aup->db[0].vaddr = 
  253. (void *)dma_alloc(MAX_BUF_SIZE * 2*NUM_IR_DESC, &temp);
  254. if (!aup->db[0].vaddr || !aup->rx_ring[0]) {
  255. retval = -ENOMEM;
  256. goto out;
  257. }
  259. setup_hw_rings(aup, (u32)aup->rx_ring[0], (u32)aup->rx_ring[0] + 512);
  261. pDBfree = NULL;
  262. pDB = aup->db;
  263. for (i=0; i<(2*NUM_IR_DESC); i++) {
  264. pDB->pnext = pDBfree;
  265. pDBfree = pDB;
  266. pDB->vaddr = 
  267. (u32 *)((unsigned)aup->db[0].vaddr + MAX_BUF_SIZE*i);
  268. pDB->dma_addr = (dma_addr_t)virt_to_bus(pDB->vaddr);
  269. pDB++;
  270. }
  271. aup->pDBfree = pDBfree;
  273. /* attach a data buffer to each descriptor */
  274. for (i=0; i<NUM_IR_DESC; i++) {
  275. pDB = GetFreeDB(aup);
  276. if (!pDB) goto out;
  277. aup->rx_ring[i]->addr_0 = (u8)(pDB->dma_addr & 0xff);
  278. aup->rx_ring[i]->addr_1 = (u8)((pDB->dma_addr>>8) & 0xff);
  279. aup->rx_ring[i]->addr_2 = (u8)((pDB->dma_addr>>16) & 0xff);
  280. aup->rx_ring[i]->addr_3 = (u8)((pDB->dma_addr>>24) & 0xff);
  281. aup->rx_db_inuse[i] = pDB;
  282. }
  283. for (i=0; i<NUM_IR_DESC; i++) {
  284. pDB = GetFreeDB(aup);
  285. if (!pDB) goto out;
  286. aup->tx_ring[i]->addr_0 = (u8)(pDB->dma_addr & 0xff);
  287. aup->tx_ring[i]->addr_1 = (u8)((pDB->dma_addr>>8) & 0xff);
  288. aup->tx_ring[i]->addr_2 = (u8)((pDB->dma_addr>>16) & 0xff);
  289. aup->tx_ring[i]->addr_3 = (u8)((pDB->dma_addr>>24) & 0xff);
  290. aup->tx_ring[i]->count_0 = 0;
  291. aup->tx_ring[i]->count_1 = 0;
  292. aup->tx_ring[i]->flags = 0;
  293. aup->tx_db_inuse[i] = pDB;
  294. }
  295. return 0;
  297. out:
  298. if (aup->db[0].vaddr) 
  299. dma_free((void *)aup->db[0].vaddr, 
  300. MAX_BUF_SIZE * 2*NUM_IR_DESC);
  301. if (aup->rx_ring[0])
  302. kfree((void *)aup->rx_ring[0]);
  303. if (aup->rx_buff.head)
  304. kfree(aup->rx_buff.head);
  305. if (dev->priv != NULL)
  306. kfree(dev->priv);
  307. unregister_netdevice(dev);
  308. printk(KERN_ERR "%s: au1k_init_module failed.  Returns %dn",
  309.        dev->name, retval);
  310. return retval;
  311. }
  314. static int au1k_init(struct net_device *dev)
  315. {
  316. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  317. int i;
  318. u32 control;
  319. u32 ring_address;
  321. /* bring the device out of reset */
  322. control = 0xe; /* coherent, clock enable, one half system clock */
  323.   
  324. #ifndef CONFIG_CPU_LITTLE_ENDIAN
  325. control |= 1;
  326. #endif
  327. aup->tx_head = 0;
  328. aup->tx_tail = 0;
  329. aup->rx_head = 0;
  331. for (i=0; i<NUM_IR_DESC; i++) {
  332. aup->rx_ring[i]->flags = AU_OWN;
  333. }
  335. writel(control, IR_INTERFACE_CONFIG);
  336. au_sync_delay(10);
  338. writel(read_ir_reg(IR_ENABLE) & ~0x8000, IR_ENABLE); /* disable PHY */
  339. au_sync_delay(1);
  341. writel(MAX_BUF_SIZE, IR_MAX_PKT_LEN);
  343. ring_address = (u32)virt_to_phys((void *)aup->rx_ring[0]);
  344. writel(ring_address >> 26, IR_RING_BASE_ADDR_H);
  345. writel((ring_address >> 10) & 0xffff, IR_RING_BASE_ADDR_L);
  347. writel(RING_SIZE_64<<8 | RING_SIZE_64<<12, IR_RING_SIZE);
  349. writel(1<<2 | IR_ONE_PIN, IR_CONFIG_2); /* 48MHz */
  350. writel(0, IR_RING_ADDR_CMPR);
  352. au1k_irda_set_speed(dev, 9600);
  353. return 0;
  354. }
  356. static int au1k_irda_start(struct net_device *dev)
  357. {
  358. int retval;
  359. char hwname[32];
  360. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  362. MOD_INC_USE_COUNT;
  364. if ((retval = au1k_init(dev))) {
  365. printk(KERN_ERR "%s: error in au1k_initn", dev->name);
  366. MOD_DEC_USE_COUNT;
  367. return retval;
  368. }
  370. if ((retval = request_irq(AU1000_IRDA_TX_INT, &au1k_irda_interrupt, 
  371. 0, dev->name, dev))) {
  372. printk(KERN_ERR "%s: unable to get IRQ %dn", 
  373. dev->name, dev->irq);
  374. MOD_DEC_USE_COUNT;
  375. return retval;
  376. }
  377. if ((retval = request_irq(AU1000_IRDA_RX_INT, &au1k_irda_interrupt, 
  378. 0, dev->name, dev))) {
  379. free_irq(AU1000_IRDA_TX_INT, dev);
  380. printk(KERN_ERR "%s: unable to get IRQ %dn", 
  381. dev->name, dev->irq);
  382. MOD_DEC_USE_COUNT;
  383. return retval;
  384. }
  386. /* Give self a hardware name */
  387. sprintf(hwname, "Au1000 SIR/FIR");
  388. aup->irlap = irlap_open(dev, &aup->qos, hwname);
  389. netif_start_queue(dev);
  391. writel(read_ir_reg(IR_CONFIG_2) | 1<<8, IR_CONFIG_2); /* int enable */
  393. aup->timer.expires = RUN_AT((3*HZ)); 
  394. aup->timer.data = (unsigned long)dev;
  395. return 0;
  396. }
  398. static int au1k_irda_stop(struct net_device *dev)
  399. {
  400. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  402. /* disable interrupts */
  403. writel(read_ir_reg(IR_CONFIG_2) & ~(1<<8), IR_CONFIG_2);
  404. writel(0, IR_CONFIG_1); 
  405. writel(0, IR_INTERFACE_CONFIG); /* disable clock */
  406. au_sync();
  408. if (aup->irlap) {
  409. irlap_close(aup->irlap);
  410. aup->irlap = NULL;
  411. }
  413. netif_stop_queue(dev);
  414. del_timer(&aup->timer);
  416. /* disable the interrupt */
  417. free_irq(AU1000_IRDA_TX_INT, dev);
  418. free_irq(AU1000_IRDA_RX_INT, dev);
  419. MOD_DEC_USE_COUNT;
  420. return 0;
  421. }
  423. static void __exit au1k_irda_exit(void)
  424. {
  425. struct net_device *dev = ir_devs[0];
  426. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  428. if (!dev) {
  429. printk(KERN_ERR "au1k_ircc no dev foundn");
  430. return;
  431. }
  432. if (aup->db[0].vaddr)  {
  433. dma_free((void *)aup->db[0].vaddr, 
  434. MAX_BUF_SIZE * 2*NUM_IR_DESC);
  435. aup->db[0].vaddr = 0;
  436. }
  437. if (aup->rx_ring[0]) {
  438. dma_free((void *)aup->rx_ring[0], 
  439. 2*MAX_NUM_IR_DESC*(sizeof(ring_dest_t)));
  440. aup->rx_ring[0] = 0;
  441. }
  442. rtnl_lock();
  443. unregister_netdevice(dev);
  444. rtnl_unlock();
  445. ir_devs[0] = 0;
  446. }
  449. static inline void 
  450. update_tx_stats(struct net_device *dev, u32 status, u32 pkt_len)
  451. {
  452. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  453. struct net_device_stats *ps = &aup->stats;
  455. ps->tx_packets++;
  456. ps->tx_bytes += pkt_len;
  458. if (status & IR_TX_ERROR) {
  459. ps->tx_errors++;
  460. ps->tx_aborted_errors++;
  461. }
  462. }
  465. static void au1k_tx_ack(struct net_device *dev)
  466. {
  467. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  468. volatile ring_dest_t *ptxd;
  470. ptxd = aup->tx_ring[aup->tx_tail];
  471. while (!(ptxd->flags & AU_OWN) && (aup->tx_tail != aup->tx_head)) {
  472. update_tx_stats(dev, ptxd->flags, 
  473. ptxd->count_1<<8 | ptxd->count_0);
  474. ptxd->count_0 = 0;
  475. ptxd->count_1 = 0;
  476. au_sync();
  478. aup->tx_tail = (aup->tx_tail + 1) & (NUM_IR_DESC - 1);
  479. ptxd = aup->tx_ring[aup->tx_tail];
  481. if (aup->tx_full) {
  482. aup->tx_full = 0;
  483. netif_wake_queue(dev);
  484. }
  485. }
  487. if (aup->tx_tail == aup->tx_head) {
  488. if (aup->newspeed) {
  489. au1k_irda_set_speed(dev, aup->newspeed);
  490. aup->newspeed = 0;
  491. }
  492. else {
  493. writel(read_ir_reg(IR_CONFIG_1) & ~IR_TX_ENABLE, 
  494. IR_CONFIG_1); 
  495. au_sync();
  496. writel(read_ir_reg(IR_CONFIG_1) | IR_RX_ENABLE, 
  497. IR_CONFIG_1); 
  498. writel(0, IR_RING_PROMPT);
  499. au_sync();
  500. }
  501. }
  502. }
  505. /*
  506.  * Au1000 transmit routine.
  507.  */
  508. static int au1k_irda_hard_xmit(struct sk_buff *skb, struct net_device *dev)
  509. {
  510. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  511. int speed = irda_get_next_speed(skb);
  512. volatile ring_dest_t *ptxd;
  513. u32 len;
  515. u32 flags;
  516. db_dest_t *pDB;
  518. if (speed != aup->speed && speed != -1) {
  519. aup->newspeed = speed;
  520. }
  522. if ((skb->len == 0) && (aup->newspeed)) {
  523. if (aup->tx_tail == aup->tx_head) {
  524. au1k_irda_set_speed(dev, speed);
  525. aup->newspeed = 0;
  526. }
  527. dev_kfree_skb(skb);
  528. return 0;
  529. }
  531. ptxd = aup->tx_ring[aup->tx_head];
  532. flags = ptxd->flags;
  534. if (flags & AU_OWN) {
  535. printk(KERN_INFO "%s: tx_fulln", dev->name);
  536. netif_stop_queue(dev);
  537. aup->tx_full = 1;
  538. return 1;
  539. }
  540. else if (((aup->tx_head + 1) & (NUM_IR_DESC - 1)) == aup->tx_tail) {
  541. printk(KERN_INFO "%s: tx_fulln", dev->name);
  542. netif_stop_queue(dev);
  543. aup->tx_full = 1;
  544. return 1;
  545. }
  547. pDB = aup->tx_db_inuse[aup->tx_head];
  549. #if 0
  550. if (read_ir_reg(IR_RX_BYTE_CNT) != 0) {
  551. printk("tx warning: rx byte cnt %xn", 
  552. read_ir_reg(IR_RX_BYTE_CNT));
  553. }
  554. #endif
  556. if (aup->speed == 4000000) {
  557. /* FIR */
  558. memcpy((void *)pDB->vaddr, skb->data, skb->len);
  559. ptxd->count_0 = skb->len & 0xff;
  560. ptxd->count_1 = (skb->len >> 8) & 0xff;
  561. }
  562. else {
  563. /* SIR */
  564. len = async_wrap_skb(skb, (u8 *)pDB->vaddr, MAX_BUF_SIZE);
  565. ptxd->count_0 = len & 0xff;
  566. ptxd->count_1 = (len >> 8) & 0xff;
  567. ptxd->flags |= IR_DIS_CRC;
  568. }
  569. ptxd->flags |= AU_OWN;
  570. au_sync();
  572. writel(read_ir_reg(IR_CONFIG_1) | IR_TX_ENABLE, IR_CONFIG_1); 
  573. writel(0, IR_RING_PROMPT);
  574. au_sync();
  576. dev_kfree_skb(skb);
  577. aup->tx_head = (aup->tx_head + 1) & (NUM_IR_DESC - 1);
  578. dev->trans_start = jiffies;
  579. return 0;
  580. }
  583. static inline void 
  584. update_rx_stats(struct net_device *dev, u32 status, u32 count)
  585. {
  586. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  587. struct net_device_stats *ps = &aup->stats;
  589. ps->rx_packets++;
  591. if (status & IR_RX_ERROR) {
  592. ps->rx_errors++;
  593. if (status & (IR_PHY_ERROR|IR_FIFO_OVER))
  594. ps->rx_missed_errors++;
  595. if (status & IR_MAX_LEN)
  596. ps->rx_length_errors++;
  597. if (status & IR_CRC_ERROR)
  598. ps->rx_crc_errors++;
  599. }
  600. else 
  601. ps->rx_bytes += count;
  602. }
  604. /*
  605.  * Au1000 receive routine.
  606.  */
  607. static int au1k_irda_rx(struct net_device *dev)
  608. {
  609. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  610. struct sk_buff *skb;
  611. volatile ring_dest_t *prxd;
  612. u32 flags, count;
  613. db_dest_t *pDB;
  615. prxd = aup->rx_ring[aup->rx_head];
  616. flags = prxd->flags;
  618. while (!(flags & AU_OWN))  {
  619. pDB = aup->rx_db_inuse[aup->rx_head];
  620. count = prxd->count_1<<8 | prxd->count_0;
  621. if (!(flags & IR_RX_ERROR))  {
  622. /* good frame */
  623. update_rx_stats(dev, flags, count);
  624. skb=alloc_skb(count+1,GFP_ATOMIC);
  625. if (skb == NULL) {
  626. aup->stats.rx_dropped++;
  627. continue;
  628. }
  629. skb_reserve(skb, 1);
  630. if (aup->speed == 4000000)
  631. skb_put(skb, count);
  632. else
  633. skb_put(skb, count-2);
  634. memcpy(skb->data, (void *)pDB->vaddr, count-2);
  635. skb->dev = dev;
  636. skb->mac.raw = skb->data;
  637. skb->protocol = htons(ETH_P_IRDA);
  638. netif_rx(skb);
  639. prxd->count_0 = 0;
  640. prxd->count_1 = 0;
  641. }
  642. prxd->flags |= AU_OWN;
  643. aup->rx_head = (aup->rx_head + 1) & (NUM_IR_DESC - 1);
  644. writel(0, IR_RING_PROMPT);
  645. au_sync();
  647. /* next descriptor */
  648. prxd = aup->rx_ring[aup->rx_head];
  649. flags = prxd->flags;
  650. dev->last_rx = jiffies;
  652. }
  653. return 0;
  654. }
  657. void au1k_irda_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  658. {
  659. struct net_device *dev = (struct net_device *) dev_id;
  661. if (dev == NULL) {
  662. printk(KERN_ERR "%s: isr: null dev ptrn", dev->name);
  663. return;
  664. }
  666. writel(0, IR_INT_CLEAR); /* ack irda interrupts */
  668. au1k_irda_rx(dev);
  669. au1k_tx_ack(dev);
  670. }
  673. /*
  674.  * The Tx ring has been full longer than the watchdog timeout
  675.  * value. The transmitter must be hung?
  676.  */
  677. static void au1k_tx_timeout(struct net_device *dev)
  678. {
  679. u32 speed;
  680. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  682. printk(KERN_ERR "%s: tx timeoutn", dev->name);
  683. speed = aup->speed;
  684. aup->speed = 0;
  685. au1k_irda_set_speed(dev, speed);
  686. aup->tx_full = 0;
  687. netif_wake_queue(dev);
  688. }
  691. /*
  692.  * Set the IrDA communications speed.
  693.  */
  694. static int 
  695. au1k_irda_set_speed(struct net_device *dev, int speed)
  696. {
  697. unsigned long flags;
  698. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  699. u32 control;
  700. int ret = 0, timeout = 10, i;
  701. volatile ring_dest_t *ptxd;
  703. if (speed == aup->speed)
  704. return ret;
  706. save_flags(flags);
  707. cli();
  709. /* disable PHY first */
  710. writel(read_ir_reg(IR_ENABLE) & ~0x8000, IR_ENABLE);
  712. /* disable RX/TX */
  713. writel(read_ir_reg(IR_CONFIG_1) & ~(IR_RX_ENABLE|IR_TX_ENABLE), 
  714. IR_CONFIG_1);
  715. au_sync_delay(1);
  716. while (read_ir_reg(IR_ENABLE) & (IR_RX_STATUS | IR_TX_STATUS)) {
  717. mdelay(1);
  718. if (!timeout--) {
  719. printk(KERN_ERR "%s: rx/tx disable timeoutn",
  720. dev->name);
  721. break;
  722. }
  723. }
  725. /* disable DMA */
  726. writel(read_ir_reg(IR_CONFIG_1) & ~IR_DMA_ENABLE, IR_CONFIG_1);
  727. au_sync_delay(1);
  729. /* 
  730.  *  After we disable tx/rx. the index pointers
  731.    * go back to zero.
  732.  */
  733. aup->tx_head = aup->tx_tail = aup->rx_head = 0;
  734. for (i=0; i<NUM_IR_DESC; i++) {
  735. ptxd = aup->tx_ring[i];
  736. ptxd->flags = 0;
  737. ptxd->count_0 = 0;
  738. ptxd->count_1 = 0;
  739. }
  741. for (i=0; i<NUM_IR_DESC; i++) {
  742. ptxd = aup->rx_ring[i];
  743. ptxd->count_0 = 0;
  744. ptxd->count_1 = 0;
  745. ptxd->flags = AU_OWN;
  746. }
  748. if (speed == 4000000)
  749. writel(1<<13, CPLD_AUX1);
  750. else
  751. writel(readl(CPLD_AUX1) & ~(1<<13), CPLD_AUX1);
  753. switch (speed) {
  754. case 9600:
  755. writel(11<<10 | 12<<5, IR_WRITE_PHY_CONFIG); 
  756. writel(IR_SIR_MODE, IR_CONFIG_1); 
  757. break;
  758. case 19200:
  759. writel(5<<10 | 12<<5, IR_WRITE_PHY_CONFIG); 
  760. writel(IR_SIR_MODE, IR_CONFIG_1); 
  761. break;
  762. case 38400:
  763. writel(2<<10 | 12<<5, IR_WRITE_PHY_CONFIG); 
  764. writel(IR_SIR_MODE, IR_CONFIG_1); 
  765. break;
  766. case 57600:
  767. writel(1<<10 | 12<<5, IR_WRITE_PHY_CONFIG); 
  768. writel(IR_SIR_MODE, IR_CONFIG_1); 
  769. break;
  770. case 115200: 
  771. writel(12<<5, IR_WRITE_PHY_CONFIG); 
  772. writel(IR_SIR_MODE, IR_CONFIG_1); 
  773. break;
  774. case 4000000:
  775. writel(0xF, IR_WRITE_PHY_CONFIG);
  776. writel(IR_FIR|IR_DMA_ENABLE|IR_RX_ENABLE, IR_CONFIG_1); 
  777. break;
  778. default:
  779. printk(KERN_ERR "%s unsupported speed %xn", dev->name, speed);
  780. ret = -EINVAL;
  781. break;
  782. }
  784. aup->speed = speed;
  785. writel(read_ir_reg(IR_ENABLE) | 0x8000, IR_ENABLE);
  786. au_sync();
  788. control = read_ir_reg(IR_ENABLE);
  789. writel(0, IR_RING_PROMPT);
  790. au_sync();
  792. if (control & (1<<14)) {
  793. printk(KERN_ERR "%s: configuration errorn", dev->name);
  794. }
  795. else {
  796. if (control & (1<<11))
  797. printk(KERN_INFO "%s Valid SIR confign", dev->name);
  798. if (control & (1<<12))
  799. printk(KERN_INFO "%s Valid MIR confign", dev->name);
  800. if (control & (1<<13))
  801. printk(KERN_INFO "%s Valid FIR confign", dev->name);
  802. if (control & (1<<10))
  803. printk(KERN_INFO "%s TX enabledn", dev->name);
  804. if (control & (1<<9))
  805. printk(KERN_INFO "%s RX enabledn", dev->name);
  806. }
  808. restore_flags(flags);
  809. return ret;
  810. }
  812. static int 
  813. au1k_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
  814. {
  815. struct if_irda_req *rq = (struct if_irda_req *)ifreq;
  816. struct au1k_private *aup = dev->priv;
  817. int ret = -EOPNOTSUPP;
  819. switch (cmd) {
  820. case SIOCSBANDWIDTH:
  821. if (capable(CAP_NET_ADMIN)) {
  822. /*
  823.  * We are unable to set the speed if the
  824.  * device is not running.
  825.  */
  826. if (aup->open)
  827. ret = au1k_irda_set_speed(dev,
  828. rq->ifr_baudrate);
  829. else {
  830. printk(KERN_ERR "%s ioctl: !netif_runningn",
  831. dev->name);
  832. ret = 0;
  833. }
  834. }
  835. break;
  837. case SIOCSMEDIABUSY:
  838. ret = -EPERM;
  839. if (capable(CAP_NET_ADMIN)) {
  840. irda_device_set_media_busy(dev, TRUE);
  841. ret = 0;
  842. }
  843. break;
  845. case SIOCGRECEIVING:
  846. rq->ifr_receiving = 0;
  847. break;
  848. default:
  849. break;
  850. }
  851. return ret;
  852. }
  855. static struct net_device_stats *au1k_irda_stats(struct net_device *dev)
  856. {
  857. struct au1k_private *aup = (struct au1k_private *) dev->priv;
  858. return &aup->stats;
  859. }
  861. #ifdef MODULE
  862. MODULE_AUTHOR("Pete Popov <ppopov@mvista.com>");
  863. MODULE_DESCRIPTION("Au1000 IrDA Device Driver");
  865. module_init(au1k_irda_init);
  866. module_exit(au1k_irda_exit);
  867. #endif /* MODULE */