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

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

嵌入式Linux

开发平台：

Unix_Linux

belkin_sa.c：源码内容
  1. /*
  2.  * Belkin USB Serial Adapter Driver
  3.  *
  4.  *  Copyright (C) 2000
  5.  *      William Greathouse (wgreathouse@smva.com)
  6.  *
  7.  *  This program is largely derived from work by the linux-usb group
  8.  *  and associated source files.  Please see the usb/serial files for
  9.  *  individual credits and copyrights.
  10.  *  
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  * See Documentation/usb/usb-serial.txt for more information on using this driver
  17.  *
  18.  * TODO:
  19.  * -- Add true modem contol line query capability.  Currently we track the
  20.  *    states reported by the interrupt and the states we request.
  21.  * -- Add error reporting back to application for UART error conditions.
  22.  *    Just point me at how to implement this and I'll do it. I've put the
  23.  *    framework in, but haven't analyzed the "tty_flip" interface yet.
  24.  * -- Add support for flush commands
  25.  * -- Add everything that is missing :)
  26.  *
  27.  * 30-May-2001 gkh
  28.  * switched from using spinlock to a semaphore, which fixes lots of problems.
  29.  *
  30.  * 08-Apr-2001 gb
  31.  * - Identify version on module load.
  32.  *
  33.  * 12-Mar-2001 gkh
  34.  * - Added support for the GoHubs GO-COM232 device which is the same as the
  35.  *   Peracom device.
  36.  *
  37.  * 06-Nov-2000 gkh
  38.  * - Added support for the old Belkin and Peracom devices.
  39.  * - Made the port able to be opened multiple times.
  40.  * - Added some defaults incase the line settings are things these devices
  41.  *   can't support. 
  42.  *
  43.  * 18-Oct-2000 William Greathouse
  44.  *    Released into the wild (linux-usb-devel)
  45.  *
  46.  * 17-Oct-2000 William Greathouse
  47.  *    Add code to recognize firmware version and set hardware flow control
  48.  *    appropriately.  Belkin states that firmware prior to 3.05 does not
  49.  *    operate correctly in hardware handshake mode.  I have verified this
  50.  *    on firmware 2.05 -- for both RTS and DTR input flow control, the control
  51.  *    line is not reset.  The test performed by the Belkin Win* driver is
  52.  *    to enable hardware flow control for firmware 2.06 or greater and
  53.  *    for 1.00 or prior.  I am only enabling for 2.06 or greater.
  54.  *
  55.  * 12-Oct-2000 William Greathouse
  56.  *    First cut at supporting Belkin USB Serial Adapter F5U103
  57.  *    I did not have a copy of the original work to support this
  58.  *    adapter, so pardon any stupid mistakes.  All of the information
  59.  *    I am using to write this driver was acquired by using a modified
  60.  *    UsbSnoop on Windows2000 and from examining the other USB drivers.
  61.  */
  63. #include <linux/config.h>
  64. #include <linux/kernel.h>
  65. #include <linux/sched.h>
  66. #include <linux/signal.h>
  67. #include <linux/errno.h>
  68. #include <linux/poll.h>
  69. #include <linux/init.h>
  70. #include <linux/slab.h>
  71. #include <linux/fcntl.h>
  72. #include <linux/tty.h>
  73. #include <linux/tty_driver.h>
  74. #include <linux/tty_flip.h>
  75. #include <linux/module.h>
  76. #include <linux/spinlock.h>
  77. #include <linux/usb.h>
  79. #ifdef CONFIG_USB_SERIAL_DEBUG
  80.   static int debug = 1;
  81. #else
  82.   static int debug;
  83. #endif
  85. #include "usb-serial.h"
  86. #include "belkin_sa.h"
  88. /*
  89.  * Version Information
  90.  */
  91. #define DRIVER_VERSION "v1.1"
  92. #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
  93. #define DRIVER_DESC "USB Belkin Serial converter driver"
  95. /* function prototypes for a Belkin USB Serial Adapter F5U103 */
  96. static int  belkin_sa_startup (struct usb_serial *serial);
  97. static void belkin_sa_shutdown (struct usb_serial *serial);
  98. static int  belkin_sa_open (struct usb_serial_port *port, struct file *filp);
  99. static void belkin_sa_close (struct usb_serial_port *port, struct file *filp);
  100. static void belkin_sa_read_int_callback (struct urb *urb);
  101. static void belkin_sa_set_termios (struct usb_serial_port *port, struct termios * old);
  102. static int  belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
  103. static void belkin_sa_break_ctl (struct usb_serial_port *port, int break_state );
  106. static __devinitdata struct usb_device_id id_table_combined [] = {
  107. { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
  108. { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
  109. { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
  110. { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
  111. { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
  112. { } /* Terminating entry */
  113. };
  115. static __devinitdata struct usb_device_id belkin_dockstation_table [] = {
  116. { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
  117. { } /* Terminating entry */
  118. };
  120. static __devinitdata struct usb_device_id belkin_sa_table [] = {
  121. { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
  122. { } /* Terminating entry */
  123. };
  125. static __devinitdata struct usb_device_id belkin_old_table [] = {
  126. { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
  127. { } /* Terminating entry */
  128. };
  130. static __devinitdata struct usb_device_id peracom_table [] = {
  131. { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
  132. { } /* Terminating entry */
  133. };
  135. static __devinitdata struct usb_device_id gocom232_table [] = {
  136. { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
  137. { } /* Terminating entry */
  138. };
  140. MODULE_DEVICE_TABLE (usb, id_table_combined);
  142. /* All of the device info needed for the Belkin dockstation serial converter */
  143. static struct usb_serial_device_type belkin_dockstation_device = {
  144. name: "Belkin F5U120-PC USB Serial Adapter",
  145. id_table: belkin_dockstation_table, /* the Belkin F5U103 device */
  146. needs_interrupt_in: MUST_HAVE, /* this device must have an interrupt in endpoint */
  147. needs_bulk_in: MUST_HAVE, /* this device must have a bulk in endpoint */
  148. needs_bulk_out: MUST_HAVE, /* this device must have a bulk out endpoint */
  149. num_interrupt_in: 1,
  150. num_bulk_in: 1,
  151. num_bulk_out: 1,
  152. num_ports: 1,
  153. open: belkin_sa_open,
  154. close: belkin_sa_close,
  155. read_int_callback: belkin_sa_read_int_callback, /* How we get the status info */
  156. ioctl: belkin_sa_ioctl,
  157. set_termios: belkin_sa_set_termios,
  158. break_ctl: belkin_sa_break_ctl,
  159. startup: belkin_sa_startup,
  160. shutdown: belkin_sa_shutdown,
  161. };
  163. /* All of the device info needed for the Belkin serial converter */
  164. static struct usb_serial_device_type belkin_sa_device = {
  165. name: "Belkin F5U103 USB Serial Adapter",
  166. id_table: belkin_sa_table, /* the Belkin F5U103 device */
  167. needs_interrupt_in: MUST_HAVE, /* this device must have an interrupt in endpoint */
  168. needs_bulk_in: MUST_HAVE, /* this device must have a bulk in endpoint */
  169. needs_bulk_out: MUST_HAVE, /* this device must have a bulk out endpoint */
  170. num_interrupt_in: 1,
  171. num_bulk_in: 1,
  172. num_bulk_out: 1,
  173. num_ports: 1,
  174. open: belkin_sa_open,
  175. close: belkin_sa_close,
  176. read_int_callback: belkin_sa_read_int_callback, /* How we get the status info */
  177. ioctl: belkin_sa_ioctl,
  178. set_termios: belkin_sa_set_termios,
  179. break_ctl: belkin_sa_break_ctl,
  180. startup: belkin_sa_startup,
  181. shutdown: belkin_sa_shutdown,
  182. };
  185. /* This driver also supports the "old" school Belkin single port adaptor */
  186. static struct usb_serial_device_type belkin_old_device = {
  187. name: "Belkin USB Serial Adapter",
  188. id_table: belkin_old_table, /* the old Belkin device */
  189. needs_interrupt_in: MUST_HAVE, /* this device must have an interrupt in endpoint */
  190. needs_bulk_in: MUST_HAVE, /* this device must have a bulk in endpoint */
  191. needs_bulk_out: MUST_HAVE, /* this device must have a bulk out endpoint */
  192. num_interrupt_in: 1,
  193. num_bulk_in: 1,
  194. num_bulk_out: 1,
  195. num_ports: 1,
  196. open: belkin_sa_open,
  197. close: belkin_sa_close,
  198. read_int_callback: belkin_sa_read_int_callback, /* How we get the status info */
  199. ioctl: belkin_sa_ioctl,
  200. set_termios: belkin_sa_set_termios,
  201. break_ctl: belkin_sa_break_ctl,
  202. startup: belkin_sa_startup,
  203. shutdown: belkin_sa_shutdown,
  204. };
  206. /* this driver also works for the Peracom single port adapter */
  207. static struct usb_serial_device_type peracom_device = {
  208. name: "Peracom single port USB Serial Adapter",
  209. id_table: peracom_table, /* the Peracom device */
  210. needs_interrupt_in: MUST_HAVE, /* this device must have an interrupt in endpoint */
  211. needs_bulk_in: MUST_HAVE, /* this device must have a bulk in endpoint */
  212. needs_bulk_out: MUST_HAVE, /* this device must have a bulk out endpoint */
  213. num_interrupt_in: 1,
  214. num_bulk_in: 1,
  215. num_bulk_out: 1,
  216. num_ports: 1,
  217. open: belkin_sa_open,
  218. close: belkin_sa_close,
  219. read_int_callback: belkin_sa_read_int_callback, /* How we get the status info */
  220. ioctl: belkin_sa_ioctl,
  221. set_termios: belkin_sa_set_termios,
  222. break_ctl: belkin_sa_break_ctl,
  223. startup: belkin_sa_startup,
  224. shutdown: belkin_sa_shutdown,
  225. };
  227. /* the GoHubs Go-COM232 device is the same as the Peracom single port adapter */
  228. static struct usb_serial_device_type gocom232_device = {
  229. name: "GO-COM232 USB Serial Converter",
  230. id_table: gocom232_table, /* the GO-COM232 device */
  231. needs_interrupt_in: MUST_HAVE, /* this device must have an interrupt in endpoint */
  232. needs_bulk_in: MUST_HAVE, /* this device must have a bulk in endpoint */
  233. needs_bulk_out: MUST_HAVE, /* this device must have a bulk out endpoint */
  234. num_interrupt_in: 1,
  235. num_bulk_in: 1,
  236. num_bulk_out: 1,
  237. num_ports: 1,
  238. open: belkin_sa_open,
  239. close: belkin_sa_close,
  240. read_int_callback: belkin_sa_read_int_callback, /* How we get the status info */
  241. ioctl: belkin_sa_ioctl,
  242. set_termios: belkin_sa_set_termios,
  243. break_ctl: belkin_sa_break_ctl,
  244. startup: belkin_sa_startup,
  245. shutdown: belkin_sa_shutdown,
  246. };
  249. struct belkin_sa_private {
  250. unsigned long control_state;
  251. unsigned char last_lsr;
  252. unsigned char last_msr;
  253. int bad_flow_control;
  254. };
  257. /*
  258.  * ***************************************************************************
  259.  * Belkin USB Serial Adapter F5U103 specific driver functions
  260.  * ***************************************************************************
  261.  */
  263. #define WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */
  265. /* assumes that struct usb_serial *serial is available */
  266. #define BSA_USB_CMD(c,v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 
  267.     (c), BELKIN_SA_SET_REQUEST_TYPE, 
  268.     (v), 0, NULL, 0, WDR_TIMEOUT)
  270. /* do some startup allocations not currently performed by usb_serial_probe() */
  271. static int belkin_sa_startup (struct usb_serial *serial)
  272. {
  273. struct usb_device *dev = serial->dev;
  274. struct belkin_sa_private *priv;
  276. /* allocate the private data structure */
  277. serial->port->private = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
  278. if (!serial->port->private)
  279. return (-1); /* error */
  280. priv = (struct belkin_sa_private *)serial->port->private;
  281. /* set initial values for control structures */
  282. priv->control_state = 0;
  283. priv->last_lsr = 0;
  284. priv->last_msr = 0;
  285. /* see comments at top of file */
  286. priv->bad_flow_control = (dev->descriptor.bcdDevice <= 0x0206) ? 1 : 0;
  287. info("bcdDevice: %04x, bfc: %d", dev->descriptor.bcdDevice, priv->bad_flow_control);
  289. init_waitqueue_head(&serial->port->write_wait);
  291. return (0);
  292. }
  295. static void belkin_sa_shutdown (struct usb_serial *serial)
  296. {
  297. int i;
  299. dbg (__FUNCTION__);
  301. /* stop reads and writes on all ports */
  302. for (i=0; i < serial->num_ports; ++i) {
  303. while (serial->port[i].open_count > 0) {
  304. belkin_sa_close (&serial->port[i], NULL);
  305. }
  306. /* My special items, the standard routines free my urbs */
  307. if (serial->port[i].private)
  308. kfree(serial->port[i].private);
  309. }
  310. }
  313. static int  belkin_sa_open (struct usb_serial_port *port, struct file *filp)
  314. {
  315. int retval = 0;
  317. dbg(__FUNCTION__" port %d", port->number);
  319. down (&port->sem);
  321. ++port->open_count;
  322. MOD_INC_USE_COUNT;
  324. if (!port->active) {
  325. port->active = 1;
  327. /*Start reading from the device*/
  328. /* TODO: Look at possibility of submitting mulitple URBs to device to
  329.  *       enhance buffering.  Win trace shows 16 initial read URBs.
  330.  */
  331. port->read_urb->dev = port->serial->dev;
  332. retval = usb_submit_urb(port->read_urb);
  333. if (retval) {
  334. err("usb_submit_urb(read bulk) failed");
  335. goto exit;
  336. }
  338. port->interrupt_in_urb->dev = port->serial->dev;
  339. retval = usb_submit_urb(port->interrupt_in_urb);
  340. if (retval)
  341. err(" usb_submit_urb(read int) failed");
  342. }
  344. exit:
  345. up (&port->sem);
  347. return retval;
  348. } /* belkin_sa_open */
  351. static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
  352. {
  353. struct usb_serial *serial;
  355. if (port_paranoia_check (port, __FUNCTION__))
  356. return;
  358. serial = get_usb_serial (port, __FUNCTION__);
  359. if (!serial)
  360. return;
  362. dbg(__FUNCTION__" port %d", port->number);
  364. down (&port->sem);
  366. --port->open_count;
  368. if (port->open_count <= 0) {
  369. if (serial->dev) {
  370. /* shutdown our bulk reads and writes */
  371. usb_unlink_urb (port->write_urb);
  372. usb_unlink_urb (port->read_urb);
  373. usb_unlink_urb (port->interrupt_in_urb);
  374. }
  375. port->active = 0;
  376. }
  378. up (&port->sem);
  379. MOD_DEC_USE_COUNT;
  380. } /* belkin_sa_close */
  383. static void belkin_sa_read_int_callback (struct urb *urb)
  384. {
  385. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  386. struct belkin_sa_private *priv;
  387. struct usb_serial *serial;
  388. unsigned char *data = urb->transfer_buffer;
  390. /* the urb might have been killed. */
  391. if (urb->status)
  392. return;
  394. if (port_paranoia_check (port, __FUNCTION__)) return;
  396. serial = port->serial;
  397. if (serial_paranoia_check (serial, __FUNCTION__)) return;
  399. usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
  401. /* Handle known interrupt data */
  402. /* ignore data[0] and data[1] */
  404. priv = (struct belkin_sa_private *)port->private;
  405. priv->last_msr = data[BELKIN_SA_MSR_INDEX];
  407. /* Record Control Line states */
  408. if (priv->last_msr & BELKIN_SA_MSR_DSR)
  409. priv->control_state |= TIOCM_DSR;
  410. else
  411. priv->control_state &= ~TIOCM_DSR;
  413. if (priv->last_msr & BELKIN_SA_MSR_CTS)
  414. priv->control_state |= TIOCM_CTS;
  415. else
  416. priv->control_state &= ~TIOCM_CTS;
  418. if (priv->last_msr & BELKIN_SA_MSR_RI)
  419. priv->control_state |= TIOCM_RI;
  420. else
  421. priv->control_state &= ~TIOCM_RI;
  423. if (priv->last_msr & BELKIN_SA_MSR_CD)
  424. priv->control_state |= TIOCM_CD;
  425. else
  426. priv->control_state &= ~TIOCM_CD;
  428. /* Now to report any errors */
  429. priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
  430. #if 0
  431. /*
  432.  * fill in the flip buffer here, but I do not know the relation
  433.  * to the current/next receive buffer or characters.  I need
  434.  * to look in to this before committing any code.
  435.  */
  436. if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
  437. tty = port->tty;
  438. /* Overrun Error */
  439. if (priv->last_lsr & BELKIN_SA_LSR_OE) {
  440. }
  441. /* Parity Error */
  442. if (priv->last_lsr & BELKIN_SA_LSR_PE) {
  443. }
  444. /* Framing Error */
  445. if (priv->last_lsr & BELKIN_SA_LSR_FE) {
  446. }
  447. /* Break Indicator */
  448. if (priv->last_lsr & BELKIN_SA_LSR_BI) {
  449. }
  450. }
  451. #endif
  453. /* INT urbs are automatically re-submitted */
  454. }
  456. static void belkin_sa_set_termios (struct usb_serial_port *port, struct termios *old_termios)
  457. {
  458. struct usb_serial *serial = port->serial;
  459. struct belkin_sa_private *priv = (struct belkin_sa_private *)port->private;
  460. unsigned int iflag = port->tty->termios->c_iflag;
  461. unsigned int cflag = port->tty->termios->c_cflag;
  462. unsigned int old_iflag = old_termios->c_iflag;
  463. unsigned int old_cflag = old_termios->c_cflag;
  464. __u16 urb_value = 0; /* Will hold the new flags */
  466. /* Set the baud rate */
  467. if( (cflag&CBAUD) != (old_cflag&CBAUD) ) {
  468. /* reassert DTR and (maybe) RTS on transition from B0 */
  469. if( (old_cflag&CBAUD) == B0 ) {
  470. priv->control_state |= (TIOCM_DTR|TIOCM_RTS);
  471. if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
  472. err("Set DTR error");
  473. /* don't set RTS if using hardware flow control */
  474. if (!(old_cflag&CRTSCTS) )
  475. if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 1) < 0)
  476. err("Set RTS error");
  477. }
  479. switch(cflag & CBAUD) {
  480. case B0: /* handled below */ break;
  481. case B300: urb_value = BELKIN_SA_BAUD(300); break;
  482. case B600: urb_value = BELKIN_SA_BAUD(600); break;
  483. case B1200: urb_value = BELKIN_SA_BAUD(1200); break;
  484. case B2400: urb_value = BELKIN_SA_BAUD(2400); break;
  485. case B4800: urb_value = BELKIN_SA_BAUD(4800); break;
  486. case B9600: urb_value = BELKIN_SA_BAUD(9600); break;
  487. case B19200: urb_value = BELKIN_SA_BAUD(19200); break;
  488. case B38400: urb_value = BELKIN_SA_BAUD(38400); break;
  489. case B57600: urb_value = BELKIN_SA_BAUD(57600); break;
  490. case B115200: urb_value = BELKIN_SA_BAUD(115200); break;
  491. case B230400: urb_value = BELKIN_SA_BAUD(230400); break;
  492. default: err("BELKIN USB Serial Adapter: unsupported baudrate request, using default of 9600");
  493. urb_value = BELKIN_SA_BAUD(9600); break;
  494. }
  495. if ((cflag & CBAUD) != B0 ) {
  496. if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
  497. err("Set baudrate error");
  498. } else {
  499. /* Disable flow control */
  500. if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, BELKIN_SA_FLOW_NONE) < 0)
  501. err("Disable flowcontrol error");
  503. /* Drop RTS and DTR */
  504. priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
  505. if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
  506. err("DTR LOW error");
  507. if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
  508. err("RTS LOW error");
  509. }
  510. }
  512. /* set the parity */
  513. if( (cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD)) ) {
  514. if (cflag & PARENB)
  515. urb_value = (cflag & PARODD) ?  BELKIN_SA_PARITY_ODD : BELKIN_SA_PARITY_EVEN;
  516. else
  517. urb_value = BELKIN_SA_PARITY_NONE;
  518. if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
  519. err("Set parity error");
  520. }
  522. /* set the number of data bits */
  523. if( (cflag&CSIZE) != (old_cflag&CSIZE) ) {
  524. switch (cflag & CSIZE) {
  525. case CS5: urb_value = BELKIN_SA_DATA_BITS(5); break;
  526. case CS6: urb_value = BELKIN_SA_DATA_BITS(6); break;
  527. case CS7: urb_value = BELKIN_SA_DATA_BITS(7); break;
  528. case CS8: urb_value = BELKIN_SA_DATA_BITS(8); break;
  529. default: err("CSIZE was not CS5-CS8, using default of 8");
  530. urb_value = BELKIN_SA_DATA_BITS(8);
  531. break;
  532. }
  533. if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
  534. err("Set data bits error");
  535. }
  537. /* set the number of stop bits */
  538. if( (cflag&CSTOPB) != (old_cflag&CSTOPB) ) {
  539. urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) : BELKIN_SA_STOP_BITS(1);
  540. if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, urb_value) < 0)
  541. err("Set stop bits error");
  542. }
  544. /* Set flow control */
  545. if( (iflag&IXOFF)   != (old_iflag&IXOFF)
  546. || (iflag&IXON)    != (old_iflag&IXON)
  547. ||  (cflag&CRTSCTS) != (old_cflag&CRTSCTS) ) {
  548. urb_value = 0;
  549. if ((iflag & IXOFF) || (iflag & IXON))
  550. urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
  551. else
  552. urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
  554. if (cflag & CRTSCTS)
  555. urb_value |=  (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
  556. else
  557. urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
  559. if (priv->bad_flow_control)
  560. urb_value &= ~(BELKIN_SA_FLOW_IRTS);
  562. if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
  563. err("Set flow control error");
  564. }
  565. } /* belkin_sa_set_termios */
  568. static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state )
  569. {
  570. struct usb_serial *serial = port->serial;
  572. if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
  573. err("Set break_ctl %d", break_state);
  574. }
  577. static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
  578. {
  579. struct usb_serial *serial = port->serial;
  580. __u16 urb_value; /* Will hold the new flags */
  581. struct belkin_sa_private *priv = (struct belkin_sa_private *)port->private;
  582. int  ret, mask;
  584. /* Based on code from acm.c and others */
  585. switch (cmd) {
  586. case TIOCMGET:
  587. return put_user(priv->control_state, (unsigned long *) arg);
  588. break;
  590. case TIOCMSET: /* Turns on and off the lines as specified by the mask */
  591. case TIOCMBIS: /* turns on (Sets) the lines as specified by the mask */
  592. case TIOCMBIC: /* turns off (Clears) the lines as specified by the mask */
  593. if (get_user(mask, (unsigned long *) arg))
  594. return -EFAULT;
  596. if ((cmd == TIOCMSET) || (mask & TIOCM_RTS)) {
  597. /* RTS needs set */
  598. urb_value = ((cmd == TIOCMSET) && (mask & TIOCM_RTS)) || (cmd == TIOCMBIS) ? 1 : 0;
  599. if (urb_value)
  600. priv->control_state |= TIOCM_RTS;
  601. else
  602. priv->control_state &= ~TIOCM_RTS;
  604. if ((ret = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, urb_value)) < 0) {
  605. err("Set RTS error %d", ret);
  606. return(ret);
  607. }
  608. }
  610. if ((cmd == TIOCMSET) || (mask & TIOCM_DTR)) {
  611. /* DTR needs set */
  612. urb_value = ((cmd == TIOCMSET) && (mask & TIOCM_DTR)) || (cmd == TIOCMBIS) ? 1 : 0;
  613. if (urb_value)
  614. priv->control_state |= TIOCM_DTR;
  615. else
  616. priv->control_state &= ~TIOCM_DTR;
  617. if ((ret = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, urb_value)) < 0) {
  618. err("Set DTR error %d", ret);
  619. return(ret);
  620. }
  621. }
  622. break;
  624. case TIOCMIWAIT:
  625. /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
  626. /* TODO */
  627. return( 0 );
  629. case TIOCGICOUNT:
  630. /* return count of modemline transitions */
  631. /* TODO */
  632. return 0;
  634. default:
  635. dbg("belkin_sa_ioctl arg not supported - 0x%04x",cmd);
  636. return(-ENOIOCTLCMD);
  637. break;
  638. }
  639. return 0;
  640. } /* belkin_sa_ioctl */
  643. static int __init belkin_sa_init (void)
  644. {
  645. usb_serial_register (&belkin_dockstation_device);
  646. usb_serial_register (&belkin_sa_device);
  647. usb_serial_register (&belkin_old_device);
  648. usb_serial_register (&peracom_device);
  649. usb_serial_register (&gocom232_device);
  650. info(DRIVER_DESC " " DRIVER_VERSION);
  651. return 0;
  652. }
  655. static void __exit belkin_sa_exit (void)
  656. {
  657. usb_serial_deregister (&belkin_dockstation_device);
  658. usb_serial_deregister (&belkin_sa_device);
  659. usb_serial_deregister (&belkin_old_device);
  660. usb_serial_deregister (&peracom_device);
  661. usb_serial_deregister (&gocom232_device);
  662. }
  665. module_init (belkin_sa_init);
  666. module_exit (belkin_sa_exit);
  668. MODULE_AUTHOR( DRIVER_AUTHOR );
  669. MODULE_DESCRIPTION( DRIVER_DESC );
  670. MODULE_LICENSE("GPL");
  672. MODULE_PARM(debug, "i");
  673. MODULE_PARM_DESC(debug, "Debug enabled or not");