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

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

嵌入式Linux

开发平台：

Unix_Linux

irport.c：源码内容
  1. /*********************************************************************
  2.  * 
  3.  * Filename:   irport.c
  4.  * Version:   1.0
  5.  * Description:   Half duplex serial port SIR driver for IrDA. 
  6.  * Status:   Experimental.
  7.  * Author:   Dag Brattli <dagb@cs.uit.no>
  8.  * Created at:   Sun Aug  3 13:49:59 1997
  9.  * Modified at:   Fri Jan 28 20:22:38 2000
  10.  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11.  * Sources:   serial.c by Linus Torvalds 
  12.  * 
  13.  *     Copyright (c) 1997, 1998, 1999-2000 Dag Brattli, All Rights Reserved.
  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.  *     This program is distributed in the hope that it will be useful,
  21.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23.  *     GNU General Public License for more details.
  24.  * 
  25.  *     You should have received a copy of the GNU General Public License 
  26.  *     along with this program; if not, write to the Free Software 
  27.  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
  28.  *     MA 02111-1307 USA
  29.  *
  30.  *     This driver is ment to be a small half duplex serial driver to be
  31.  *     used for IR-chipsets that has a UART (16550) compatibility mode. 
  32.  *     Eventually it will replace irtty, because of irtty has some 
  33.  *     problems that is hard to get around when we don't have control
  34.  *     over the serial driver. This driver may also be used by FIR 
  35.  *     drivers to handle SIR mode for them.
  36.  *
  37.  ********************************************************************/
  39. #include <linux/module.h>
  41. #include <linux/kernel.h>
  42. #include <linux/types.h>
  43. #include <linux/ioport.h>
  44. #include <linux/slab.h>
  45. #include <linux/string.h>
  46. #include <linux/skbuff.h>
  47. #include <linux/serial_reg.h>
  48. #include <linux/errno.h>
  49. #include <linux/init.h>
  50. #include <linux/spinlock.h>
  51. #include <linux/rtnetlink.h>
  53. #include <asm/system.h>
  54. #include <asm/bitops.h>
  55. #include <asm/io.h>
  57. #include <net/irda/irda.h>
  58. #include <net/irda/irmod.h>
  59. #include <net/irda/wrapper.h>
  60. #include <net/irda/irport.h>
  62. #define IO_EXTENT 8
  64. /* 
  65.  * Currently you'll need to set these values using insmod like this:
  66.  * insmod irport io=0x3e8 irq=11
  67.  */
  68. static unsigned int io[]  = { ~0, ~0, ~0, ~0 };
  69. static unsigned int irq[] = { 0, 0, 0, 0 };
  71. static unsigned int qos_mtt_bits = 0x03;
  73. static struct irport_cb *dev_self[] = { NULL, NULL, NULL, NULL};
  74. static char *driver_name = "irport";
  76. static void irport_write_wakeup(struct irport_cb *self);
  77. static int  irport_write(int iobase, int fifo_size, __u8 *buf, int len);
  78. static void irport_receive(struct irport_cb *self);
  80. static int  irport_net_init(struct net_device *dev);
  81. static int  irport_net_ioctl(struct net_device *dev, struct ifreq *rq, 
  82.      int cmd);
  83. static int  irport_is_receiving(struct irport_cb *self);
  84. static int  irport_set_dtr_rts(struct net_device *dev, int dtr, int rts);
  85. static int  irport_raw_write(struct net_device *dev, __u8 *buf, int len);
  86. static struct net_device_stats *irport_net_get_stats(struct net_device *dev);
  87. static int irport_change_speed_complete(struct irda_task *task);
  88. static void irport_timeout(struct net_device *dev);
  90. EXPORT_SYMBOL(irport_open);
  91. EXPORT_SYMBOL(irport_close);
  92. EXPORT_SYMBOL(irport_start);
  93. EXPORT_SYMBOL(irport_stop);
  94. EXPORT_SYMBOL(irport_interrupt);
  95. EXPORT_SYMBOL(irport_hard_xmit);
  96. EXPORT_SYMBOL(irport_timeout);
  97. EXPORT_SYMBOL(irport_change_speed);
  98. EXPORT_SYMBOL(irport_net_open);
  99. EXPORT_SYMBOL(irport_net_close);
  101. int __init irport_init(void)
  102. {
  103.   int i;
  105.   for (i=0; (io[i] < 2000) && (i < 4); i++) {
  106.   int ioaddr = io[i];
  107.   if (check_region(ioaddr, IO_EXTENT))
  108.   continue;
  109.   if (irport_open(i, io[i], irq[i]) != NULL)
  110.   return 0;
  111.   }
  112. /* 
  113.  * Maybe something failed, but we can still be usable for FIR drivers 
  114.  */
  115.   return 0;
  116. }
  118. /*
  119.  * Function irport_cleanup ()
  120.  *
  121.  *    Close all configured ports
  122.  *
  123.  */
  124. #ifdef MODULE
  125. static void irport_cleanup(void)
  126. {
  127.   int i;
  129.         IRDA_DEBUG( 4, __FUNCTION__ "()n");
  131. for (i=0; i < 4; i++) {
  132.   if (dev_self[i])
  133.   irport_close(dev_self[i]);
  134.   }
  135. }
  136. #endif /* MODULE */
  138. struct irport_cb *
  139. irport_open(int i, unsigned int iobase, unsigned int irq)
  140. {
  141. struct net_device *dev;
  142. struct irport_cb *self;
  143. void *ret;
  144. int err;
  146. IRDA_DEBUG(0, __FUNCTION__ "()n");
  148. /*
  149.  *  Allocate new instance of the driver
  150.  */
  151. self = kmalloc(sizeof(struct irport_cb), GFP_KERNEL);
  152. if (!self) {
  153. ERROR(__FUNCTION__ "(), can't allocate memory for "
  154.       "control block!n");
  155. return NULL;
  156. }
  157. memset(self, 0, sizeof(struct irport_cb));
  158. spin_lock_init(&self->lock);
  160. /* Need to store self somewhere */
  161. dev_self[i] = self;
  162. self->priv = self;
  163. self->index = i;
  165. /* Initialize IO */
  166. self->io.sir_base  = iobase;
  167.         self->io.sir_ext   = IO_EXTENT;
  168.         self->io.irq       = irq;
  169.         self->io.fifo_size = 16;
  171. /* Lock the port that we need */
  172. ret = request_region(self->io.sir_base, self->io.sir_ext, driver_name);
  173. if (!ret) { 
  174. IRDA_DEBUG(0, __FUNCTION__ "(), can't get iobase of 0x%03xn",
  175.    self->io.sir_base);
  176. return NULL;
  177. }
  179. /* Initialize QoS for this device */
  180. irda_init_max_qos_capabilies(&self->qos);
  182. self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
  183. IR_115200;
  185. self->qos.min_turn_time.bits = qos_mtt_bits;
  186. irda_qos_bits_to_value(&self->qos);
  188. self->flags = IFF_SIR|IFF_PIO;
  190. /* Specify how much memory we want */
  191. self->rx_buff.truesize = 4000; 
  192. self->tx_buff.truesize = 4000;
  194. /* Allocate memory if needed */
  195. if (self->rx_buff.truesize > 0) {
  196. self->rx_buff.head = (__u8 *) kmalloc(self->rx_buff.truesize,
  197.       GFP_KERNEL);
  198. if (self->rx_buff.head == NULL)
  199. return NULL;
  200. memset(self->rx_buff.head, 0, self->rx_buff.truesize);
  201. }
  202. if (self->tx_buff.truesize > 0) {
  203. self->tx_buff.head = (__u8 *) kmalloc(self->tx_buff.truesize, 
  204.       GFP_KERNEL);
  205. if (self->tx_buff.head == NULL) {
  206. kfree(self->rx_buff.head);
  207. return NULL;
  208. }
  209. memset(self->tx_buff.head, 0, self->tx_buff.truesize);
  210. }
  211. self->rx_buff.in_frame = FALSE;
  212. self->rx_buff.state = OUTSIDE_FRAME;
  213. self->tx_buff.data = self->tx_buff.head;
  214. self->rx_buff.data = self->rx_buff.head;
  215. self->mode = IRDA_IRLAP;
  217. if (!(dev = dev_alloc("irda%d", &err))) {
  218. ERROR(__FUNCTION__ "(), dev_alloc() failed!n");
  219. return NULL;
  220. }
  221. self->netdev = dev;
  223. /* May be overridden by piggyback drivers */
  224.   dev->priv = (void *) self;
  225. self->interrupt    = irport_interrupt;
  226. self->change_speed = irport_change_speed;
  228. /* Override the network functions we need to use */
  229. dev->init            = irport_net_init;
  230. dev->hard_start_xmit = irport_hard_xmit;
  231. dev->tx_timeout      = irport_timeout;
  232. dev->watchdog_timeo  = HZ;  /* Allow time enough for speed change */
  233. dev->open            = irport_net_open;
  234. dev->stop            = irport_net_close;
  235. dev->get_stats      = irport_net_get_stats;
  236. dev->do_ioctl        = irport_net_ioctl;
  238. /* Make ifconfig display some details */
  239. dev->base_addr = iobase;
  240. dev->irq = irq;
  242. rtnl_lock();
  243. err = register_netdevice(dev);
  244. rtnl_unlock();
  245. if (err) {
  246. ERROR(__FUNCTION__ "(), register_netdev() failed!n");
  247. return NULL;
  248. }
  249. MESSAGE("IrDA: Registered device %sn", dev->name);
  251. return self;
  252. }
  254. int irport_close(struct irport_cb *self)
  255. {
  256. ASSERT(self != NULL, return -1;);
  258. /* We are not using any dongle anymore! */
  259. if (self->dongle)
  260. irda_device_dongle_cleanup(self->dongle);
  261. self->dongle = NULL;
  263. /* Remove netdevice */
  264. if (self->netdev) {
  265. rtnl_lock();
  266. unregister_netdevice(self->netdev);
  267. rtnl_unlock();
  268. }
  270. /* Release the IO-port that this driver is using */
  271. IRDA_DEBUG(0 , __FUNCTION__ "(), Releasing Region %03xn", 
  272.    self->io.sir_base);
  273. release_region(self->io.sir_base, self->io.sir_ext);
  275. if (self->tx_buff.head)
  276. kfree(self->tx_buff.head);
  278. if (self->rx_buff.head)
  279. kfree(self->rx_buff.head);
  281. /* Remove ourselves */
  282. dev_self[self->index] = NULL;
  283. kfree(self);
  285. return 0;
  286. }
  288. void irport_start(struct irport_cb *self)
  289. {
  290. unsigned long flags;
  291. int iobase;
  293. iobase = self->io.sir_base;
  295. irport_stop(self);
  297. spin_lock_irqsave(&self->lock, flags);
  299. /* Initialize UART */
  300. outb(UART_LCR_WLEN8, iobase+UART_LCR);  /* Reset DLAB */
  301. outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase+UART_MCR);
  303. /* Turn on interrups */
  304. outb(UART_IER_RLSI | UART_IER_RDI |UART_IER_THRI, iobase+UART_IER);
  306. spin_unlock_irqrestore(&self->lock, flags);
  307. }
  309. void irport_stop(struct irport_cb *self)
  310. {
  311. unsigned long flags;
  312. int iobase;
  314. iobase = self->io.sir_base;
  316. spin_lock_irqsave(&self->lock, flags);
  318. /* Reset UART */
  319. outb(0, iobase+UART_MCR);
  321. /* Turn off interrupts */
  322. outb(0, iobase+UART_IER);
  324. spin_unlock_irqrestore(&self->lock, flags);
  325. }
  327. /*
  328.  * Function irport_probe (void)
  329.  *
  330.  *    Start IO port 
  331.  *
  332.  */
  333. int irport_probe(int iobase)
  334. {
  335. IRDA_DEBUG(4, __FUNCTION__ "(), iobase=%#xn", iobase);
  337. return 0;
  338. }
  340. /*
  341.  * Function irport_change_speed (self, speed)
  342.  *
  343.  *    Set speed of IrDA port to specified baudrate
  344.  *
  345.  */
  346. void irport_change_speed(void *priv, __u32 speed)
  347. {
  348. struct irport_cb *self = (struct irport_cb *) priv;
  349. unsigned long flags;
  350. int iobase; 
  351. int fcr;    /* FIFO control reg */
  352. int lcr;    /* Line control reg */
  353. int divisor;
  355. IRDA_DEBUG(0, __FUNCTION__ "(), Setting speed to: %dn", speed);
  357. ASSERT(self != NULL, return;);
  359. iobase = self->io.sir_base;
  361. /* Update accounting for new speed */
  362. self->io.speed = speed;
  364. spin_lock_irqsave(&self->lock, flags);
  366. /* Turn off interrupts */
  367. outb(0, iobase+UART_IER); 
  369. divisor = SPEED_MAX/speed;
  371. fcr = UART_FCR_ENABLE_FIFO;
  373. /* 
  374.  * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
  375.  * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
  376.  * about this timeout since it will always be fast enough. 
  377.  */
  378. if (self->io.speed < 38400)
  379. fcr |= UART_FCR_TRIGGER_1;
  380. else 
  381. fcr |= UART_FCR_TRIGGER_14;
  382.         
  383. /* IrDA ports use 8N1 */
  384. lcr = UART_LCR_WLEN8;
  386. outb(UART_LCR_DLAB | lcr, iobase+UART_LCR); /* Set DLAB */
  387. outb(divisor & 0xff,      iobase+UART_DLL); /* Set speed */
  388. outb(divisor >> 8,   iobase+UART_DLM);
  389. outb(lcr,   iobase+UART_LCR); /* Set 8N1 */
  390. outb(fcr,   iobase+UART_FCR); /* Enable FIFO's */
  392. /* Turn on interrups */
  393. outb(/*UART_IER_RLSI|*/UART_IER_RDI/*|UART_IER_THRI*/, iobase+UART_IER);
  395. spin_unlock_irqrestore(&self->lock, flags);
  396. }
  398. /*
  399.  * Function __irport_change_speed (instance, state, param)
  400.  *
  401.  *    State machine for changing speed of the device. We do it this way since
  402.  *    we cannot use schedule_timeout() when we are in interrupt context
  403.  */
  404. int __irport_change_speed(struct irda_task *task)
  405. {
  406. struct irport_cb *self;
  407. __u32 speed = (__u32) task->param;
  408. int ret = 0;
  410. IRDA_DEBUG(2, __FUNCTION__ "(), <%ld>n", jiffies); 
  412. self = (struct irport_cb *) task->instance;
  414. ASSERT(self != NULL, return -1;);
  416. switch (task->state) {
  417. case IRDA_TASK_INIT:
  418. case IRDA_TASK_WAIT:
  419. /* Are we ready to change speed yet? */
  420. if (self->tx_buff.len > 0) {
  421. task->state = IRDA_TASK_WAIT;
  423. /* Try again later */
  424. ret = MSECS_TO_JIFFIES(20);
  425. break;
  426. }
  428. if (self->dongle)
  429. irda_task_next_state(task, IRDA_TASK_CHILD_INIT);
  430. else
  431. irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
  432. break;
  433. case IRDA_TASK_CHILD_INIT:
  434. /* Go to default speed */
  435. self->change_speed(self->priv, 9600);
  437. /* Change speed of dongle */
  438. if (irda_task_execute(self->dongle,
  439.       self->dongle->issue->change_speed, 
  440.       NULL, task, (void *) speed))
  441. {
  442. /* Dongle need more time to change its speed */
  443. irda_task_next_state(task, IRDA_TASK_CHILD_WAIT);
  445. /* Give dongle 1 sec to finish */
  446. ret = MSECS_TO_JIFFIES(1000);
  447. } else
  448. /* Child finished immediately */
  449. irda_task_next_state(task, IRDA_TASK_CHILD_DONE);
  450. break;
  451. case IRDA_TASK_CHILD_WAIT:
  452. WARNING(__FUNCTION__ 
  453. "(), changing speed of dongle timed out!n");
  454. ret = -1;
  455. break;
  456. case IRDA_TASK_CHILD_DONE:
  457. /* Finally we are ready to change the speed */
  458. self->change_speed(self->priv, speed);
  460. irda_task_next_state(task, IRDA_TASK_DONE);
  461. break;
  462. default:
  463. ERROR(__FUNCTION__ "(), unknown state %dn", task->state);
  464. irda_task_next_state(task, IRDA_TASK_DONE);
  465. ret = -1;
  466. break;
  467. }
  468. return ret;
  469. }
  471. /*
  472.  * Function irport_write_wakeup (tty)
  473.  *
  474.  *    Called by the driver when there's room for more data.  If we have
  475.  *    more packets to send, we send them here.
  476.  *
  477.  */
  478. static void irport_write_wakeup(struct irport_cb *self)
  479. {
  480. int actual = 0;
  481. int iobase;
  482. int fcr;
  484. ASSERT(self != NULL, return;);
  486. IRDA_DEBUG(4, __FUNCTION__ "()n");
  488. iobase = self->io.sir_base;
  490. /* Finished with frame?  */
  491. if (self->tx_buff.len > 0)  {
  492. /* Write data left in transmit buffer */
  493. actual = irport_write(iobase, self->io.fifo_size, 
  494.       self->tx_buff.data, self->tx_buff.len);
  495. self->tx_buff.data += actual;
  496. self->tx_buff.len  -= actual;
  497. } else {
  498. /* 
  499.  *  Now serial buffer is almost free & we can start 
  500.  *  transmission of another packet. But first we must check
  501.  *  if we need to change the speed of the hardware
  502.  */
  503. if (self->new_speed) {
  504. IRDA_DEBUG(5, __FUNCTION__ "(), Changing speed!n");
  505. irda_task_execute(self, __irport_change_speed, 
  506.   irport_change_speed_complete, 
  507.   NULL, (void *) self->new_speed);
  508. self->new_speed = 0;
  509. } else {
  510. /* Tell network layer that we want more frames */
  511. netif_wake_queue(self->netdev);
  512. }
  513. self->stats.tx_packets++;
  515. /* 
  516.  * Reset Rx FIFO to make sure that all reflected transmit data
  517.  * is discarded. This is needed for half duplex operation
  518.  */
  519. fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR;
  520. if (self->io.speed < 38400)
  521. fcr |= UART_FCR_TRIGGER_1;
  522. else 
  523. fcr |= UART_FCR_TRIGGER_14;
  525. outb(fcr, iobase+UART_FCR);
  527. /* Turn on receive interrupts */
  528. outb(UART_IER_RDI, iobase+UART_IER);
  529. }
  530. }
  532. /*
  533.  * Function irport_write (driver)
  534.  *
  535.  *    Fill Tx FIFO with transmit data
  536.  *
  537.  */
  538. static int irport_write(int iobase, int fifo_size, __u8 *buf, int len)
  539. {
  540. int actual = 0;
  542. /* Tx FIFO should be empty! */
  543. if (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) {
  544. IRDA_DEBUG(0, __FUNCTION__ "(), failed, fifo not empty!n");
  545. return 0;
  546. }
  547.         
  548. /* Fill FIFO with current frame */
  549. while ((fifo_size-- > 0) && (actual < len)) {
  550. /* Transmit next byte */
  551. outb(buf[actual], iobase+UART_TX);
  553. actual++;
  554. }
  555.         
  556. return actual;
  557. }
  559. /*
  560.  * Function irport_change_speed_complete (task)
  561.  *
  562.  *    Called when the change speed operation completes
  563.  *
  564.  */
  565. static int irport_change_speed_complete(struct irda_task *task)
  566. {
  567. struct irport_cb *self;
  569. IRDA_DEBUG(0, __FUNCTION__ "()n");
  571. self = (struct irport_cb *) task->instance;
  573. ASSERT(self != NULL, return -1;);
  574. ASSERT(self->netdev != NULL, return -1;);
  576. /* Finished changing speed, so we are not busy any longer */
  577. /* Signal network layer so it can try to send the frame */
  579. netif_wake_queue(self->netdev);
  581. return 0;
  582. }
  584. /*
  585.  * Function irport_timeout (struct net_device *dev)
  586.  *
  587.  *    The networking layer thinks we timed out.
  588.  *
  589.  */
  591. static void irport_timeout(struct net_device *dev)
  592. {
  593. struct irport_cb *self;
  594. int iobase;
  596. self = (struct irport_cb *) dev->priv;
  597. iobase = self->io.sir_base;
  599. WARNING("%s: transmit timed outn", dev->name);
  600. irport_start(self);
  601. self->change_speed(self->priv, self->io.speed);
  602. dev->trans_start = jiffies;
  603. netif_wake_queue(dev);
  604. }
  605.  
  606. /*
  607.  * Function irport_hard_start_xmit (struct sk_buff *skb, struct net_device *dev)
  608.  *
  609.  *    Transmits the current frame until FIFO is full, then
  610.  *    waits until the next transmitt interrupt, and continues until the
  611.  *    frame is transmitted.
  612.  */
  613. int irport_hard_xmit(struct sk_buff *skb, struct net_device *dev)
  614. {
  615. struct irport_cb *self;
  616. unsigned long flags;
  617. int iobase;
  618. s32 speed;
  620. IRDA_DEBUG(0, __FUNCTION__ "()n");
  622. ASSERT(dev != NULL, return 0;);
  624. self = (struct irport_cb *) dev->priv;
  625. ASSERT(self != NULL, return 0;);
  627. iobase = self->io.sir_base;
  629. netif_stop_queue(dev);
  631. /* Check if we need to change the speed */
  632. speed = irda_get_next_speed(skb);
  633. if ((speed != self->io.speed) && (speed != -1)) {
  634. /* Check for empty frame */
  635. if (!skb->len) {
  636. irda_task_execute(self, __irport_change_speed, 
  637.   irport_change_speed_complete, 
  638.   NULL, (void *) speed);
  639. dev_kfree_skb(skb);
  640. return 0;
  641. } else
  642. self->new_speed = speed;
  643. }
  645. spin_lock_irqsave(&self->lock, flags);
  647. /* Init tx buffer */
  648. self->tx_buff.data = self->tx_buff.head;
  650.         /* Copy skb to tx_buff while wrapping, stuffing and making CRC */
  651. self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, 
  652.    self->tx_buff.truesize);
  654. self->stats.tx_bytes += self->tx_buff.len;
  656. /* Turn on transmit finished interrupt. Will fire immediately!  */
  657. outb(UART_IER_THRI, iobase+UART_IER); 
  659. spin_unlock_irqrestore(&self->lock, flags);
  661. dev_kfree_skb(skb);
  663. return 0;
  664. }
  665.         
  666. /*
  667.  * Function irport_receive (self)
  668.  *
  669.  *    Receive one frame from the infrared port
  670.  *
  671.  */
  672. static void irport_receive(struct irport_cb *self) 
  673. {
  674. int boguscount = 0;
  675. int iobase;
  677. ASSERT(self != NULL, return;);
  679. iobase = self->io.sir_base;
  681. /*  
  682.  * Receive all characters in Rx FIFO, unwrap and unstuff them. 
  683.          * async_unwrap_char will deliver all found frames  
  684.  */
  685. do {
  686. async_unwrap_char(self->netdev, &self->stats, &self->rx_buff, 
  687.   inb(iobase+UART_RX));
  689. /* Make sure we don't stay here to long */
  690. if (boguscount++ > 32) {
  691. IRDA_DEBUG(2,__FUNCTION__ "(), breaking!n");
  692. break;
  693. }
  694. } while (inb(iobase+UART_LSR) & UART_LSR_DR);
  695. }
  697. /*
  698.  * Function irport_interrupt (irq, dev_id, regs)
  699.  *
  700.  *    Interrupt handler
  701.  */
  702. void irport_interrupt(int irq, void *dev_id, struct pt_regs *regs) 
  703. {
  704. struct net_device *dev = (struct net_device *) dev_id;
  705. struct irport_cb *self;
  706. int boguscount = 0;
  707. int iobase;
  708. int iir, lsr;
  710. if (!dev) {
  711. WARNING(__FUNCTION__ "() irq %d for unknown device.n", irq);
  712. return;
  713. }
  714. self = (struct irport_cb *) dev->priv;
  716. spin_lock(&self->lock);
  718. iobase = self->io.sir_base;
  720. iir = inb(iobase+UART_IIR) & UART_IIR_ID;
  721. while (iir) {
  722. /* Clear interrupt */
  723. lsr = inb(iobase+UART_LSR);
  725. IRDA_DEBUG(4, __FUNCTION__ 
  726.    "(), iir=%02x, lsr=%02x, iobase=%#xn", 
  727.    iir, lsr, iobase);
  729. switch (iir) {
  730. case UART_IIR_RLSI:
  731. IRDA_DEBUG(2, __FUNCTION__ "(), RLSIn");
  732. break;
  733. case UART_IIR_RDI:
  734. /* Receive interrupt */
  735. irport_receive(self);
  736. break;
  737. case UART_IIR_THRI:
  738. if (lsr & UART_LSR_THRE)
  739. /* Transmitter ready for data */
  740. irport_write_wakeup(self);
  741. break;
  742. default:
  743. IRDA_DEBUG(0, __FUNCTION__ "(), unhandled IIR=%#xn", iir);
  744. break;
  745. } 
  747. /* Make sure we don't stay here to long */
  748. if (boguscount++ > 100)
  749. break;
  751.           iir = inb(iobase + UART_IIR) & UART_IIR_ID;
  752. }
  753. spin_unlock(&self->lock);
  754. }
  756. static int irport_net_init(struct net_device *dev)
  757. {
  758. /* Set up to be a normal IrDA network device driver */
  759. irda_device_setup(dev);
  761. /* Insert overrides below this line! */
  763. return 0;
  764. }
  766. /*
  767.  * Function irport_net_open (dev)
  768.  *
  769.  *    Network device is taken up. Usually this is done by "ifconfig irda0 up" 
  770.  *   
  771.  */
  772. int irport_net_open(struct net_device *dev)
  773. {
  774. struct irport_cb *self;
  775. int iobase;
  776. char hwname[16];
  778. IRDA_DEBUG(0, __FUNCTION__ "()n");
  780. ASSERT(dev != NULL, return -1;);
  781. self = (struct irport_cb *) dev->priv;
  783. iobase = self->io.sir_base;
  785. if (request_irq(self->io.irq, self->interrupt, 0, dev->name, 
  786. (void *) dev)) {
  787. IRDA_DEBUG(0, __FUNCTION__ "(), unable to allocate irq=%dn",
  788.    self->io.irq);
  789. return -EAGAIN;
  790. }
  792. irport_start(self);
  795. /* Give self a hardware name */
  796. sprintf(hwname, "SIR @ 0x%03x", self->io.sir_base);
  798. /* 
  799.  * Open new IrLAP layer instance, now that everything should be
  800.  * initialized properly 
  801.  */
  802. self->irlap = irlap_open(dev, &self->qos, hwname);
  804. /* FIXME: change speed of dongle */
  805. /* Ready to play! */
  807. netif_start_queue(dev);
  809. MOD_INC_USE_COUNT;
  811. return 0;
  812. }
  814. /*
  815.  * Function irport_net_close (self)
  816.  *
  817.  *    Network device is taken down. Usually this is done by 
  818.  *    "ifconfig irda0 down" 
  819.  */
  820. int irport_net_close(struct net_device *dev)
  821. {
  822. struct irport_cb *self;
  823. int iobase;
  825. IRDA_DEBUG(4, __FUNCTION__ "()n");
  827. ASSERT(dev != NULL, return -1;);
  828. self = (struct irport_cb *) dev->priv;
  830. ASSERT(self != NULL, return -1;);
  832. iobase = self->io.sir_base;
  834. /* Stop device */
  835. netif_stop_queue(dev);
  837. /* Stop and remove instance of IrLAP */
  838. if (self->irlap)
  839. irlap_close(self->irlap);
  840. self->irlap = NULL;
  842. irport_stop(self);
  844. free_irq(self->io.irq, dev);
  846. MOD_DEC_USE_COUNT;
  848. return 0;
  849. }
  851. /*
  852.  * Function irport_wait_until_sent (self)
  853.  *
  854.  *    Delay exectution until finished transmitting
  855.  *
  856.  */
  857. #if 0
  858. void irport_wait_until_sent(struct irport_cb *self)
  859. {
  860. int iobase;
  862. iobase = self->io.sir_base;
  864. /* Wait until Tx FIFO is empty */
  865. while (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) {
  866. IRDA_DEBUG(2, __FUNCTION__ "(), waiting!n");
  867. current->state = TASK_INTERRUPTIBLE;
  868. schedule_timeout(MSECS_TO_JIFFIES(60));
  869. }
  870. }
  871. #endif
  873. /*
  874.  * Function irport_is_receiving (self)
  875.  *
  876.  *    Returns true is we are currently receiving data
  877.  *
  878.  */
  879. static int irport_is_receiving(struct irport_cb *self)
  880. {
  881. return (self->rx_buff.state != OUTSIDE_FRAME);
  882. }
  884. /*
  885.  * Function irport_set_dtr_rts (tty, dtr, rts)
  886.  *
  887.  *    This function can be used by dongles etc. to set or reset the status
  888.  *    of the dtr and rts lines
  889.  */
  890. static int irport_set_dtr_rts(struct net_device *dev, int dtr, int rts)
  891. {
  892. struct irport_cb *self = dev->priv;
  893. int iobase;
  895. ASSERT(self != NULL, return -1;);
  897. iobase = self->io.sir_base;
  899. if (dtr)
  900. dtr = UART_MCR_DTR;
  901. if (rts)
  902. rts = UART_MCR_RTS;
  904. outb(dtr|rts|UART_MCR_OUT2, iobase+UART_MCR);
  906. return 0;
  907. }
  909. static int irport_raw_write(struct net_device *dev, __u8 *buf, int len)
  910. {
  911. struct irport_cb *self = (struct irport_cb *) dev->priv;
  912. int actual = 0;
  913. int iobase;
  915. ASSERT(self != NULL, return -1;);
  917. iobase = self->io.sir_base;
  919. /* Tx FIFO should be empty! */
  920. if (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) {
  921. IRDA_DEBUG( 0, __FUNCTION__ "(), failed, fifo not empty!n");
  922. return -1;
  923. }
  924.         
  925. /* Fill FIFO with current frame */
  926. while (actual < len) {
  927. /* Transmit next byte */
  928. outb(buf[actual], iobase+UART_TX);
  929. actual++;
  930. }
  932. return actual;
  933. }
  935. /*
  936.  * Function irport_net_ioctl (dev, rq, cmd)
  937.  *
  938.  *    Process IOCTL commands for this device
  939.  *
  940.  */
  941. static int irport_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  942. {
  943. struct if_irda_req *irq = (struct if_irda_req *) rq;
  944. struct irport_cb *self;
  945. dongle_t *dongle;
  946. unsigned long flags;
  947. int ret = 0;
  949. ASSERT(dev != NULL, return -1;);
  951. self = dev->priv;
  953. ASSERT(self != NULL, return -1;);
  955. IRDA_DEBUG(2, __FUNCTION__ "(), %s, (cmd=0x%X)n", dev->name, cmd);
  957. /* Disable interrupts & save flags */
  958. save_flags(flags);
  959. cli();
  961. switch (cmd) {
  962. case SIOCSBANDWIDTH: /* Set bandwidth */
  963. if (!capable(CAP_NET_ADMIN))
  964. ret = -EPERM;
  965.                 else
  966. irda_task_execute(self, __irport_change_speed, NULL, 
  967.   NULL, (void *) irq->ifr_baudrate);
  968. break;
  969. case SIOCSDONGLE: /* Set dongle */
  970. if (!capable(CAP_NET_ADMIN)) {
  971. ret = -EPERM;
  972. break;
  973. }
  975. /* Initialize dongle */
  976. dongle = irda_device_dongle_init(dev, irq->ifr_dongle);
  977. if (!dongle)
  978. break;
  980. dongle->set_mode    = NULL;
  981. dongle->read        = NULL;
  982. dongle->write       = irport_raw_write;
  983. dongle->set_dtr_rts = irport_set_dtr_rts;
  985. self->dongle = dongle;
  987. /* Now initialize the dongle!  */
  988. dongle->issue->open(dongle, &self->qos);
  990. /* Reset dongle */
  991. irda_task_execute(dongle, dongle->issue->reset, NULL, NULL, 
  992.   NULL);
  993. break;
  994. case SIOCSMEDIABUSY: /* Set media busy */
  995. if (!capable(CAP_NET_ADMIN)) {
  996. ret = -EPERM;
  997. break;
  998. }
  1000. irda_device_set_media_busy(self->netdev, TRUE);
  1001. break;
  1002. case SIOCGRECEIVING: /* Check if we are receiving right now */
  1003. irq->ifr_receiving = irport_is_receiving(self);
  1004. break;
  1005. case SIOCSDTRRTS:
  1006. if (!capable(CAP_NET_ADMIN)) {
  1007. ret = -EPERM;
  1008. break;
  1009. }
  1011. irport_set_dtr_rts(dev, irq->ifr_dtr, irq->ifr_rts);
  1012. break;
  1013. default:
  1014. ret = -EOPNOTSUPP;
  1015. }
  1017. restore_flags(flags);
  1019. return ret;
  1020. }
  1022. static struct net_device_stats *irport_net_get_stats(struct net_device *dev)
  1023. {
  1024. struct irport_cb *self = (struct irport_cb *) dev->priv;
  1026. return &self->stats;
  1027. }
  1029. #ifdef MODULE
  1030. MODULE_PARM(io, "1-4i");
  1031. MODULE_PARM_DESC(io, "Base I/O addresses");
  1032. MODULE_PARM(irq, "1-4i");
  1033. MODULE_PARM_DESC(irq, "IRQ lines");
  1035. MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
  1036. MODULE_DESCRIPTION("Half duplex serial driver for IrDA SIR mode");
  1037. MODULE_LICENSE("GPL");
  1040. void cleanup_module(void)
  1041. {
  1042. irport_cleanup();
  1043. }
  1045. int init_module(void)
  1046. {
  1047. return irport_init();
  1048. }
  1049. #endif /* MODULE */