drivers/usb/serial/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  * 04-Nov-2003 Bill Marr <marr at flex dot com>
  28  *   - Mimic Windows driver by sending 2 USB 'device request' messages
  29  *     following normal 'baud rate change' message.  This allows data to be
  30  *     transmitted to RS-232 devices which don't assert the 'CTS' signal.
  31  *
  32  * 10-Nov-2001 Wolfgang Grandegger
  33  *   - Fixed an endianess problem with the baudrate selection for PowerPC.
  34  *
  35  * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
  36  *   - Added support for the Belkin F5U109 DB9 adaptor
  37  *
  38  * 30-May-2001 Greg Kroah-Hartman
  39  *   - switched from using spinlock to a semaphore, which fixes lots of
  40  *     problems.
  41  *
  42  * 04-May-2001 Stelian Pop
  43  *   - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
  44  *     instead of the device reported 32 (using 32 bytes causes many data
  45  *     loss, Windows driver uses 16 too).
  46  *
  47  * 02-May-2001 Stelian Pop
  48  *   - Fixed the baud calculation for Sitecom U232-P25 model
  49  *
  50  * 08-Apr-2001 gb
  51  *   - Identify version on module load.
  52  *
  53  * 06-Jan-2001 Cornel Ciocirlan
  54  *   - Added support for Sitecom U232-P25 model (Product Id 0x0230)
  55  *   - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
  56  *
  57  * 29-Nov-2000 Greg Kroah-Hartman
  58  *   - Added device id table to fit with 2.4.0-test11 structure.
  59  *   - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
  60  *     (lots of things will change if/when the usb-serial core changes to
  61  *     handle these issues.
  62  *
  63  * 27-Nov-2000 Wolfgang Grandegge
  64  *   A version for kernel 2.4.0-test10 released to the Linux community
  65  *   (via linux-usb-devel).
  66  */
  67
  68 #include <linux/kernel.h>
  69 #include <linux/errno.h>
  70 #include <linux/init.h>
  71 #include <linux/slab.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/uaccess.h>
  78 #include <asm/unaligned.h>
  79 #include <linux/usb.h>
  80 #include <linux/usb/serial.h>
  81 #include <linux/serial.h>
  82 #include <linux/ioctl.h>
  83 #include "mct_u232.h"
  84
  85 /*
  86  * Version Information
  87  */
  88 #define DRIVER_VERSION "z2.1"           /* Linux in-kernel version */
  89 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
  90 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
  91
  92 static int debug;
  93
  94 /*
  95  * Function prototypes
  96  */
  97 static int  mct_u232_startup(struct usb_serial *serial);
  98 static void mct_u232_release(struct usb_serial *serial);
  99 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
 100 static void mct_u232_close(struct usb_serial_port *port);
 101 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
 102 static void mct_u232_read_int_callback(struct urb *urb);
 103 static void mct_u232_set_termios(struct tty_struct *tty,
 104                         struct usb_serial_port *port, struct ktermios *old);
 105 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
 106 static int  mct_u232_tiocmget(struct tty_struct *tty);
 107 static int  mct_u232_tiocmset(struct tty_struct *tty,
 108                         unsigned int set, unsigned int clear);
 109 static int  mct_u232_ioctl(struct tty_struct *tty,
 110                         unsigned int cmd, unsigned long arg);
 111 static int  mct_u232_get_icount(struct tty_struct *tty,
 112                         struct serial_icounter_struct *icount);
 113 static void mct_u232_throttle(struct tty_struct *tty);
 114 static void mct_u232_unthrottle(struct tty_struct *tty);
 115
 116
 117 /*
 118  * All of the device info needed for the MCT USB-RS232 converter.
 119  */
 120 static const struct usb_device_id id_table_combined[] = {
 121         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
 122         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
 123         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
 124         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
 125         { }             /* Terminating entry */
 126 };
 127
 128 MODULE_DEVICE_TABLE(usb, id_table_combined);
 129
 130 static struct usb_driver mct_u232_driver = {
 131         .name =         "mct_u232",
 132         .probe =        usb_serial_probe,
 133         .disconnect =   usb_serial_disconnect,
 134         .id_table =     id_table_combined,
 135         .no_dynamic_id =        1,
 136 };
 137
 138 static struct usb_serial_driver mct_u232_device = {
 139         .driver = {
 140                 .owner =        THIS_MODULE,
 141                 .name =         "mct_u232",
 142         },
 143         .description =       "MCT U232",
 144         .usb_driver =        &mct_u232_driver,
 145         .id_table =          id_table_combined,
 146         .num_ports =         1,
 147         .open =              mct_u232_open,
 148         .close =             mct_u232_close,
 149         .dtr_rts =           mct_u232_dtr_rts,
 150         .throttle =          mct_u232_throttle,
 151         .unthrottle =        mct_u232_unthrottle,
 152         .read_int_callback = mct_u232_read_int_callback,
 153         .set_termios =       mct_u232_set_termios,
 154         .break_ctl =         mct_u232_break_ctl,
 155         .tiocmget =          mct_u232_tiocmget,
 156         .tiocmset =          mct_u232_tiocmset,
 157         .attach =            mct_u232_startup,
 158         .release =           mct_u232_release,
 159         .ioctl =             mct_u232_ioctl,
 160         .get_icount =        mct_u232_get_icount,
 161 };
 162
 163 struct mct_u232_private {
 164         spinlock_t lock;
 165         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
 166         unsigned char        last_lcr;      /* Line Control Register */
 167         unsigned char        last_lsr;      /* Line Status Register */
 168         unsigned char        last_msr;      /* Modem Status Register */
 169         unsigned int         rx_flags;      /* Throttling flags */
 170         struct async_icount  icount;
 171 };
 172
 173 #define THROTTLED               0x01
 174
 175 /*
 176  * Handle vendor specific USB requests
 177  */
 178
 179 #define WDR_TIMEOUT 5000 /* default urb timeout */
 180
 181 /*
 182  * Later day 2.6.0-test kernels have new baud rates like B230400 which
 183  * we do not know how to support. We ignore them for the moment.
 184  */
 185 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
 186                                         speed_t value, speed_t *result)
 187 {
 188         *result = value;
 189
 190         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
 191                 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
 192                 switch (value) {
 193                 case 300:
 194                         return 0x01;
 195                 case 600:
 196                         return 0x02; /* this one not tested */
 197                 case 1200:
 198                         return 0x03;
 199                 case 2400:
 200                         return 0x04;
 201                 case 4800:
 202                         return 0x06;
 203                 case 9600:
 204                         return 0x08;
 205                 case 19200:
 206                         return 0x09;
 207                 case 38400:
 208                         return 0x0a;
 209                 case 57600:
 210                         return 0x0b;
 211                 case 115200:
 212                         return 0x0c;
 213                 default:
 214                         *result = 9600;
 215                         return 0x08;
 216                 }
 217         } else {
 218                 /* FIXME: Can we use any divider - should we do
 219                    divider = 115200/value;
 220                    real baud = 115200/divider */
 221                 switch (value) {
 222                 case 300: break;
 223                 case 600: break;
 224                 case 1200: break;
 225                 case 2400: break;
 226                 case 4800: break;
 227                 case 9600: break;
 228                 case 19200: break;
 229                 case 38400: break;
 230                 case 57600: break;
 231                 case 115200: break;
 232                 default:
 233                         value = 9600;
 234                         *result = 9600;
 235                 }
 236                 return 115200/value;
 237         }
 238 }
 239
 240 static int mct_u232_set_baud_rate(struct tty_struct *tty,
 241         struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
 242 {
 243         unsigned int divisor;
 244         int rc;
 245         unsigned char *buf;
 246         unsigned char cts_enable_byte = 0;
 247         speed_t speed;
 248
 249         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 250         if (buf == NULL)
 251                 return -ENOMEM;
 252
 253         divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
 254         put_unaligned_le32(cpu_to_le32(divisor), buf);
 255         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 256                                 MCT_U232_SET_BAUD_RATE_REQUEST,
 257                                 MCT_U232_SET_REQUEST_TYPE,
 258                                 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
 259                                 WDR_TIMEOUT);
 260         if (rc < 0)     /*FIXME: What value speed results */
 261                 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
 262                         value, rc);
 263         else
 264                 tty_encode_baud_rate(tty, speed, speed);
 265         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
 266
 267         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
 268            always sends two extra USB 'device request' messages after the
 269            'baud rate change' message.  The actual functionality of the
 270            request codes in these messages is not fully understood but these
 271            particular codes are never seen in any operation besides a baud
 272            rate change.  Both of these messages send a single byte of data.
 273            In the first message, the value of this byte is always zero.
 274
 275            The second message has been determined experimentally to control
 276            whether data will be transmitted to a device which is not asserting
 277            the 'CTS' signal.  If the second message's data byte is zero, data
 278            will be transmitted even if 'CTS' is not asserted (i.e. no hardware
 279            flow control).  if the second message's data byte is nonzero (a
 280            value of 1 is used by this driver), data will not be transmitted to
 281            a device which is not asserting 'CTS'.
 282         */
 283
 284         buf[0] = 0;
 285         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 286                                 MCT_U232_SET_UNKNOWN1_REQUEST,
 287                                 MCT_U232_SET_REQUEST_TYPE,
 288                                 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
 289                                 WDR_TIMEOUT);
 290         if (rc < 0)
 291                 dev_err(&port->dev, "Sending USB device request code %d "
 292                         "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
 293                         rc);
 294
 295         if (port && C_CRTSCTS(tty))
 296            cts_enable_byte = 1;
 297
 298         dbg("set_baud_rate: send second control message, data = %02X",
 299                                                         cts_enable_byte);
 300         buf[0] = cts_enable_byte;
 301         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 302                         MCT_U232_SET_CTS_REQUEST,
 303                         MCT_U232_SET_REQUEST_TYPE,
 304                         0, 0, buf, MCT_U232_SET_CTS_SIZE,
 305                         WDR_TIMEOUT);
 306         if (rc < 0)
 307                 dev_err(&port->dev, "Sending USB device request code %d "
 308                         "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
 309
 310         kfree(buf);
 311         return rc;
 312 } /* mct_u232_set_baud_rate */
 313
 314 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
 315 {
 316         int rc;
 317         unsigned char *buf;
 318
 319         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 320         if (buf == NULL)
 321                 return -ENOMEM;
 322
 323         buf[0] = lcr;
 324         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 325                         MCT_U232_SET_LINE_CTRL_REQUEST,
 326                         MCT_U232_SET_REQUEST_TYPE,
 327                         0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
 328                         WDR_TIMEOUT);
 329         if (rc < 0)
 330                 dev_err(&serial->dev->dev,
 331                         "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
 332         dbg("set_line_ctrl: 0x%x", lcr);
 333         kfree(buf);
 334         return rc;
 335 } /* mct_u232_set_line_ctrl */
 336
 337 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
 338                                    unsigned int control_state)
 339 {
 340         int rc;
 341         unsigned char mcr;
 342         unsigned char *buf;
 343
 344         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 345         if (buf == NULL)
 346                 return -ENOMEM;
 347
 348         mcr = MCT_U232_MCR_NONE;
 349         if (control_state & TIOCM_DTR)
 350                 mcr |= MCT_U232_MCR_DTR;
 351         if (control_state & TIOCM_RTS)
 352                 mcr |= MCT_U232_MCR_RTS;
 353
 354         buf[0] = mcr;
 355         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 356                         MCT_U232_SET_MODEM_CTRL_REQUEST,
 357                         MCT_U232_SET_REQUEST_TYPE,
 358                         0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
 359                         WDR_TIMEOUT);
 360         kfree(buf);
 361
 362         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
 363
 364         if (rc < 0) {
 365                 dev_err(&serial->dev->dev,
 366                         "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
 367                 return rc;
 368         }
 369         return 0;
 370 } /* mct_u232_set_modem_ctrl */
 371
 372 static int mct_u232_get_modem_stat(struct usb_serial *serial,
 373                                                 unsigned char *msr)
 374 {
 375         int rc;
 376         unsigned char *buf;
 377
 378         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
 379         if (buf == NULL) {
 380                 *msr = 0;
 381                 return -ENOMEM;
 382         }
 383         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 384                         MCT_U232_GET_MODEM_STAT_REQUEST,
 385                         MCT_U232_GET_REQUEST_TYPE,
 386                         0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
 387                         WDR_TIMEOUT);
 388         if (rc < 0) {
 389                 dev_err(&serial->dev->dev,
 390                         "Get MODEM STATus failed (error = %d)\n", rc);
 391                 *msr = 0;
 392         } else {
 393                 *msr = buf[0];
 394         }
 395         dbg("get_modem_stat: 0x%x", *msr);
 396         kfree(buf);
 397         return rc;
 398 } /* mct_u232_get_modem_stat */
 399
 400 static void mct_u232_msr_to_icount(struct async_icount *icount,
 401                                                 unsigned char msr)
 402 {
 403         /* Translate Control Line states */
 404         if (msr & MCT_U232_MSR_DDSR)
 405                 icount->dsr++;
 406         if (msr & MCT_U232_MSR_DCTS)
 407                 icount->cts++;
 408         if (msr & MCT_U232_MSR_DRI)
 409                 icount->rng++;
 410         if (msr & MCT_U232_MSR_DCD)
 411                 icount->dcd++;
 412 } /* mct_u232_msr_to_icount */
 413
 414 static void mct_u232_msr_to_state(unsigned int *control_state,
 415                                                 unsigned char msr)
 416 {
 417         /* Translate Control Line states */
 418         if (msr & MCT_U232_MSR_DSR)
 419                 *control_state |=  TIOCM_DSR;
 420         else
 421                 *control_state &= ~TIOCM_DSR;
 422         if (msr & MCT_U232_MSR_CTS)
 423                 *control_state |=  TIOCM_CTS;
 424         else
 425                 *control_state &= ~TIOCM_CTS;
 426         if (msr & MCT_U232_MSR_RI)
 427                 *control_state |=  TIOCM_RI;
 428         else
 429                 *control_state &= ~TIOCM_RI;
 430         if (msr & MCT_U232_MSR_CD)
 431                 *control_state |=  TIOCM_CD;
 432         else
 433                 *control_state &= ~TIOCM_CD;
 434         dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
 435 } /* mct_u232_msr_to_state */
 436
 437 /*
 438  * Driver's tty interface functions
 439  */
 440
 441 static int mct_u232_startup(struct usb_serial *serial)
 442 {
 443         struct mct_u232_private *priv;
 444         struct usb_serial_port *port, *rport;
 445
 446         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 447         if (!priv)
 448                 return -ENOMEM;
 449         spin_lock_init(&priv->lock);
 450         usb_set_serial_port_data(serial->port[0], priv);
 451
 452         init_waitqueue_head(&serial->port[0]->write_wait);
 453
 454         /* Puh, that's dirty */
 455         port = serial->port[0];
 456         rport = serial->port[1];
 457         /* No unlinking, it wasn't submitted yet. */
 458         usb_free_urb(port->read_urb);
 459         port->read_urb = rport->interrupt_in_urb;
 460         rport->interrupt_in_urb = NULL;
 461         port->read_urb->context = port;
 462
 463         return 0;
 464 } /* mct_u232_startup */
 465
 466
 467 static void mct_u232_release(struct usb_serial *serial)
 468 {
 469         struct mct_u232_private *priv;
 470         int i;
 471
 472         dbg("%s", __func__);
 473
 474         for (i = 0; i < serial->num_ports; ++i) {
 475                 /* My special items, the standard routines free my urbs */
 476                 priv = usb_get_serial_port_data(serial->port[i]);
 477                 kfree(priv);
 478         }
 479 } /* mct_u232_release */
 480
 481 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 482 {
 483         struct usb_serial *serial = port->serial;
 484         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 485         int retval = 0;
 486         unsigned int control_state;
 487         unsigned long flags;
 488         unsigned char last_lcr;
 489         unsigned char last_msr;
 490
 491         dbg("%s port %d", __func__, port->number);
 492
 493         /* Compensate for a hardware bug: although the Sitecom U232-P25
 494          * device reports a maximum output packet size of 32 bytes,
 495          * it seems to be able to accept only 16 bytes (and that's what
 496          * SniffUSB says too...)
 497          */
 498         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 499                                                 == MCT_U232_SITECOM_PID)
 500                 port->bulk_out_size = 16;
 501
 502         /* Do a defined restart: the normal serial device seems to
 503          * always turn on DTR and RTS here, so do the same. I'm not
 504          * sure if this is really necessary. But it should not harm
 505          * either.
 506          */
 507         spin_lock_irqsave(&priv->lock, flags);
 508         if (tty && (tty->termios->c_cflag & CBAUD))
 509                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 510         else
 511                 priv->control_state = 0;
 512
 513         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 514                           MCT_U232_PARITY_NONE |
 515                           MCT_U232_STOP_BITS_1);
 516         control_state = priv->control_state;
 517         last_lcr = priv->last_lcr;
 518         spin_unlock_irqrestore(&priv->lock, flags);
 519         mct_u232_set_modem_ctrl(serial, control_state);
 520         mct_u232_set_line_ctrl(serial, last_lcr);
 521
 522         /* Read modem status and update control state */
 523         mct_u232_get_modem_stat(serial, &last_msr);
 524         spin_lock_irqsave(&priv->lock, flags);
 525         priv->last_msr = last_msr;
 526         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 527         spin_unlock_irqrestore(&priv->lock, flags);
 528
 529         port->read_urb->dev = port->serial->dev;
 530         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 531         if (retval) {
 532                 dev_err(&port->dev,
 533                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 534                         port->read_urb->pipe, retval);
 535                 goto error;
 536         }
 537
 538         port->interrupt_in_urb->dev = port->serial->dev;
 539         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 540         if (retval) {
 541                 usb_kill_urb(port->read_urb);
 542                 dev_err(&port->dev,
 543                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 544                         port->interrupt_in_urb->pipe, retval);
 545                 goto error;
 546         }
 547         return 0;
 548
 549 error:
 550         return retval;
 551 } /* mct_u232_open */
 552
 553 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 554 {
 555         unsigned int control_state;
 556         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 557
 558         spin_lock_irq(&priv->lock);
 559         if (on)
 560                 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 561         else
 562                 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 563         control_state = priv->control_state;
 564         spin_unlock_irq(&priv->lock);
 565
 566         mct_u232_set_modem_ctrl(port->serial, control_state);
 567 }
 568
 569 static void mct_u232_close(struct usb_serial_port *port)
 570 {
 571         dbg("%s port %d", __func__, port->number);
 572
 573         /*
 574          * Must kill the read urb as it is actually an interrupt urb, which
 575          * generic close thus fails to kill.
 576          */
 577         usb_kill_urb(port->read_urb);
 578         usb_kill_urb(port->interrupt_in_urb);
 579
 580         usb_serial_generic_close(port);
 581 } /* mct_u232_close */
 582
 583
 584 static void mct_u232_read_int_callback(struct urb *urb)
 585 {
 586         struct usb_serial_port *port = urb->context;
 587         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 588         struct usb_serial *serial = port->serial;
 589         struct tty_struct *tty;
 590         unsigned char *data = urb->transfer_buffer;
 591         int retval;
 592         int status = urb->status;
 593         unsigned long flags;
 594
 595         switch (status) {
 596         case 0:
 597                 /* success */
 598                 break;
 599         case -ECONNRESET:
 600         case -ENOENT:
 601         case -ESHUTDOWN:
 602                 /* this urb is terminated, clean up */
 603                 dbg("%s - urb shutting down with status: %d",
 604                     __func__, status);
 605                 return;
 606         default:
 607                 dbg("%s - nonzero urb status received: %d",
 608                     __func__, status);
 609                 goto exit;
 610         }
 611
 612         if (!serial) {
 613                 dbg("%s - bad serial pointer, exiting", __func__);
 614                 return;
 615         }
 616
 617         dbg("%s - port %d", __func__, port->number);
 618         usb_serial_debug_data(debug, &port->dev, __func__,
 619                                         urb->actual_length, data);
 620
 621         /*
 622          * Work-a-round: handle the 'usual' bulk-in pipe here
 623          */
 624         if (urb->transfer_buffer_length > 2) {
 625                 if (urb->actual_length) {
 626                         tty = tty_port_tty_get(&port->port);
 627                         if (tty) {
 628                                 tty_insert_flip_string(tty, data,
 629                                                 urb->actual_length);
 630                                 tty_flip_buffer_push(tty);
 631                         }
 632                         tty_kref_put(tty);
 633                 }
 634                 goto exit;
 635         }
 636
 637         /*
 638          * The interrupt-in pipe signals exceptional conditions (modem line
 639          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 640          */
 641         spin_lock_irqsave(&priv->lock, flags);
 642         priv->last_msr = data[MCT_U232_MSR_INDEX];
 643
 644         /* Record Control Line states */
 645         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 646
 647         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
 648
 649 #if 0
 650         /* Not yet handled. See belkin_sa.c for further information */
 651         /* Now to report any errors */
 652         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 653         /*
 654          * fill in the flip buffer here, but I do not know the relation
 655          * to the current/next receive buffer or characters.  I need
 656          * to look in to this before committing any code.
 657          */
 658         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 659                 tty = tty_port_tty_get(&port->port);
 660                 /* Overrun Error */
 661                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 662                 }
 663                 /* Parity Error */
 664                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 665                 }
 666                 /* Framing Error */
 667                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 668                 }
 669                 /* Break Indicator */
 670                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 671                 }
 672                 tty_kref_put(tty);
 673         }
 674 #endif
 675         wake_up_interruptible(&port->delta_msr_wait);
 676         spin_unlock_irqrestore(&priv->lock, flags);
 677 exit:
 678         retval = usb_submit_urb(urb, GFP_ATOMIC);
 679         if (retval)
 680                 dev_err(&port->dev,
 681                         "%s - usb_submit_urb failed with result %d\n",
 682                         __func__, retval);
 683 } /* mct_u232_read_int_callback */
 684
 685 static void mct_u232_set_termios(struct tty_struct *tty,
 686                                  struct usb_serial_port *port,
 687                                  struct ktermios *old_termios)
 688 {
 689         struct usb_serial *serial = port->serial;
 690         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 691         struct ktermios *termios = tty->termios;
 692         unsigned int cflag = termios->c_cflag;
 693         unsigned int old_cflag = old_termios->c_cflag;
 694         unsigned long flags;
 695         unsigned int control_state;
 696         unsigned char last_lcr;
 697
 698         /* get a local copy of the current port settings */
 699         spin_lock_irqsave(&priv->lock, flags);
 700         control_state = priv->control_state;
 701         spin_unlock_irqrestore(&priv->lock, flags);
 702         last_lcr = 0;
 703
 704         /*
 705          * Update baud rate.
 706          * Do not attempt to cache old rates and skip settings,
 707          * disconnects screw such tricks up completely.
 708          * Premature optimization is the root of all evil.
 709          */
 710
 711         /* reassert DTR and RTS on transition from B0 */
 712         if ((old_cflag & CBAUD) == B0) {
 713                 dbg("%s: baud was B0", __func__);
 714                 control_state |= TIOCM_DTR | TIOCM_RTS;
 715                 mct_u232_set_modem_ctrl(serial, control_state);
 716         }
 717
 718         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 719
 720         if ((cflag & CBAUD) == B0) {
 721                 dbg("%s: baud is B0", __func__);
 722                 /* Drop RTS and DTR */
 723                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 724                 mct_u232_set_modem_ctrl(serial, control_state);
 725         }
 726
 727         /*
 728          * Update line control register (LCR)
 729          */
 730
 731         /* set the parity */
 732         if (cflag & PARENB)
 733                 last_lcr |= (cflag & PARODD) ?
 734                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 735         else
 736                 last_lcr |= MCT_U232_PARITY_NONE;
 737
 738         /* set the number of data bits */
 739         switch (cflag & CSIZE) {
 740         case CS5:
 741                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 742         case CS6:
 743                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 744         case CS7:
 745                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 746         case CS8:
 747                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 748         default:
 749                 dev_err(&port->dev,
 750                         "CSIZE was not CS5-CS8, using default of 8\n");
 751                 last_lcr |= MCT_U232_DATA_BITS_8;
 752                 break;
 753         }
 754
 755         termios->c_cflag &= ~CMSPAR;
 756
 757         /* set the number of stop bits */
 758         last_lcr |= (cflag & CSTOPB) ?
 759                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 760
 761         mct_u232_set_line_ctrl(serial, last_lcr);
 762
 763         /* save off the modified port settings */
 764         spin_lock_irqsave(&priv->lock, flags);
 765         priv->control_state = control_state;
 766         priv->last_lcr = last_lcr;
 767         spin_unlock_irqrestore(&priv->lock, flags);
 768 } /* mct_u232_set_termios */
 769
 770 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 771 {
 772         struct usb_serial_port *port = tty->driver_data;
 773         struct usb_serial *serial = port->serial;
 774         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 775         unsigned char lcr;
 776         unsigned long flags;
 777
 778         dbg("%sstate=%d", __func__, break_state);
 779
 780         spin_lock_irqsave(&priv->lock, flags);
 781         lcr = priv->last_lcr;
 782
 783         if (break_state)
 784                 lcr |= MCT_U232_SET_BREAK;
 785         spin_unlock_irqrestore(&priv->lock, flags);
 786
 787         mct_u232_set_line_ctrl(serial, lcr);
 788 } /* mct_u232_break_ctl */
 789
 790
 791 static int mct_u232_tiocmget(struct tty_struct *tty)
 792 {
 793         struct usb_serial_port *port = tty->driver_data;
 794         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 795         unsigned int control_state;
 796         unsigned long flags;
 797
 798         dbg("%s", __func__);
 799
 800         spin_lock_irqsave(&priv->lock, flags);
 801         control_state = priv->control_state;
 802         spin_unlock_irqrestore(&priv->lock, flags);
 803
 804         return control_state;
 805 }
 806
 807 static int mct_u232_tiocmset(struct tty_struct *tty,
 808                               unsigned int set, unsigned int clear)
 809 {
 810         struct usb_serial_port *port = tty->driver_data;
 811         struct usb_serial *serial = port->serial;
 812         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 813         unsigned int control_state;
 814         unsigned long flags;
 815
 816         dbg("%s", __func__);
 817
 818         spin_lock_irqsave(&priv->lock, flags);
 819         control_state = priv->control_state;
 820
 821         if (set & TIOCM_RTS)
 822                 control_state |= TIOCM_RTS;
 823         if (set & TIOCM_DTR)
 824                 control_state |= TIOCM_DTR;
 825         if (clear & TIOCM_RTS)
 826                 control_state &= ~TIOCM_RTS;
 827         if (clear & TIOCM_DTR)
 828                 control_state &= ~TIOCM_DTR;
 829
 830         priv->control_state = control_state;
 831         spin_unlock_irqrestore(&priv->lock, flags);
 832         return mct_u232_set_modem_ctrl(serial, control_state);
 833 }
 834
 835 static void mct_u232_throttle(struct tty_struct *tty)
 836 {
 837         struct usb_serial_port *port = tty->driver_data;
 838         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 839         unsigned int control_state;
 840
 841         dbg("%s - port %d", __func__, port->number);
 842
 843         spin_lock_irq(&priv->lock);
 844         priv->rx_flags |= THROTTLED;
 845         if (C_CRTSCTS(tty)) {
 846                 priv->control_state &= ~TIOCM_RTS;
 847                 control_state = priv->control_state;
 848                 spin_unlock_irq(&priv->lock);
 849                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 850         } else {
 851                 spin_unlock_irq(&priv->lock);
 852         }
 853 }
 854
 855 static void mct_u232_unthrottle(struct tty_struct *tty)
 856 {
 857         struct usb_serial_port *port = tty->driver_data;
 858         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 859         unsigned int control_state;
 860
 861         dbg("%s - port %d", __func__, port->number);
 862
 863         spin_lock_irq(&priv->lock);
 864         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 865                 priv->rx_flags &= ~THROTTLED;
 866                 priv->control_state |= TIOCM_RTS;
 867                 control_state = priv->control_state;
 868                 spin_unlock_irq(&priv->lock);
 869                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 870         } else {
 871                 spin_unlock_irq(&priv->lock);
 872         }
 873 }
 874
 875 static int  mct_u232_ioctl(struct tty_struct *tty,
 876                         unsigned int cmd, unsigned long arg)
 877 {
 878         DEFINE_WAIT(wait);
 879         struct usb_serial_port *port = tty->driver_data;
 880         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 881         struct async_icount cnow, cprev;
 882         unsigned long flags;
 883
 884         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
 885
 886         switch (cmd) {
 887
 888         case TIOCMIWAIT:
 889
 890                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 891
 892                 spin_lock_irqsave(&mct_u232_port->lock, flags);
 893                 cprev = mct_u232_port->icount;
 894                 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 895                 for ( ; ; ) {
 896                         prepare_to_wait(&port->delta_msr_wait,
 897                                         &wait, TASK_INTERRUPTIBLE);
 898                         schedule();
 899                         finish_wait(&port->delta_msr_wait, &wait);
 900                         /* see if a signal did it */
 901                         if (signal_pending(current))
 902                                 return -ERESTARTSYS;
 903
 904                         if (port->serial->disconnected)
 905                                 return -EIO;
 906
 907                         spin_lock_irqsave(&mct_u232_port->lock, flags);
 908                         cnow = mct_u232_port->icount;
 909                         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 910                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
 911                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
 912                                 return -EIO; /* no change => error */
 913                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
 914                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
 915                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
 916                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
 917                                 return 0;
 918                         }
 919                         cprev = cnow;
 920                 }
 921
 922         }
 923         return -ENOIOCTLCMD;
 924 }
 925
 926 static int  mct_u232_get_icount(struct tty_struct *tty,
 927                         struct serial_icounter_struct *icount)
 928 {
 929         struct usb_serial_port *port = tty->driver_data;
 930         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 931         struct async_icount *ic = &mct_u232_port->icount;
 932         unsigned long flags;
 933
 934         spin_lock_irqsave(&mct_u232_port->lock, flags);
 935
 936         icount->cts = ic->cts;
 937         icount->dsr = ic->dsr;
 938         icount->rng = ic->rng;
 939         icount->dcd = ic->dcd;
 940         icount->rx = ic->rx;
 941         icount->tx = ic->tx;
 942         icount->frame = ic->frame;
 943         icount->overrun = ic->overrun;
 944         icount->parity = ic->parity;
 945         icount->brk = ic->brk;
 946         icount->buf_overrun = ic->buf_overrun;
 947
 948         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 949
 950         dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
 951                 __func__,  port->number, icount->rx, icount->tx);
 952         return 0;
 953 }
 954
 955 static int __init mct_u232_init(void)
 956 {
 957         int retval;
 958         retval = usb_serial_register(&mct_u232_device);
 959         if (retval)
 960                 goto failed_usb_serial_register;
 961         retval = usb_register(&mct_u232_driver);
 962         if (retval)
 963                 goto failed_usb_register;
 964         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 965                DRIVER_DESC "\n");
 966         return 0;
 967 failed_usb_register:
 968         usb_serial_deregister(&mct_u232_device);
 969 failed_usb_serial_register:
 970         return retval;
 971 }
 972
 973
 974 static void __exit mct_u232_exit(void)
 975 {
 976         usb_deregister(&mct_u232_driver);
 977         usb_serial_deregister(&mct_u232_device);
 978 }
 979
 980 module_init(mct_u232_init);
 981 module_exit(mct_u232_exit);
 982
 983 MODULE_AUTHOR(DRIVER_AUTHOR);
 984 MODULE_DESCRIPTION(DRIVER_DESC);
 985 MODULE_LICENSE("GPL");
 986
 987 module_param(debug, bool, S_IRUGO | S_IWUSR);
 988 MODULE_PARM_DESC(debug, "Debug enabled or not");