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

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

嵌入式Linux

开发平台：

Unix_Linux

ir-usb.c：源码内容
  1. /*
  2.  * USB IR Dongle driver
  3.  *
  4.  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
  5.  * Copyright (C) 2002 Gary Brubaker (xavyer@ix.netcom.com)
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This driver allows a USB IrDA device to be used as a "dumb" serial device.
  13.  * This can be useful if you do not have access to a full IrDA stack on the
  14.  * other side of the connection.  If you do have an IrDA stack on both devices,
  15.  * please use the usb-irda driver, as it contains the proper error checking and
  16.  * other goodness of a full IrDA stack.
  17.  *
  18.  * Portions of this driver were taken from drivers/net/irda/irda-usb.c, which
  19.  * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli
  20.  * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com>
  21.  *
  22.  * See Documentation/usb/usb-serial.txt for more information on using this driver
  23.  *
  24.  * 2002_Jan_14  gb
  25.  * Added module parameter to force specific number of XBOFs.
  26.  * Added ir_xbof_change().
  27.  * Reorganized read_bulk_callback error handling.
  28.  * Switched from FILL_BULK_URB() to usb_fill_bulk_urb().
  29.  *
  30.  * 2001_Nov_08  greg kh
  31.  * Changed the irda_usb_find_class_desc() function based on comments and
  32.  * code from Martin Diehl.
  33.  *
  34.  * 2001_Nov_01 greg kh
  35.  * Added support for more IrDA USB devices.
  36.  * Added support for zero packet.  Added buffer override paramater, so
  37.  * users can transfer larger packets at once if they wish.  Both patches
  38.  * came from Dag Brattli <dag@obexcode.com>.
  39.  *
  40.  * 2001_Oct_07 greg kh
  41.  * initial version released.
  42.  */
  44. #include <linux/config.h>
  45. #include <linux/kernel.h>
  46. #include <linux/sched.h>
  47. #include <linux/signal.h>
  48. #include <linux/errno.h>
  49. #include <linux/poll.h>
  50. #include <linux/init.h>
  51. #include <linux/slab.h>
  52. #include <linux/fcntl.h>
  53. #include <linux/tty.h>
  54. #include <linux/tty_driver.h>
  55. #include <linux/tty_flip.h>
  56. #include <linux/module.h>
  57. #include <linux/spinlock.h>
  58. #include <linux/usb.h>
  59. #include <net/irda/irda-usb.h>
  61. #ifdef CONFIG_USB_SERIAL_DEBUG
  62. static int debug = 1;
  63. #else
  64. static int debug;
  65. #endif
  67. #include "usb-serial.h"
  69. /*
  70.  * Version Information
  71.  */
  72. #define DRIVER_VERSION "v0.4"
  73. #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
  74. #define DRIVER_DESC "USB IR Dongle driver"
  76. /* if overridden by the user, then use their value for the size of the read and
  77.  * write urbs */
  78. static int buffer_size = 0;
  79. /* if overridden by the user, then use the specified number of XBOFs */
  80. static int xbof = -1;
  82. static int  ir_startup (struct usb_serial *serial);
  83. static int  ir_open (struct usb_serial_port *port, struct file *filep);
  84. static void ir_close (struct usb_serial_port *port, struct file *filep);
  85. static int  ir_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
  86. static void ir_write_bulk_callback (struct urb *urb);
  87. static void ir_read_bulk_callback (struct urb *urb);
  88. static void ir_set_termios (struct usb_serial_port *port, struct termios *old_termios);
  90. static u8 ir_baud = 0;
  91. static u8 ir_xbof = 0;
  92. static u8 ir_add_bof = 0;
  94. static __devinitdata struct usb_device_id id_table [] = {
  95. { USB_DEVICE(0x050f, 0x0180) }, /* KC Technology, KC-180 */
  96. { USB_DEVICE(0x08e9, 0x0100) }, /* XTNDAccess */
  97. { USB_DEVICE(0x09c4, 0x0011) }, /* ACTiSys ACT-IR2000U */
  98. { USB_INTERFACE_INFO (USB_CLASS_APP_SPEC, USB_CLASS_IRDA, 0) },
  99. { } /* Terminating entry */
  100. };
  102. MODULE_DEVICE_TABLE (usb, id_table);
  105. struct usb_serial_device_type ir_device = {
  106. name: "IR Dongle",
  107. id_table: id_table,
  108. needs_interrupt_in: MUST_HAVE,
  109. needs_bulk_in: MUST_HAVE,
  110. needs_bulk_out: MUST_HAVE,
  111. num_interrupt_in: 1,
  112. num_bulk_in: 1,
  113. num_bulk_out: 1,
  114. num_ports: 1,
  115. set_termios: ir_set_termios,
  116. startup: ir_startup,
  117. open: ir_open,
  118. close: ir_close,
  119. write: ir_write,
  120. write_bulk_callback: ir_write_bulk_callback,
  121. read_bulk_callback: ir_read_bulk_callback,
  122. };
  124. static inline void irda_usb_dump_class_desc(struct irda_class_desc *desc)
  125. {
  126. dbg("bLength=%x", desc->bLength);
  127. dbg("bDescriptorType=%x", desc->bDescriptorType);
  128. dbg("bcdSpecRevision=%x", desc->bcdSpecRevision); 
  129. dbg("bmDataSize=%x", desc->bmDataSize);
  130. dbg("bmWindowSize=%x", desc->bmWindowSize);
  131. dbg("bmMinTurnaroundTime=%d", desc->bmMinTurnaroundTime);
  132. dbg("wBaudRate=%x", desc->wBaudRate);
  133. dbg("bmAdditionalBOFs=%x", desc->bmAdditionalBOFs);
  134. dbg("bIrdaRateSniff=%x", desc->bIrdaRateSniff);
  135. dbg("bMaxUnicastList=%x", desc->bMaxUnicastList);
  136. }
  138. /*------------------------------------------------------------------*/
  139. /*
  140.  * Function irda_usb_find_class_desc(dev, ifnum)
  141.  *
  142.  *    Returns instance of IrDA class descriptor, or NULL if not found
  143.  *
  144.  * The class descriptor is some extra info that IrDA USB devices will
  145.  * offer to us, describing their IrDA characteristics. We will use that in
  146.  * irda_usb_init_qos()
  147.  *
  148.  * Based on the same function in drivers/net/irda/irda-usb.c
  149.  */
  150. static struct irda_class_desc *irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum)
  151. {
  152. struct irda_class_desc *desc;
  153. int ret;
  155. desc = kmalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
  156. if (desc == NULL) 
  157. return NULL;
  158. memset(desc, 0, sizeof(struct irda_class_desc));
  160. ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
  161. IU_REQ_GET_CLASS_DESC,
  162. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  163. 0, ifnum, desc, sizeof(*desc), MSECS_TO_JIFFIES(500));
  165. dbg("%s -  ret=%d", __FUNCTION__, ret);
  166. if (ret < sizeof(*desc)) {
  167. dbg("%s - class descriptor read %s (%d)",
  168. __FUNCTION__, 
  169. (ret<0) ? "failed" : "too short",
  170. ret);
  171. goto error;
  172. }
  173. if (desc->bDescriptorType != USB_DT_IRDA) {
  174. dbg("%s - bad class descriptor type", __FUNCTION__);
  175. goto error;
  176. }
  178. irda_usb_dump_class_desc(desc);
  179. return desc;
  180. error:
  181. kfree(desc);
  182. return NULL;
  183. }
  186. static u8 ir_xbof_change(u8 xbof)
  187. {
  188. u8 result;
  189. /* reference irda-usb.c */
  190. switch(xbof) {
  191. case 48: result = 0x10; break;
  192. case 28:
  193. case 24: result = 0x20; break;
  194. default:
  195. case 12: result = 0x30; break;
  196. case  5:
  197. case  6: result = 0x40; break;
  198. case  3: result = 0x50; break;
  199. case  2: result = 0x60; break;
  200. case  1: result = 0x70; break;
  201. case  0: result = 0x80; break;
  202. }
  203. return(result);
  204. }
  207. static int ir_startup (struct usb_serial *serial)
  208. {
  209. struct irda_class_desc *irda_desc;
  211. irda_desc = irda_usb_find_class_desc (serial->dev, 0);
  212. if (irda_desc == NULL) {
  213. err ("IRDA class descriptor not found, device not bound");
  214. return -ENODEV;
  215. }
  217. dbg ("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s",
  218. __FUNCTION__,
  219. (irda_desc->wBaudRate & 0x0001) ? " 2400"    : "",
  220. (irda_desc->wBaudRate & 0x0002) ? " 9600"    : "",
  221. (irda_desc->wBaudRate & 0x0004) ? " 19200"   : "",
  222. (irda_desc->wBaudRate & 0x0008) ? " 38400"   : "",
  223. (irda_desc->wBaudRate & 0x0010) ? " 57600"   : "",
  224. (irda_desc->wBaudRate & 0x0020) ? " 115200"  : "",
  225. (irda_desc->wBaudRate & 0x0040) ? " 576000"  : "",
  226. (irda_desc->wBaudRate & 0x0080) ? " 1152000" : "",
  227. (irda_desc->wBaudRate & 0x0100) ? " 4000000" : "");
  229. switch( irda_desc->bmAdditionalBOFs ) {
  230. case 0x01: ir_add_bof = 48; break;
  231. case 0x02: ir_add_bof = 24; break;
  232. case 0x04: ir_add_bof = 12; break;
  233. case 0x08: ir_add_bof =  6; break;
  234. case 0x10: ir_add_bof =  3; break;
  235. case 0x20: ir_add_bof =  2; break;
  236. case 0x40: ir_add_bof =  1; break;
  237. case 0x80: ir_add_bof =  0; break;
  238. default:
  239. }
  241. kfree (irda_desc);
  243. return 0;
  244. }
  246. static int ir_open (struct usb_serial_port *port, struct file *filp)
  247. {
  248. struct usb_serial *serial = port->serial;
  249. char *buffer;
  250. int result = 0;
  252. if (port_paranoia_check (port, __FUNCTION__))
  253. return -ENODEV;
  255. dbg("%s - port %d", __FUNCTION__, port->number);
  257. down (&port->sem);
  259. ++port->open_count;
  260. MOD_INC_USE_COUNT;
  262. if (!port->active) {
  263. port->active = 1;
  265. if (buffer_size) {
  266. /* override the default buffer sizes */
  267. buffer = kmalloc (buffer_size, GFP_KERNEL);
  268. if (!buffer) {
  269. err ("%s - out of memory.", __FUNCTION__);
  270. return -ENOMEM;
  271. }
  272. kfree (port->read_urb->transfer_buffer);
  273. port->read_urb->transfer_buffer = buffer;
  274. port->read_urb->transfer_buffer_length = buffer_size;
  276. buffer = kmalloc (buffer_size, GFP_KERNEL);
  277. if (!buffer) {
  278. err ("%s - out of memory.", __FUNCTION__);
  279. return -ENOMEM;
  280. }
  281. kfree (port->write_urb->transfer_buffer);
  282. port->write_urb->transfer_buffer = buffer;
  283. port->write_urb->transfer_buffer_length = buffer_size;
  284. port->bulk_out_size = buffer_size;
  285. }
  287. /* Start reading from the device */
  288. usb_fill_bulk_urb (
  289. port->read_urb,
  290. serial->dev, 
  291. usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
  292. port->read_urb->transfer_buffer,
  293. port->read_urb->transfer_buffer_length,
  294. ir_read_bulk_callback,
  295. port);
  296. port->read_urb->transfer_flags = USB_QUEUE_BULK;
  297. result = usb_submit_urb(port->read_urb);
  298. if (result)
  299. err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
  300. }
  302. up (&port->sem);
  304. return result;
  305. }
  307. static void ir_close (struct usb_serial_port *port, struct file * filp)
  308. {
  309. struct usb_serial *serial;
  311. if (port_paranoia_check (port, __FUNCTION__))
  312. return;
  314. dbg("%s - port %d", __FUNCTION__, port->number);
  315.  
  316. serial = get_usb_serial (port, __FUNCTION__);
  317. if (!serial)
  318. return;
  320. down (&port->sem);
  322. --port->open_count;
  324. if (port->open_count <= 0) {
  325. if (serial->dev) {
  326. /* shutdown our bulk read */
  327. usb_unlink_urb (port->read_urb);
  328. }
  329. port->active = 0;
  330. port->open_count = 0;
  332. }
  333. up (&port->sem);
  334. MOD_DEC_USE_COUNT;
  335. }
  337. static int ir_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count)
  338. {
  339. unsigned char *transfer_buffer;
  340. int result;
  341. int transfer_size;
  343. dbg("%s - port = %d, count = %d", __FUNCTION__, port->number, count);
  345. if (!port->tty) {
  346. err ("%s - no tty???", __FUNCTION__);
  347. return 0;
  348. }
  350. if (count == 0)
  351. return 0;
  353. if (port->write_urb->status == -EINPROGRESS) {
  354. dbg ("%s - already writing", __FUNCTION__);
  355. return 0;
  356. }
  358. transfer_buffer = port->write_urb->transfer_buffer;
  359. transfer_size = min(count, port->bulk_out_size - 1);
  361. /*
  362.  * The first byte of the packet we send to the device contains an
  363.  * inband header which indicates an additional number of BOFs and
  364.  * a baud rate change.
  365.  *
  366.  * See section 5.4.2.2 of the USB IrDA spec.
  367.  */
  368. *transfer_buffer = ir_xbof | ir_baud;
  369. ++transfer_buffer;
  371. if (from_user) {
  372. if (copy_from_user (transfer_buffer, buf, transfer_size))
  373. return -EFAULT;
  374. } else {
  375. memcpy (transfer_buffer, buf, transfer_size);
  376. }
  378. usb_fill_bulk_urb (
  379. port->write_urb,
  380. port->serial->dev,
  381. usb_sndbulkpipe(port->serial->dev,
  382. port->bulk_out_endpointAddress),
  383. port->write_urb->transfer_buffer,
  384. transfer_size + 1,
  385. ir_write_bulk_callback,
  386. port);
  388. port->write_urb->transfer_flags
  389. = USB_QUEUE_BULK
  390. | USB_ZERO_PACKET;
  392. result = usb_submit_urb (port->write_urb);
  393. if (result)
  394. err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
  395. else
  396. result = transfer_size;
  398. return result;
  399. }
  401. static void ir_write_bulk_callback (struct urb *urb)
  402. {
  403. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  405. if (port_paranoia_check (port, __FUNCTION__))
  406. return;
  408. dbg("%s - port %d", __FUNCTION__, port->number);
  410. if (urb->status) {
  411. dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
  412. return;
  413. }
  415. usb_serial_debug_data (
  416. __FILE__,
  417. __FUNCTION__,
  418. urb->actual_length,
  419. urb->transfer_buffer);
  421. queue_task(&port->tqueue, &tq_immediate);
  422. mark_bh(IMMEDIATE_BH);
  424. return;
  425. }
  427. static void ir_read_bulk_callback (struct urb *urb)
  428. {
  429. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  430. struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
  431. struct tty_struct *tty;
  432. unsigned char *data = urb->transfer_buffer;
  433. int result;
  435. if (port_paranoia_check (port, __FUNCTION__))
  436. return;
  438. dbg("%s - port %d", __FUNCTION__, port->number);
  440. if (!serial) {
  441. dbg("%s - bad serial pointer, exiting", __FUNCTION__);
  442. return;
  443. }
  445. if (!port->active) {
  446. dbg("%s - port closed.", __FUNCTION__);
  447. return;
  448. }
  450. switch (urb->status) {
  452. case 0: /* Successful */
  454. /*
  455.  * The first byte of the packet we get from the device
  456.  * contains a busy indicator and baud rate change.
  457.  * See section 5.4.1.2 of the USB IrDA spec.
  458.  */
  459. if((*data & 0x0f) > 0) ir_baud = *data & 0x0f;
  461. usb_serial_debug_data (
  462. __FILE__,
  463. __FUNCTION__,
  464. urb->actual_length,
  465. data);
  467. /*
  468.  * Bypass flip-buffers, and feed the ldisc directly
  469.  * due to our potentally large buffer size.  Since we
  470.  * used to set low_latency, this is exactly what the
  471.  * tty layer did anyway :)
  472.  */
  473. tty = port->tty;
  475. tty->ldisc.receive_buf(
  476. tty,
  477. data+1,
  478. NULL,
  479. urb->actual_length-1);
  481. /*
  482.  * No break here.
  483.  * We want to resubmit the urb so we can read
  484.  * again.
  485.  */
  487. case -EPROTO: /* taking inspiration from pl2303.c */
  489. /* Continue trying to always read */
  490. usb_fill_bulk_urb (
  491. port->read_urb,
  492. serial->dev, 
  493. usb_rcvbulkpipe(serial->dev,
  494. port->bulk_in_endpointAddress),
  495. port->read_urb->transfer_buffer,
  496. port->read_urb->transfer_buffer_length,
  497. ir_read_bulk_callback,
  498. port);
  500. port->read_urb->transfer_flags = USB_QUEUE_BULK;
  502. result = usb_submit_urb(port->read_urb);
  504. if (result)
  505. err("%s - failed resubmitting read urb, error %d",
  506. __FUNCTION__, 
  507. result);
  509. break ;
  511. default:
  512. dbg("%s - nonzero read bulk status received: %d",
  513. __FUNCTION__, 
  514. urb->status);
  515. break ;
  517. }
  519. return;
  520. }
  522. static void ir_set_termios (struct usb_serial_port *port, struct termios *old_termios)
  523. {
  524. unsigned char *transfer_buffer;
  525. unsigned int cflag;
  526. int result;
  528. dbg("%s - port %d", __FUNCTION__, port->number);
  530. if ((!port->tty) || (!port->tty->termios)) {
  531. dbg("%s - no tty structures", __FUNCTION__);
  532. return;
  533. }
  535. cflag = port->tty->termios->c_cflag;
  536. /* check that they really want us to change something */
  537. if (old_termios) {
  538. if ((cflag == old_termios->c_cflag) &&
  539.     (RELEVANT_IFLAG(port->tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) {
  540. dbg("%s - nothing to change...", __FUNCTION__);
  541. return;
  542. }
  543. }
  545. /* All we can change is the baud rate */
  546. if (cflag & CBAUD) {
  548. dbg ("%s - asking for baud %d",
  549. __FUNCTION__,
  550. tty_get_baud_rate(port->tty));
  552. /* 
  553.  * FIXME, we should compare the baud request against the
  554.  * capability stated in the IR header that we got in the
  555.  * startup funtion.
  556.  */
  557. switch (cflag & CBAUD) {
  558. case B2400:    ir_baud = SPEED_2400;    break;
  559. default:
  560. case B9600:    ir_baud = SPEED_9600;    break;
  561. case B19200:   ir_baud = SPEED_19200;   break;
  562. case B38400:   ir_baud = SPEED_38400;   break;
  563. case B57600:   ir_baud = SPEED_57600;   break;
  564. case B115200:  ir_baud = SPEED_115200;  break;
  565. case B576000:  ir_baud = SPEED_576000;  break;
  566. case B1152000: ir_baud = SPEED_1152000; break;
  567. case B4000000: ir_baud = SPEED_4000000; break;
  568. }
  570. if (xbof == -1) {
  571. ir_xbof = ir_xbof_change(ir_add_bof);
  572. } else {
  573. ir_xbof = ir_xbof_change(xbof) ;
  574. }
  576. /* Notify the tty driver that the termios have changed. */
  577. port->tty->ldisc.set_termios(port->tty, NULL);
  579. /* FIXME need to check to see if our write urb is busy right
  580.  * now, or use a urb pool.
  581.  *
  582.  * send the baud change out on an "empty" data packet
  583.  */
  584. transfer_buffer = port->write_urb->transfer_buffer;
  585. *transfer_buffer = ir_xbof | ir_baud;
  587. usb_fill_bulk_urb (
  588. port->write_urb,
  589. port->serial->dev,
  590. usb_sndbulkpipe(port->serial->dev,
  591. port->bulk_out_endpointAddress),
  592. port->write_urb->transfer_buffer,
  593. 1,
  594. ir_write_bulk_callback,
  595. port);
  597. port->write_urb->transfer_flags
  598. = USB_QUEUE_BULK
  599. | USB_ZERO_PACKET;
  601. result = usb_submit_urb (port->write_urb);
  602. if (result)
  603. err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
  604. }
  605. return;
  606. }
  609. static int __init ir_init (void)
  610. {
  611. usb_serial_register (&ir_device);
  612. info(DRIVER_DESC " " DRIVER_VERSION);
  613. return 0;
  614. }
  617. static void __exit ir_exit (void)
  618. {
  619. usb_serial_deregister (&ir_device);
  620. }
  623. module_init(ir_init);
  624. module_exit(ir_exit);
  626. MODULE_AUTHOR(DRIVER_AUTHOR);
  627. MODULE_DESCRIPTION(DRIVER_DESC);
  628. MODULE_LICENSE("GPL");
  630. MODULE_PARM(debug, "i");
  631. MODULE_PARM_DESC(debug, "Debug enabled or not");
  632. MODULE_PARM(xbof, "i");
  633. MODULE_PARM_DESC(xbof, "Force specific number of XBOFs");
  634. MODULE_PARM(buffer_size, "i");
  635. MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers");