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

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

Linux/Unix编程

开发平台：

Unix_Linux

mct_u232.c：源码内容
  1. /*
  2.  * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
  3.  *
  4.  *   Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
  5.  *
  6.  *   This program is free software; you can redistribute it and/or modify
  7.  *   it under the terms of the GNU General Public License as published by
  8.  *   the Free Software Foundation; either version 2 of the License, or
  9.  *   (at your option) any later version.
  10.  *
  11.  * This program is largely derived from the Belkin USB Serial Adapter Driver
  12.  * (see belkin_sa.[ch]). All of the information about the device was acquired
  13.  * by using SniffUSB on Windows98. For technical details see mct_u232.h.
  14.  *
  15.  * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
  16.  * do the reverse engineering and how to write a USB serial device driver.
  17.  *
  18.  * TO BE DONE, TO BE CHECKED:
  19.  *   DTR/RTS signal handling may be incomplete or incorrect. I have mainly
  20.  *   implemented what I have seen with SniffUSB or found in belkin_sa.c.
  21.  *   For further TODOs check also belkin_sa.c.
  22.  *
  23.  * TEST STATUS:
  24.  *   Basic tests have been performed with minicom/zmodem transfers and
  25.  *   modem dialing under Linux 2.4.0-test10 (for me it works fine).
  26.  *
  27.  * 10-Nov-2001 Wolfgang Grandegger
  28.  *   - Fixed an endianess problem with the baudrate selection for PowerPC.
  29.  *
  30.  * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
  31.  * Added support for the Belkin F5U109 DB9 adaptor
  32.  *
  33.  * 30-May-2001 Greg Kroah-Hartman
  34.  * switched from using spinlock to a semaphore, which fixes lots of problems.
  35.  *
  36.  * 04-May-2001 Stelian Pop
  37.  *   - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
  38.  *     instead of the device reported 32 (using 32 bytes causes many data
  39.  *     loss, Windows driver uses 16 too).
  40.  *
  41.  * 02-May-2001 Stelian Pop
  42.  *   - Fixed the baud calculation for Sitecom U232-P25 model
  43.  *
  44.  * 08-Apr-2001 gb
  45.  *   - Identify version on module load.
  46.  *
  47.  * 06-Jan-2001 Cornel Ciocirlan 
  48.  *   - Added support for Sitecom U232-P25 model (Product Id 0x0230)
  49.  *   - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
  50.  *
  51.  * 29-Nov-2000 Greg Kroah-Hartman
  52.  *   - Added device id table to fit with 2.4.0-test11 structure.
  53.  *   - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
  54.  *     (lots of things will change if/when the usb-serial core changes to
  55.  *     handle these issues.
  56.  *
  57.  * 27-Nov-2000 Wolfgang Grandegger
  58.  *   A version for kernel 2.4.0-test10 released to the Linux community 
  59.  *   (via linux-usb-devel).
  60.  */
  62. #include <linux/config.h>
  63. #include <linux/kernel.h>
  64. #include <linux/errno.h>
  65. #include <linux/init.h>
  66. #include <linux/slab.h>
  67. #include <linux/tty.h>
  68. #include <linux/tty_driver.h>
  69. #include <linux/tty_flip.h>
  70. #include <linux/module.h>
  71. #include <linux/spinlock.h>
  72. #include <asm/uaccess.h>
  73. #include <linux/usb.h>
  75. #ifdef CONFIG_USB_SERIAL_DEBUG
  76.   static int debug = 1;
  77. #else
  78.   static int debug;
  79. #endif
  81. #include "usb-serial.h"
  82. #include "mct_u232.h"
  85. /*
  86.  * Version Information
  87.  */
  88. #define DRIVER_VERSION "v1.1"
  89. #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
  90. #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
  92. /*
  93.  * Some not properly written applications do not handle the return code of
  94.  * write() correctly. This can result in character losses. A work-a-round
  95.  * can be compiled in with the following definition. This work-a-round
  96.  * should _NOT_ be part of an 'official' kernel release, of course!
  97.  */
  98. #undef FIX_WRITE_RETURN_CODE_PROBLEM
  99. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  100. static int write_blocking; /* disabled by default */
  101. #endif
  103. /*
  104.  * Function prototypes
  105.  */
  106. static int  mct_u232_startup          (struct usb_serial *serial);
  107. static void mct_u232_shutdown          (struct usb_serial *serial);
  108. static int  mct_u232_open          (struct usb_serial_port *port,
  109.   struct file *filp);
  110. static void mct_u232_close          (struct usb_serial_port *port,
  111.   struct file *filp);
  112. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  113. static int  mct_u232_write          (struct usb_serial_port *port,
  114.   int from_user,
  115.   const unsigned char *buf,
  116.   int count);
  117. static void mct_u232_write_bulk_callback (struct urb *urb);
  118. #endif
  119. static void mct_u232_read_int_callback   (struct urb *urb);
  120. static void mct_u232_set_termios         (struct usb_serial_port *port,
  121.   struct termios * old);
  122. static int  mct_u232_ioctl          (struct usb_serial_port *port,
  123.   struct file * file,
  124.   unsigned int cmd,
  125.   unsigned long arg);
  126. static void mct_u232_break_ctl          (struct usb_serial_port *port,
  127.   int break_state );
  129. /*
  130.  * All of the device info needed for the MCT USB-RS232 converter.
  131.  */
  132. static struct usb_device_id id_table_combined [] = {
  133. { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
  134. { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
  135. { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
  136. { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
  137. { } /* Terminating entry */
  138. };
  140. MODULE_DEVICE_TABLE (usb, id_table_combined);
  143. static struct usb_serial_device_type mct_u232_device = {
  144. .owner =      THIS_MODULE,
  145. .name =      "Magic Control Technology USB-RS232",
  146. .id_table =      id_table_combined,
  147. .num_interrupt_in =  2,
  148. .num_bulk_in =      0,
  149. .num_bulk_out =      1,
  150. .num_ports =      1,
  151. .open =      mct_u232_open,
  152. .close =      mct_u232_close,
  153. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  154. .write =      mct_u232_write,
  155. .write_bulk_callback = mct_u232_write_bulk_callback,
  156. #endif
  157. .read_int_callback = mct_u232_read_int_callback,
  158. .ioctl =      mct_u232_ioctl,
  159. .set_termios =      mct_u232_set_termios,
  160. .break_ctl =      mct_u232_break_ctl,
  161. .startup =      mct_u232_startup,
  162. .shutdown =      mct_u232_shutdown,
  163. };
  166. struct mct_u232_private {
  167. unsigned long      control_state; /* Modem Line Setting (TIOCM) */
  168. unsigned char        last_lcr;      /* Line Control Register */
  169. unsigned char      last_lsr;      /* Line Status Register */
  170. unsigned char      last_msr;      /* Modem Status Register */
  171. };
  173. /*
  174.  * Handle vendor specific USB requests
  175.  */
  177. #define WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */
  179. static int mct_u232_calculate_baud_rate(struct usb_serial *serial, int value) {
  180. if (serial->dev->descriptor.idProduct == MCT_U232_SITECOM_PID
  181.   || serial->dev->descriptor.idProduct == MCT_U232_BELKIN_F5U109_PID) {
  182. switch (value) {
  183. case    300: return 0x01;
  184. case    600: return 0x02; /* this one not tested */
  185. case   1200: return 0x03;
  186. case   2400: return 0x04;
  187. case   4800: return 0x06;
  188. case   9600: return 0x08;
  189. case  19200: return 0x09;
  190. case  38400: return 0x0a;
  191. case  57600: return 0x0b;
  192. case 115200: return 0x0c;
  193. default:     return -1; /* normally not reached */
  194. }
  195. }
  196. else
  197. return MCT_U232_BAUD_RATE(value);
  198. }
  200. static int mct_u232_set_baud_rate(struct usb_serial *serial, int value)
  201. {
  202. unsigned int divisor;
  203.         int rc;
  204. divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value));
  205.         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  206.                              MCT_U232_SET_BAUD_RATE_REQUEST,
  207.      MCT_U232_SET_REQUEST_TYPE,
  208.                              0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
  209.      WDR_TIMEOUT);
  210. if (rc < 0)
  211. err("Set BAUD RATE %d failed (error = %d)", value, rc);
  212. dbg("set_baud_rate: value: %d, divisor: 0x%x", value, divisor);
  213.         return rc;
  214. } /* mct_u232_set_baud_rate */
  216. static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
  217. {
  218.         int rc;
  219.         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  220.                              MCT_U232_SET_LINE_CTRL_REQUEST,
  221.      MCT_U232_SET_REQUEST_TYPE,
  222.                              0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
  223.      WDR_TIMEOUT);
  224. if (rc < 0)
  225. err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
  226. dbg("set_line_ctrl: 0x%x", lcr);
  227.         return rc;
  228. } /* mct_u232_set_line_ctrl */
  230. static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
  231.    unsigned long control_state)
  232. {
  233.         int rc;
  234. unsigned char mcr = MCT_U232_MCR_NONE;
  236. if (control_state & TIOCM_DTR)
  237. mcr |= MCT_U232_MCR_DTR;
  238. if (control_state & TIOCM_RTS)
  239. mcr |= MCT_U232_MCR_RTS;
  241.         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  242.                              MCT_U232_SET_MODEM_CTRL_REQUEST,
  243.      MCT_U232_SET_REQUEST_TYPE,
  244.                              0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
  245.      WDR_TIMEOUT);
  246. if (rc < 0)
  247. err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
  248. dbg("set_modem_ctrl: state=0x%lx ==> mcr=0x%x", control_state, mcr);
  250.         return rc;
  251. } /* mct_u232_set_modem_ctrl */
  253. static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
  254. {
  255.         int rc;
  256.         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
  257.                              MCT_U232_GET_MODEM_STAT_REQUEST,
  258.      MCT_U232_GET_REQUEST_TYPE,
  259.                              0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
  260.      WDR_TIMEOUT);
  261. if (rc < 0) {
  262. err("Get MODEM STATus failed (error = %d)", rc);
  263. *msr = 0;
  264. }
  265. dbg("get_modem_stat: 0x%x", *msr);
  266.         return rc;
  267. } /* mct_u232_get_modem_stat */
  269. static void mct_u232_msr_to_state(unsigned long *control_state, unsigned char msr)
  270. {
  271.   /* Translate Control Line states */
  272. if (msr & MCT_U232_MSR_DSR)
  273. *control_state |=  TIOCM_DSR;
  274. else
  275. *control_state &= ~TIOCM_DSR;
  276. if (msr & MCT_U232_MSR_CTS)
  277. *control_state |=  TIOCM_CTS;
  278. else
  279. *control_state &= ~TIOCM_CTS;
  280. if (msr & MCT_U232_MSR_RI)
  281. *control_state |=  TIOCM_RI;
  282. else
  283. *control_state &= ~TIOCM_RI;
  284. if (msr & MCT_U232_MSR_CD)
  285. *control_state |=  TIOCM_CD;
  286. else
  287. *control_state &= ~TIOCM_CD;
  288.   dbg("msr_to_state: msr=0x%x ==> state=0x%lx", msr, *control_state);
  289. } /* mct_u232_msr_to_state */
  291. /*
  292.  * Driver's tty interface functions
  293.  */
  295. static int mct_u232_startup (struct usb_serial *serial)
  296. {
  297. struct mct_u232_private *priv;
  299. /* allocate the private data structure */
  300. serial->port->private = kmalloc(sizeof(struct mct_u232_private),
  301. GFP_KERNEL);
  302. if (!serial->port->private)
  303. return (-1); /* error */
  304. priv = (struct mct_u232_private *)serial->port->private;
  305. /* set initial values for control structures */
  306. priv->control_state = 0;
  307. priv->last_lsr = 0;
  308. priv->last_msr = 0;
  310. init_waitqueue_head(&serial->port->write_wait);
  312. return (0);
  313. } /* mct_u232_startup */
  316. static void mct_u232_shutdown (struct usb_serial *serial)
  317. {
  318. int i;
  320. dbg("%s", __FUNCTION__);
  322. /* stop reads and writes on all ports */
  323. for (i=0; i < serial->num_ports; ++i) {
  324. /* My special items, the standard routines free my urbs */
  325. if (serial->port[i].private)
  326. kfree(serial->port[i].private);
  327. }
  328. } /* mct_u232_shutdown */
  330. static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
  331. {
  332. struct usb_serial *serial = port->serial;
  333. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  334. int retval = 0;
  336. dbg("%s port %d", __FUNCTION__, port->number);
  338. /* Compensate for a hardware bug: although the Sitecom U232-P25
  339.  * device reports a maximum output packet size of 32 bytes,
  340.  * it seems to be able to accept only 16 bytes (and that's what
  341.  * SniffUSB says too...)
  342.  */
  343. if (serial->dev->descriptor.idProduct == MCT_U232_SITECOM_PID)
  344. port->bulk_out_size = 16;
  346. /* Do a defined restart: the normal serial device seems to 
  347.  * always turn on DTR and RTS here, so do the same. I'm not
  348.  * sure if this is really necessary. But it should not harm
  349.  * either.
  350.  */
  351. if (port->tty->termios->c_cflag & CBAUD)
  352. priv->control_state = TIOCM_DTR | TIOCM_RTS;
  353. else
  354. priv->control_state = 0;
  355. mct_u232_set_modem_ctrl(serial, priv->control_state);
  357. priv->last_lcr = (MCT_U232_DATA_BITS_8 | 
  358.   MCT_U232_PARITY_NONE |
  359.   MCT_U232_STOP_BITS_1);
  360. mct_u232_set_line_ctrl(serial, priv->last_lcr);
  362. /* Read modem status and update control state */
  363. mct_u232_get_modem_stat(serial, &priv->last_msr);
  364. mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
  366. {
  367. /* Puh, that's dirty */
  368. struct usb_serial_port *rport;
  369. rport = &serial->port[1];
  370. rport->tty = port->tty;
  371. rport->private = port->private;
  372. port->read_urb = rport->interrupt_in_urb;
  373. }
  375. port->read_urb->dev = port->serial->dev;
  376. retval = usb_submit_urb(port->read_urb);
  377. if (retval) {
  378. err("usb_submit_urb(read bulk) failed");
  379. goto exit;
  380. }
  382. port->interrupt_in_urb->dev = port->serial->dev;
  383. retval = usb_submit_urb(port->interrupt_in_urb);
  384. if (retval)
  385. err(" usb_submit_urb(read int) failed");
  387. exit:
  388. return 0;
  389. } /* mct_u232_open */
  392. static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
  393. {
  394. dbg("%s port %d", __FUNCTION__, port->number);
  396. if (port->serial->dev) {
  397. /* shutdown our urbs */
  398. usb_unlink_urb (port->write_urb);
  399. usb_unlink_urb (port->read_urb);
  400. usb_unlink_urb (port->interrupt_in_urb);
  401. }
  402. } /* mct_u232_close */
  405. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  406. /* The generic routines work fine otherwise */
  408. static int mct_u232_write (struct usb_serial_port *port, int from_user,
  409.    const unsigned char *buf, int count)
  410. {
  411. struct usb_serial *serial = port->serial;
  412. int result, bytes_sent, size;
  414. dbg("%s - port %d", __FUNCTION__, port->number);
  416. if (count == 0) {
  417. dbg("%s - write request of 0 bytes", __FUNCTION__);
  418. return (0);
  419. }
  421. /* only do something if we have a bulk out endpoint */
  422. if (!serial->num_bulk_out)
  423. return(0);;
  425. /* another write is still pending? */
  426. if (port->write_urb->status == -EINPROGRESS) {
  427. dbg("%s - already writing", __FUNCTION__);
  428. return (0);
  429. }
  431. bytes_sent = 0;
  432. while (count > 0) {
  433. size = (count > port->bulk_out_size) ? port->bulk_out_size : count;
  435. usb_serial_debug_data (__FILE__, __FUNCTION__, size, buf);
  437. if (from_user) {
  438. if (copy_from_user(port->write_urb->transfer_buffer, buf, size)) {
  439. return -EFAULT;
  440. }
  441. }
  442. else {
  443. memcpy (port->write_urb->transfer_buffer, buf, size);
  444. }
  446. /* set up our urb */
  447. FILL_BULK_URB(port->write_urb, serial->dev,
  448.       usb_sndbulkpipe(serial->dev,
  449.       port->bulk_out_endpointAddress),
  450.       port->write_urb->transfer_buffer, size,
  451.       ((serial->type->write_bulk_callback) ?
  452.        serial->type->write_bulk_callback :
  453.        mct_u232_write_bulk_callback),
  454.       port);
  456. /* send the data out the bulk port */
  457. result = usb_submit_urb(port->write_urb);
  458. if (result) {
  459. err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
  460. return result;
  461. }
  463. bytes_sent += size;
  464. if (write_blocking)
  465. interruptible_sleep_on(&port->write_wait);
  466. else
  467. break;
  469. buf += size;
  470. count -= size;
  471. }
  473. return bytes_sent;
  474. } /* mct_u232_write */
  476. static void mct_u232_write_bulk_callback (struct urb *urb)
  477. {
  478. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  479. struct usb_serial *serial = port->serial;
  480.         struct tty_struct *tty = port->tty;
  482. dbg("%s - port %d", __FUNCTION__, port->number);
  484. if (!serial) {
  485. dbg("%s - bad serial pointer, exiting", __FUNCTION__);
  486. return;
  487. }
  489. if (urb->status) {
  490. dbg("%s - nonzero write bulk status received: %d", __FUNCTION__,
  491.     urb->status);
  492. return;
  493. }
  495. if (write_blocking) {
  496. wake_up_interruptible(&port->write_wait);
  497. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  498.     tty->ldisc.write_wakeup)
  499. (tty->ldisc.write_wakeup)(tty);
  500. wake_up_interruptible(&tty->write_wait);
  502. } else {
  503. /* from generic_write_bulk_callback */
  504. queue_task(&port->tqueue, &tq_immediate);
  505. mark_bh(IMMEDIATE_BH);
  506. }
  508. return;
  509. } /* mct_u232_write_bulk_callback */
  510. #endif
  512. static void mct_u232_read_int_callback (struct urb *urb)
  513. {
  514. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  515. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  516. struct usb_serial *serial = port->serial;
  517. struct tty_struct *tty;
  518. unsigned char *data = urb->transfer_buffer;
  520.         dbg("%s - port %d", __FUNCTION__, port->number);
  522. /* The urb might have been killed. */
  523.         if (urb->status) {
  524.                 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__,
  525.     urb->status);
  526.                 return;
  527.         }
  528. if (!serial) {
  529. dbg("%s - bad serial pointer, exiting", __FUNCTION__);
  530. return;
  531. }
  533. usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
  535. /*
  536.  * Work-a-round: handle the 'usual' bulk-in pipe here
  537.  */
  538. if (urb->transfer_buffer_length > 2) {
  539. int i;
  540. tty = port->tty;
  541. if (urb->actual_length) {
  542. for (i = 0; i < urb->actual_length ; ++i) {
  543. tty_insert_flip_char(tty, data[i], 0);
  544. }
  545. tty_flip_buffer_push(tty);
  546. }
  547. /* INT urbs are automatically re-submitted */
  548. return;
  549. }
  551. /*
  552.  * The interrupt-in pipe signals exceptional conditions (modem line
  553.  * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
  554.  */
  555. priv->last_msr = data[MCT_U232_MSR_INDEX];
  557. /* Record Control Line states */
  558. mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
  560. #if 0
  561. /* Not yet handled. See belin_sa.c for further information */
  562. /* Now to report any errors */
  563. priv->last_lsr = data[MCT_U232_LSR_INDEX];
  564. /*
  565.  * fill in the flip buffer here, but I do not know the relation
  566.  * to the current/next receive buffer or characters.  I need
  567.  * to look in to this before committing any code.
  568.  */
  569. if (priv->last_lsr & MCT_U232_LSR_ERR) {
  570. tty = port->tty;
  571. /* Overrun Error */
  572. if (priv->last_lsr & MCT_U232_LSR_OE) {
  573. }
  574. /* Parity Error */
  575. if (priv->last_lsr & MCT_U232_LSR_PE) {
  576. }
  577. /* Framing Error */
  578. if (priv->last_lsr & MCT_U232_LSR_FE) {
  579. }
  580. /* Break Indicator */
  581. if (priv->last_lsr & MCT_U232_LSR_BI) {
  582. }
  583. }
  584. #endif
  586. /* INT urbs are automatically re-submitted */
  587. } /* mct_u232_read_int_callback */
  590. static void mct_u232_set_termios (struct usb_serial_port *port,
  591.   struct termios *old_termios)
  592. {
  593. struct usb_serial *serial = port->serial;
  594. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  595. unsigned int iflag = port->tty->termios->c_iflag;
  596. unsigned int old_iflag = old_termios->c_iflag;
  597. unsigned int cflag = port->tty->termios->c_cflag;
  598. unsigned int old_cflag = old_termios->c_cflag;
  600. /*
  601.  * Update baud rate
  602.  */
  603. if( (cflag & CBAUD) != (old_cflag & CBAUD) ) {
  604.         /* reassert DTR and (maybe) RTS on transition from B0 */
  605. if( (old_cflag & CBAUD) == B0 ) {
  606. dbg("%s: baud was B0", __FUNCTION__);
  607. priv->control_state |= TIOCM_DTR;
  608. /* don't set RTS if using hardware flow control */
  609. if (!(old_cflag & CRTSCTS)) {
  610. priv->control_state |= TIOCM_RTS;
  611. }
  612. mct_u232_set_modem_ctrl(serial, priv->control_state);
  613. }
  615. switch(cflag & CBAUD) {
  616. case B0: /* handled below */
  617. break;
  618. case B300: mct_u232_set_baud_rate(serial, 300);
  619. break;
  620. case B600: mct_u232_set_baud_rate(serial, 600);
  621. break;
  622. case B1200: mct_u232_set_baud_rate(serial, 1200);
  623. break;
  624. case B2400: mct_u232_set_baud_rate(serial, 2400);
  625. break;
  626. case B4800: mct_u232_set_baud_rate(serial, 4800);
  627. break;
  628. case B9600: mct_u232_set_baud_rate(serial, 9600);
  629. break;
  630. case B19200: mct_u232_set_baud_rate(serial, 19200);
  631. break;
  632. case B38400: mct_u232_set_baud_rate(serial, 38400);
  633. break;
  634. case B57600: mct_u232_set_baud_rate(serial, 57600);
  635. break;
  636. case B115200: mct_u232_set_baud_rate(serial, 115200);
  637. break;
  638. default: err("MCT USB-RS232 converter: unsupported baudrate request, using default of 9600");
  639. mct_u232_set_baud_rate(serial, 9600); break;
  640. }
  641. if ((cflag & CBAUD) == B0 ) {
  642. dbg("%s: baud is B0", __FUNCTION__);
  643. /* Drop RTS and DTR */
  644. priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
  645.          mct_u232_set_modem_ctrl(serial, priv->control_state);
  646. }
  647. }
  649. /*
  650.  * Update line control register (LCR)
  651.  */
  652. if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
  653.     || (cflag & CSIZE) != (old_cflag & CSIZE)
  654.     || (cflag & CSTOPB) != (old_cflag & CSTOPB) ) {
  657. priv->last_lcr = 0;
  659. /* set the parity */
  660. if (cflag & PARENB)
  661. priv->last_lcr |= (cflag & PARODD) ?
  662. MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
  663. else
  664. priv->last_lcr |= MCT_U232_PARITY_NONE;
  666. /* set the number of data bits */
  667. switch (cflag & CSIZE) {
  668. case CS5:
  669. priv->last_lcr |= MCT_U232_DATA_BITS_5; break;
  670. case CS6:
  671. priv->last_lcr |= MCT_U232_DATA_BITS_6; break;
  672. case CS7:
  673. priv->last_lcr |= MCT_U232_DATA_BITS_7; break;
  674. case CS8:
  675. priv->last_lcr |= MCT_U232_DATA_BITS_8; break;
  676. default:
  677. err("CSIZE was not CS5-CS8, using default of 8");
  678. priv->last_lcr |= MCT_U232_DATA_BITS_8;
  679. break;
  680. }
  682. /* set the number of stop bits */
  683. priv->last_lcr |= (cflag & CSTOPB) ?
  684. MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
  686. mct_u232_set_line_ctrl(serial, priv->last_lcr);
  687. }
  689. /*
  690.  * Set flow control: well, I do not really now how to handle DTR/RTS.
  691.  * Just do what we have seen with SniffUSB on Win98.
  692.  */
  693. if( (iflag & IXOFF) != (old_iflag & IXOFF)
  694.     || (iflag & IXON) != (old_iflag & IXON)
  695.     ||  (cflag & CRTSCTS) != (old_cflag & CRTSCTS) ) {
  697. /* Drop DTR/RTS if no flow control otherwise assert */
  698. if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS) )
  699. priv->control_state |= TIOCM_DTR | TIOCM_RTS;
  700. else
  701. priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
  702. mct_u232_set_modem_ctrl(serial, priv->control_state);
  703. }
  704. } /* mct_u232_set_termios */
  707. static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
  708. {
  709. struct usb_serial *serial = port->serial;
  710. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  711. unsigned char lcr = priv->last_lcr;
  713. dbg("%sstate=%d", __FUNCTION__, break_state);
  715. if (break_state)
  716. lcr |= MCT_U232_SET_BREAK;
  718. mct_u232_set_line_ctrl(serial, lcr);
  719. } /* mct_u232_break_ctl */
  722. static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
  723.    unsigned int cmd, unsigned long arg)
  724. {
  725. struct usb_serial *serial = port->serial;
  726. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  727. int mask;
  729. dbg("%scmd=0x%x", __FUNCTION__, cmd);
  731. /* Based on code from acm.c and others */
  732. switch (cmd) {
  733. case TIOCMGET:
  734. return put_user(priv->control_state, (unsigned long *) arg);
  735. break;
  737. case TIOCMSET: /* Turns on and off the lines as specified by the mask */
  738. case TIOCMBIS: /* turns on (Sets) the lines as specified by the mask */
  739. case TIOCMBIC: /* turns off (Clears) the lines as specified by the mask */
  740. if (get_user(mask, (unsigned long *) arg))
  741. return -EFAULT;
  743. if ((cmd == TIOCMSET) || (mask & TIOCM_RTS)) {
  744. /* RTS needs set */
  745. if( ((cmd == TIOCMSET) && (mask & TIOCM_RTS)) ||
  746.     (cmd == TIOCMBIS) )
  747. priv->control_state |=  TIOCM_RTS;
  748. else
  749. priv->control_state &= ~TIOCM_RTS;
  750. }
  752. if ((cmd == TIOCMSET) || (mask & TIOCM_DTR)) {
  753. /* DTR needs set */
  754. if( ((cmd == TIOCMSET) && (mask & TIOCM_DTR)) ||
  755.     (cmd == TIOCMBIS) )
  756. priv->control_state |=  TIOCM_DTR;
  757. else
  758. priv->control_state &= ~TIOCM_DTR;
  759. }
  760. mct_u232_set_modem_ctrl(serial, priv->control_state);
  761. break;
  763. case TIOCMIWAIT:
  764. /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
  765. /* TODO */
  766. return( 0 );
  768. case TIOCGICOUNT:
  769. /* return count of modemline transitions */
  770. /* TODO */
  771. return 0;
  773. default:
  774. dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
  775. return(-ENOIOCTLCMD);
  776. break;
  777. }
  778. return 0;
  779. } /* mct_u232_ioctl */
  782. static int __init mct_u232_init (void)
  783. {
  784. usb_serial_register (&mct_u232_device);
  785. info(DRIVER_DESC " " DRIVER_VERSION);
  786. return 0;
  787. }
  790. static void __exit mct_u232_exit (void)
  791. {
  792. usb_serial_deregister (&mct_u232_device);
  793. }
  796. module_init (mct_u232_init);
  797. module_exit(mct_u232_exit);
  799. MODULE_AUTHOR( DRIVER_AUTHOR );
  800. MODULE_DESCRIPTION( DRIVER_DESC );
  801. MODULE_LICENSE("GPL");
  803. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  804. MODULE_PARM(write_blocking, "i");
  805. MODULE_PARM_DESC(write_blocking, 
  806.  "The write function will block to write out all data");
  807. #endif
  809. MODULE_PARM(debug, "i");
  810. MODULE_PARM_DESC(debug, "Debug enabled or not");