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

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

嵌入式Linux

开发平台：

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/sched.h>
  65. #include <linux/signal.h>
  66. #include <linux/errno.h>
  67. #include <linux/poll.h>
  68. #include <linux/init.h>
  69. #include <linux/slab.h>
  70. #include <linux/fcntl.h>
  71. #include <linux/tty.h>
  72. #include <linux/tty_driver.h>
  73. #include <linux/tty_flip.h>
  74. #include <linux/module.h>
  75. #include <linux/spinlock.h>
  76. #include <linux/usb.h>
  78. #ifdef CONFIG_USB_SERIAL_DEBUG
  79.   static int debug = 1;
  80. #else
  81.   static int debug;
  82. #endif
  84. #include "usb-serial.h"
  85. #include "mct_u232.h"
  88. /*
  89.  * Version Information
  90.  */
  91. #define DRIVER_VERSION "v1.1"
  92. #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
  93. #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
  95. /*
  96.  * Some not properly written applications do not handle the return code of
  97.  * write() correctly. This can result in character losses. A work-a-round
  98.  * can be compiled in with the following definition. This work-a-round
  99.  * should _NOT_ be part of an 'official' kernel release, of course!
  100.  */
  101. #undef FIX_WRITE_RETURN_CODE_PROBLEM
  102. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  103. static int write_blocking; /* disabled by default */
  104. #endif
  106. /*
  107.  * Function prototypes
  108.  */
  109. static int  mct_u232_startup          (struct usb_serial *serial);
  110. static void mct_u232_shutdown          (struct usb_serial *serial);
  111. static int  mct_u232_open          (struct usb_serial_port *port,
  112.   struct file *filp);
  113. static void mct_u232_close          (struct usb_serial_port *port,
  114.   struct file *filp);
  115. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  116. static int  mct_u232_write          (struct usb_serial_port *port,
  117.   int from_user,
  118.   const unsigned char *buf,
  119.   int count);
  120. static void mct_u232_write_bulk_callback (struct urb *urb);
  121. #endif
  122. static void mct_u232_read_int_callback   (struct urb *urb);
  123. static void mct_u232_set_termios         (struct usb_serial_port *port,
  124.   struct termios * old);
  125. static int  mct_u232_ioctl          (struct usb_serial_port *port,
  126.   struct file * file,
  127.   unsigned int cmd,
  128.   unsigned long arg);
  129. static void mct_u232_break_ctl          (struct usb_serial_port *port,
  130.   int break_state );
  132. /*
  133.  * All of the device info needed for the MCT USB-RS232 converter.
  134.  */
  135. static __devinitdata struct usb_device_id id_table_combined [] = {
  136. { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
  137. { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
  138. { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
  139. { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
  140. { } /* Terminating entry */
  141. };
  143. static __devinitdata struct usb_device_id mct_u232_table [] = {
  144.         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
  145. { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
  146.         { }                        /* Terminating entry */
  147. };
  149. static __devinitdata struct usb_device_id mct_u232_sitecom_table [] = {
  150.         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
  151.         { }                        /* Terminating entry */
  152. };
  154. static __devinitdata struct usb_device_id mct_u232_du_h3sp_table [] = {
  155.         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
  156.         { }                        /* Terminating entry */
  157. };
  159. MODULE_DEVICE_TABLE (usb, id_table_combined);
  162. static struct usb_serial_device_type mct_u232_device = {
  163. name:      "Magic Control Technology USB-RS232",
  164. id_table:      mct_u232_table,
  165. needs_interrupt_in:  MUST_HAVE,  /* 2 interrupt-in endpoints */
  166. needs_bulk_in:      MUST_HAVE_NOT,   /* no bulk-in endpoint */
  167. needs_bulk_out:      MUST_HAVE,       /* 1 bulk-out endpoint */
  168. num_interrupt_in:    2,
  169. num_bulk_in:      0,
  170. num_bulk_out:      1,
  171. num_ports:      1,
  172. open:      mct_u232_open,
  173. close:      mct_u232_close,
  174. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  175. write:      mct_u232_write,
  176. write_bulk_callback: mct_u232_write_bulk_callback,
  177. #endif
  178. read_int_callback:   mct_u232_read_int_callback,
  179. ioctl:      mct_u232_ioctl,
  180. set_termios:      mct_u232_set_termios,
  181. break_ctl:      mct_u232_break_ctl,
  182. startup:      mct_u232_startup,
  183. shutdown:      mct_u232_shutdown,
  184. };
  186. static struct usb_serial_device_type mct_u232_sitecom_device = {
  187. name:      "MCT/Sitecom USB-RS232",
  188. id_table:      mct_u232_sitecom_table,
  189. needs_interrupt_in:  MUST_HAVE,  /* 2 interrupt-in endpoints */
  190. needs_bulk_in:      MUST_HAVE_NOT,   /* no bulk-in endpoint */
  191. needs_bulk_out:      MUST_HAVE,       /* 1 bulk-out endpoint */
  192. num_interrupt_in:    2,
  193. num_bulk_in:      0,
  194. num_bulk_out:      1,
  195. num_ports:      1,
  196. open:      mct_u232_open,
  197. close:      mct_u232_close,
  198. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  199. write:      mct_u232_write,
  200. write_bulk_callback: mct_u232_write_bulk_callback,
  201. #endif
  202. read_int_callback:   mct_u232_read_int_callback,
  203. ioctl:      mct_u232_ioctl,
  204. set_termios:      mct_u232_set_termios,
  205. break_ctl:      mct_u232_break_ctl,
  206. startup:      mct_u232_startup,
  207. shutdown:      mct_u232_shutdown,
  208. };
  210. static struct usb_serial_device_type mct_u232_du_h3sp_device = {
  211.         name:                "MCT/D-Link DU-H3SP USB BAY",
  212.         id_table:            mct_u232_du_h3sp_table,
  213.         needs_interrupt_in:  MUST_HAVE,  /* 2 interrupt-in endpoints */
  214.         needs_bulk_in:       MUST_HAVE_NOT,   /* no bulk-in endpoint */
  215.         needs_bulk_out:      MUST_HAVE,       /* 1 bulk-out endpoint */
  216.         num_interrupt_in:    2,
  217.         num_bulk_in:         0,
  218.         num_bulk_out:        1,
  219.         num_ports:           1,
  220.         open:                mct_u232_open,
  221.         close:               mct_u232_close,
  222. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  223.         write:               mct_u232_write,
  224.         write_bulk_callback: mct_u232_write_bulk_callback,
  225. #endif
  226.         read_int_callback:   mct_u232_read_int_callback,
  227.         ioctl:               mct_u232_ioctl,
  228.         set_termios:         mct_u232_set_termios,
  229.         break_ctl:           mct_u232_break_ctl,
  230.         startup:             mct_u232_startup,
  231.         shutdown:            mct_u232_shutdown,
  232. };
  237. struct mct_u232_private {
  238. unsigned long      control_state; /* Modem Line Setting (TIOCM) */
  239. unsigned char        last_lcr;      /* Line Control Register */
  240. unsigned char      last_lsr;      /* Line Status Register */
  241. unsigned char      last_msr;      /* Modem Status Register */
  242. };
  244. /*
  245.  * Handle vendor specific USB requests
  246.  */
  248. #define WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */
  250. static int mct_u232_calculate_baud_rate(struct usb_serial *serial, int value) {
  251. if (serial->dev->descriptor.idProduct == MCT_U232_SITECOM_PID
  252.   || serial->dev->descriptor.idProduct == MCT_U232_BELKIN_F5U109_PID) {
  253. switch (value) {
  254. case    300: return 0x01;
  255. case    600: return 0x02; /* this one not tested */
  256. case   1200: return 0x03;
  257. case   2400: return 0x04;
  258. case   4800: return 0x06;
  259. case   9600: return 0x08;
  260. case  19200: return 0x09;
  261. case  38400: return 0x0a;
  262. case  57600: return 0x0b;
  263. case 115200: return 0x0c;
  264. default:     return -1; /* normally not reached */
  265. }
  266. }
  267. else
  268. return MCT_U232_BAUD_RATE(value);
  269. }
  271. static int mct_u232_set_baud_rate(struct usb_serial *serial, int value)
  272. {
  273. unsigned int divisor;
  274.         int rc;
  275. divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value));
  276.         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  277.                              MCT_U232_SET_BAUD_RATE_REQUEST,
  278.      MCT_U232_SET_REQUEST_TYPE,
  279.                              0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
  280.      WDR_TIMEOUT);
  281. if (rc < 0)
  282. err("Set BAUD RATE %d failed (error = %d)", value, rc);
  283. dbg("set_baud_rate: value: %d, divisor: 0x%x", value, divisor);
  284.         return rc;
  285. } /* mct_u232_set_baud_rate */
  287. static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
  288. {
  289.         int rc;
  290.         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  291.                              MCT_U232_SET_LINE_CTRL_REQUEST,
  292.      MCT_U232_SET_REQUEST_TYPE,
  293.                              0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
  294.      WDR_TIMEOUT);
  295. if (rc < 0)
  296. err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
  297. dbg("set_line_ctrl: 0x%x", lcr);
  298.         return rc;
  299. } /* mct_u232_set_line_ctrl */
  301. static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
  302.    unsigned long control_state)
  303. {
  304.         int rc;
  305. unsigned char mcr = MCT_U232_MCR_NONE;
  307. if (control_state & TIOCM_DTR)
  308. mcr |= MCT_U232_MCR_DTR;
  309. if (control_state & TIOCM_RTS)
  310. mcr |= MCT_U232_MCR_RTS;
  312.         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  313.                              MCT_U232_SET_MODEM_CTRL_REQUEST,
  314.      MCT_U232_SET_REQUEST_TYPE,
  315.                              0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
  316.      WDR_TIMEOUT);
  317. if (rc < 0)
  318. err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
  319. dbg("set_modem_ctrl: state=0x%lx ==> mcr=0x%x", control_state, mcr);
  321.         return rc;
  322. } /* mct_u232_set_modem_ctrl */
  324. static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
  325. {
  326.         int rc;
  327.         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
  328.                              MCT_U232_GET_MODEM_STAT_REQUEST,
  329.      MCT_U232_GET_REQUEST_TYPE,
  330.                              0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
  331.      WDR_TIMEOUT);
  332. if (rc < 0) {
  333. err("Get MODEM STATus failed (error = %d)", rc);
  334. *msr = 0;
  335. }
  336. dbg("get_modem_stat: 0x%x", *msr);
  337.         return rc;
  338. } /* mct_u232_get_modem_stat */
  340. static void mct_u232_msr_to_state(unsigned long *control_state, unsigned char msr)
  341. {
  342.   /* Translate Control Line states */
  343. if (msr & MCT_U232_MSR_DSR)
  344. *control_state |=  TIOCM_DSR;
  345. else
  346. *control_state &= ~TIOCM_DSR;
  347. if (msr & MCT_U232_MSR_CTS)
  348. *control_state |=  TIOCM_CTS;
  349. else
  350. *control_state &= ~TIOCM_CTS;
  351. if (msr & MCT_U232_MSR_RI)
  352. *control_state |=  TIOCM_RI;
  353. else
  354. *control_state &= ~TIOCM_RI;
  355. if (msr & MCT_U232_MSR_CD)
  356. *control_state |=  TIOCM_CD;
  357. else
  358. *control_state &= ~TIOCM_CD;
  359.   dbg("msr_to_state: msr=0x%x ==> state=0x%lx", msr, *control_state);
  360. } /* mct_u232_msr_to_state */
  362. /*
  363.  * Driver's tty interface functions
  364.  */
  366. static int mct_u232_startup (struct usb_serial *serial)
  367. {
  368. struct mct_u232_private *priv;
  370. /* allocate the private data structure */
  371. serial->port->private = kmalloc(sizeof(struct mct_u232_private),
  372. GFP_KERNEL);
  373. if (!serial->port->private)
  374. return (-1); /* error */
  375. priv = (struct mct_u232_private *)serial->port->private;
  376. /* set initial values for control structures */
  377. priv->control_state = 0;
  378. priv->last_lsr = 0;
  379. priv->last_msr = 0;
  381. init_waitqueue_head(&serial->port->write_wait);
  383. return (0);
  384. } /* mct_u232_startup */
  387. static void mct_u232_shutdown (struct usb_serial *serial)
  388. {
  389. int i;
  391. dbg (__FUNCTION__);
  393. /* stop reads and writes on all ports */
  394. for (i=0; i < serial->num_ports; ++i) {
  395. while (serial->port[i].open_count > 0) {
  396. mct_u232_close (&serial->port[i], NULL);
  397. }
  398. /* My special items, the standard routines free my urbs */
  399. if (serial->port[i].private)
  400. kfree(serial->port[i].private);
  401. }
  402. } /* mct_u232_shutdown */
  404. static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
  405. {
  406. struct usb_serial *serial = port->serial;
  407. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  408. int retval = 0;
  410. dbg(__FUNCTION__" port %d", port->number);
  412. down (&port->sem);
  414. ++port->open_count;
  415. MOD_INC_USE_COUNT;
  417. if (!port->active) {
  418. port->active = 1;
  420. /* Compensate for a hardware bug: although the Sitecom U232-P25
  421.  * device reports a maximum output packet size of 32 bytes,
  422.  * it seems to be able to accept only 16 bytes (and that's what
  423.  * SniffUSB says too...)
  424.  */
  425. if (serial->dev->descriptor.idProduct == MCT_U232_SITECOM_PID)
  426. port->bulk_out_size = 16;
  428. /* Do a defined restart: the normal serial device seems to 
  429.  * always turn on DTR and RTS here, so do the same. I'm not
  430.  * sure if this is really necessary. But it should not harm
  431.  * either.
  432.  */
  433. if (port->tty->termios->c_cflag & CBAUD)
  434. priv->control_state = TIOCM_DTR | TIOCM_RTS;
  435. else
  436. priv->control_state = 0;
  437. mct_u232_set_modem_ctrl(serial, priv->control_state);
  439. priv->last_lcr = (MCT_U232_DATA_BITS_8 | 
  440.   MCT_U232_PARITY_NONE |
  441.   MCT_U232_STOP_BITS_1);
  442. mct_u232_set_line_ctrl(serial, priv->last_lcr);
  444. /* Read modem status and update control state */
  445. mct_u232_get_modem_stat(serial, &priv->last_msr);
  446. mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
  448. {
  449. /* Puh, that's dirty */
  450. struct usb_serial_port *rport;
  451. rport = &serial->port[1];
  452. rport->tty = port->tty;
  453. rport->private = port->private;
  454. port->read_urb = rport->interrupt_in_urb;
  455. }
  457. port->read_urb->dev = port->serial->dev;
  458. retval = usb_submit_urb(port->read_urb);
  459. if (retval) {
  460. err("usb_submit_urb(read bulk) failed");
  461. goto exit;
  462. }
  464. port->interrupt_in_urb->dev = port->serial->dev;
  465. retval = usb_submit_urb(port->interrupt_in_urb);
  466. if (retval)
  467. err(" usb_submit_urb(read int) failed");
  469. }
  471. exit:
  472. up (&port->sem);
  474. return 0;
  475. } /* mct_u232_open */
  478. static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
  479. {
  480. dbg(__FUNCTION__" port %d", port->number);
  482. down (&port->sem);
  484. --port->open_count;
  486. if (port->open_count <= 0) {
  487. if (port->serial->dev) {
  488. /* shutdown our urbs */
  489. usb_unlink_urb (port->write_urb);
  490. usb_unlink_urb (port->read_urb);
  491. usb_unlink_urb (port->interrupt_in_urb);
  492. }
  493. port->active = 0;
  494. }
  496. up (&port->sem);
  497. MOD_DEC_USE_COUNT;
  498. } /* mct_u232_close */
  501. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  502. /* The generic routines work fine otherwise */
  504. static int mct_u232_write (struct usb_serial_port *port, int from_user,
  505.    const unsigned char *buf, int count)
  506. {
  507. struct usb_serial *serial = port->serial;
  508. int result, bytes_sent, size;
  510. dbg(__FUNCTION__ " - port %d", port->number);
  512. if (count == 0) {
  513. dbg(__FUNCTION__ " - write request of 0 bytes");
  514. return (0);
  515. }
  517. /* only do something if we have a bulk out endpoint */
  518. if (!serial->num_bulk_out)
  519. return(0);;
  521. /* another write is still pending? */
  522. if (port->write_urb->status == -EINPROGRESS) {
  523. dbg (__FUNCTION__ " - already writing");
  524. return (0);
  525. }
  527. bytes_sent = 0;
  528. while (count > 0) {
  530. down (&port->sem);
  532. size = (count > port->bulk_out_size) ? port->bulk_out_size : count;
  534. usb_serial_debug_data (__FILE__, __FUNCTION__, size, buf);
  536. if (from_user) {
  537. if (copy_from_user(port->write_urb->transfer_buffer, buf, size)) {
  538. up (&port->sem);
  539. return -EFAULT;
  540. }
  541. }
  542. else {
  543. memcpy (port->write_urb->transfer_buffer, buf, size);
  544. }
  546. /* set up our urb */
  547. FILL_BULK_URB(port->write_urb, serial->dev,
  548.       usb_sndbulkpipe(serial->dev,
  549.       port->bulk_out_endpointAddress),
  550.       port->write_urb->transfer_buffer, size,
  551.       ((serial->type->write_bulk_callback) ?
  552.        serial->type->write_bulk_callback :
  553.        mct_u232_write_bulk_callback),
  554.       port);
  556. /* send the data out the bulk port */
  557. result = usb_submit_urb(port->write_urb);
  558. if (result) {
  559. err(__FUNCTION__
  560.     " - failed submitting write urb, error %d", result);
  561. up (&port->sem);
  562. return result;
  563. }
  565. up (&port->sem);
  567. bytes_sent += size;
  568. if (write_blocking)
  569. interruptible_sleep_on(&port->write_wait);
  570. else
  571. break;
  573. buf += size;
  574. count -= size;
  575. }
  577. return bytes_sent;
  578. } /* mct_u232_write */
  580. static void mct_u232_write_bulk_callback (struct urb *urb)
  581. {
  582. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  583. struct usb_serial *serial = port->serial;
  584.         struct tty_struct *tty = port->tty;
  586. dbg(__FUNCTION__ " - port %d", port->number);
  588. if (!serial) {
  589. dbg(__FUNCTION__ " - bad serial pointer, exiting");
  590. return;
  591. }
  593. if (urb->status) {
  594. dbg(__FUNCTION__ " - nonzero write bulk status received: %d",
  595.     urb->status);
  596. return;
  597. }
  599. if (write_blocking) {
  600. wake_up_interruptible(&port->write_wait);
  601. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  602.     tty->ldisc.write_wakeup)
  603. (tty->ldisc.write_wakeup)(tty);
  604. wake_up_interruptible(&tty->write_wait);
  606. } else {
  607. /* from generic_write_bulk_callback */
  608. queue_task(&port->tqueue, &tq_immediate);
  609. mark_bh(IMMEDIATE_BH);
  610. }
  612. return;
  613. } /* mct_u232_write_bulk_callback */
  614. #endif
  616. static void mct_u232_read_int_callback (struct urb *urb)
  617. {
  618. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  619. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  620. struct usb_serial *serial = port->serial;
  621. struct tty_struct *tty;
  622. unsigned char *data = urb->transfer_buffer;
  624.         dbg(__FUNCTION__ " - port %d", port->number);
  626. /* The urb might have been killed. */
  627.         if (urb->status) {
  628.                 dbg(__FUNCTION__ " - nonzero read bulk status received: %d",
  629.     urb->status);
  630.                 return;
  631.         }
  632. if (!serial) {
  633. dbg(__FUNCTION__ " - bad serial pointer, exiting");
  634. return;
  635. }
  637. usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
  639. /*
  640.  * Work-a-round: handle the 'usual' bulk-in pipe here
  641.  */
  642. if (urb->transfer_buffer_length > 2) {
  643. int i;
  644. tty = port->tty;
  645. if (urb->actual_length) {
  646. for (i = 0; i < urb->actual_length ; ++i) {
  647. tty_insert_flip_char(tty, data[i], 0);
  648. }
  649. tty_flip_buffer_push(tty);
  650. }
  651. /* INT urbs are automatically re-submitted */
  652. return;
  653. }
  655. /*
  656.  * The interrupt-in pipe signals exceptional conditions (modem line
  657.  * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
  658.  */
  659. priv->last_msr = data[MCT_U232_MSR_INDEX];
  661. /* Record Control Line states */
  662. mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
  664. #if 0
  665. /* Not yet handled. See belin_sa.c for further information */
  666. /* Now to report any errors */
  667. priv->last_lsr = data[MCT_U232_LSR_INDEX];
  668. /*
  669.  * fill in the flip buffer here, but I do not know the relation
  670.  * to the current/next receive buffer or characters.  I need
  671.  * to look in to this before committing any code.
  672.  */
  673. if (priv->last_lsr & MCT_U232_LSR_ERR) {
  674. tty = port->tty;
  675. /* Overrun Error */
  676. if (priv->last_lsr & MCT_U232_LSR_OE) {
  677. }
  678. /* Parity Error */
  679. if (priv->last_lsr & MCT_U232_LSR_PE) {
  680. }
  681. /* Framing Error */
  682. if (priv->last_lsr & MCT_U232_LSR_FE) {
  683. }
  684. /* Break Indicator */
  685. if (priv->last_lsr & MCT_U232_LSR_BI) {
  686. }
  687. }
  688. #endif
  690. /* INT urbs are automatically re-submitted */
  691. } /* mct_u232_read_int_callback */
  694. static void mct_u232_set_termios (struct usb_serial_port *port,
  695.   struct termios *old_termios)
  696. {
  697. struct usb_serial *serial = port->serial;
  698. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  699. unsigned int iflag = port->tty->termios->c_iflag;
  700. unsigned int old_iflag = old_termios->c_iflag;
  701. unsigned int cflag = port->tty->termios->c_cflag;
  702. unsigned int old_cflag = old_termios->c_cflag;
  704. /*
  705.  * Update baud rate
  706.  */
  707. if( (cflag & CBAUD) != (old_cflag & CBAUD) ) {
  708.         /* reassert DTR and (maybe) RTS on transition from B0 */
  709. if( (old_cflag & CBAUD) == B0 ) {
  710. dbg(__FUNCTION__ ": baud was B0");
  711. priv->control_state |= TIOCM_DTR;
  712. /* don't set RTS if using hardware flow control */
  713. if (!(old_cflag & CRTSCTS)) {
  714. priv->control_state |= TIOCM_RTS;
  715. }
  716. mct_u232_set_modem_ctrl(serial, priv->control_state);
  717. }
  719. switch(cflag & CBAUD) {
  720. case B0: /* handled below */
  721. break;
  722. case B300: mct_u232_set_baud_rate(serial, 300);
  723. break;
  724. case B600: mct_u232_set_baud_rate(serial, 600);
  725. break;
  726. case B1200: mct_u232_set_baud_rate(serial, 1200);
  727. break;
  728. case B2400: mct_u232_set_baud_rate(serial, 2400);
  729. break;
  730. case B4800: mct_u232_set_baud_rate(serial, 4800);
  731. break;
  732. case B9600: mct_u232_set_baud_rate(serial, 9600);
  733. break;
  734. case B19200: mct_u232_set_baud_rate(serial, 19200);
  735. break;
  736. case B38400: mct_u232_set_baud_rate(serial, 38400);
  737. break;
  738. case B57600: mct_u232_set_baud_rate(serial, 57600);
  739. break;
  740. case B115200: mct_u232_set_baud_rate(serial, 115200);
  741. break;
  742. default: err("MCT USB-RS232 converter: unsupported baudrate request, using default of 9600");
  743. mct_u232_set_baud_rate(serial, 9600); break;
  744. }
  745. if ((cflag & CBAUD) == B0 ) {
  746. dbg(__FUNCTION__ ": baud is B0");
  747. /* Drop RTS and DTR */
  748. priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
  749.          mct_u232_set_modem_ctrl(serial, priv->control_state);
  750. }
  751. }
  753. /*
  754.  * Update line control register (LCR)
  755.  */
  756. if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
  757.     || (cflag & CSIZE) != (old_cflag & CSIZE)
  758.     || (cflag & CSTOPB) != (old_cflag & CSTOPB) ) {
  761. priv->last_lcr = 0;
  763. /* set the parity */
  764. if (cflag & PARENB)
  765. priv->last_lcr |= (cflag & PARODD) ?
  766. MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
  767. else
  768. priv->last_lcr |= MCT_U232_PARITY_NONE;
  770. /* set the number of data bits */
  771. switch (cflag & CSIZE) {
  772. case CS5:
  773. priv->last_lcr |= MCT_U232_DATA_BITS_5; break;
  774. case CS6:
  775. priv->last_lcr |= MCT_U232_DATA_BITS_6; break;
  776. case CS7:
  777. priv->last_lcr |= MCT_U232_DATA_BITS_7; break;
  778. case CS8:
  779. priv->last_lcr |= MCT_U232_DATA_BITS_8; break;
  780. default:
  781. err("CSIZE was not CS5-CS8, using default of 8");
  782. priv->last_lcr |= MCT_U232_DATA_BITS_8;
  783. break;
  784. }
  786. /* set the number of stop bits */
  787. priv->last_lcr |= (cflag & CSTOPB) ?
  788. MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
  790. mct_u232_set_line_ctrl(serial, priv->last_lcr);
  791. }
  793. /*
  794.  * Set flow control: well, I do not really now how to handle DTR/RTS.
  795.  * Just do what we have seen with SniffUSB on Win98.
  796.  */
  797. if( (iflag & IXOFF) != (old_iflag & IXOFF)
  798.     || (iflag & IXON) != (old_iflag & IXON)
  799.     ||  (cflag & CRTSCTS) != (old_cflag & CRTSCTS) ) {
  801. /* Drop DTR/RTS if no flow control otherwise assert */
  802. if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS) )
  803. priv->control_state |= TIOCM_DTR | TIOCM_RTS;
  804. else
  805. priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
  806. mct_u232_set_modem_ctrl(serial, priv->control_state);
  807. }
  808. } /* mct_u232_set_termios */
  811. static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
  812. {
  813. struct usb_serial *serial = port->serial;
  814. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  815. unsigned char lcr = priv->last_lcr;
  817. dbg (__FUNCTION__ "state=%d", break_state);
  819. if (break_state)
  820. lcr |= MCT_U232_SET_BREAK;
  822. mct_u232_set_line_ctrl(serial, lcr);
  823. } /* mct_u232_break_ctl */
  826. static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
  827.    unsigned int cmd, unsigned long arg)
  828. {
  829. struct usb_serial *serial = port->serial;
  830. struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
  831. int mask;
  833. dbg (__FUNCTION__ "cmd=0x%x", cmd);
  835. /* Based on code from acm.c and others */
  836. switch (cmd) {
  837. case TIOCMGET:
  838. return put_user(priv->control_state, (unsigned long *) arg);
  839. break;
  841. case TIOCMSET: /* Turns on and off the lines as specified by the mask */
  842. case TIOCMBIS: /* turns on (Sets) the lines as specified by the mask */
  843. case TIOCMBIC: /* turns off (Clears) the lines as specified by the mask */
  844. if (get_user(mask, (unsigned long *) arg))
  845. return -EFAULT;
  847. if ((cmd == TIOCMSET) || (mask & TIOCM_RTS)) {
  848. /* RTS needs set */
  849. if( ((cmd == TIOCMSET) && (mask & TIOCM_RTS)) ||
  850.     (cmd == TIOCMBIS) )
  851. priv->control_state |=  TIOCM_RTS;
  852. else
  853. priv->control_state &= ~TIOCM_RTS;
  854. }
  856. if ((cmd == TIOCMSET) || (mask & TIOCM_DTR)) {
  857. /* DTR needs set */
  858. if( ((cmd == TIOCMSET) && (mask & TIOCM_DTR)) ||
  859.     (cmd == TIOCMBIS) )
  860. priv->control_state |=  TIOCM_DTR;
  861. else
  862. priv->control_state &= ~TIOCM_DTR;
  863. }
  864. mct_u232_set_modem_ctrl(serial, priv->control_state);
  865. break;
  867. case TIOCMIWAIT:
  868. /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
  869. /* TODO */
  870. return( 0 );
  872. case TIOCGICOUNT:
  873. /* return count of modemline transitions */
  874. /* TODO */
  875. return 0;
  877. default:
  878. dbg(__FUNCTION__ ": arg not supported - 0x%04x",cmd);
  879. return(-ENOIOCTLCMD);
  880. break;
  881. }
  882. return 0;
  883. } /* mct_u232_ioctl */
  886. static int __init mct_u232_init (void)
  887. {
  888. usb_serial_register (&mct_u232_device);
  889. usb_serial_register (&mct_u232_sitecom_device);
  890. usb_serial_register (&mct_u232_du_h3sp_device);
  891. info(DRIVER_VERSION ":" DRIVER_DESC);
  892. return 0;
  893. }
  896. static void __exit mct_u232_exit (void)
  897. {
  898. usb_serial_deregister (&mct_u232_device);
  899. usb_serial_deregister (&mct_u232_sitecom_device);
  900. usb_serial_deregister (&mct_u232_du_h3sp_device);
  901. }
  904. module_init (mct_u232_init);
  905. module_exit(mct_u232_exit);
  907. MODULE_AUTHOR( DRIVER_AUTHOR );
  908. MODULE_DESCRIPTION( DRIVER_DESC );
  909. MODULE_LICENSE("GPL");
  911. #ifdef FIX_WRITE_RETURN_CODE_PROBLEM
  912. MODULE_PARM(write_blocking, "i");
  913. MODULE_PARM_DESC(write_blocking, 
  914.  "The write function will block to write out all data");
  915. #endif
  917. MODULE_PARM(debug, "i");
  918. MODULE_PARM_DESC(debug, "Debug enabled or not");