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         /* check first to simplify error handling */
 447         if (!serial->port[1] || !serial->port[1]->interrupt_in_urb) {
 448                 dev_err(&port->dev, "expected endpoint missing\n");
 449                 return -ENODEV;
 450         }
 451
 452         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
 453         if (!priv)
 454                 return -ENOMEM;
 455         spin_lock_init(&priv->lock);
 456         usb_set_serial_port_data(serial->port[0], priv);
 457
 458         init_waitqueue_head(&serial->port[0]->write_wait);
 459
 460         /* Puh, that's dirty */
 461         port = serial->port[0];
 462         rport = serial->port[1];
 463         /* No unlinking, it wasn't submitted yet. */
 464         usb_free_urb(port->read_urb);
 465         port->read_urb = rport->interrupt_in_urb;
 466         rport->interrupt_in_urb = NULL;
 467         port->read_urb->context = port;
 468
 469         return 0;
 470 } /* mct_u232_startup */
 471
 472
 473 static void mct_u232_release(struct usb_serial *serial)
 474 {
 475         struct mct_u232_private *priv;
 476         int i;
 477
 478         dbg("%s", __func__);
 479
 480         for (i = 0; i < serial->num_ports; ++i) {
 481                 /* My special items, the standard routines free my urbs */
 482                 priv = usb_get_serial_port_data(serial->port[i]);
 483                 kfree(priv);
 484         }
 485 } /* mct_u232_release */
 486
 487 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 488 {
 489         struct usb_serial *serial = port->serial;
 490         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 491         int retval = 0;
 492         unsigned int control_state;
 493         unsigned long flags;
 494         unsigned char last_lcr;
 495         unsigned char last_msr;
 496
 497         dbg("%s port %d", __func__, port->number);
 498
 499         /* Compensate for a hardware bug: although the Sitecom U232-P25
 500          * device reports a maximum output packet size of 32 bytes,
 501          * it seems to be able to accept only 16 bytes (and that's what
 502          * SniffUSB says too...)
 503          */
 504         if (le16_to_cpu(serial->dev->descriptor.idProduct)
 505                                                 == MCT_U232_SITECOM_PID)
 506                 port->bulk_out_size = 16;
 507
 508         /* Do a defined restart: the normal serial device seems to
 509          * always turn on DTR and RTS here, so do the same. I'm not
 510          * sure if this is really necessary. But it should not harm
 511          * either.
 512          */
 513         spin_lock_irqsave(&priv->lock, flags);
 514         if (tty && (tty->termios->c_cflag & CBAUD))
 515                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
 516         else
 517                 priv->control_state = 0;
 518
 519         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
 520                           MCT_U232_PARITY_NONE |
 521                           MCT_U232_STOP_BITS_1);
 522         control_state = priv->control_state;
 523         last_lcr = priv->last_lcr;
 524         spin_unlock_irqrestore(&priv->lock, flags);
 525         mct_u232_set_modem_ctrl(serial, control_state);
 526         mct_u232_set_line_ctrl(serial, last_lcr);
 527
 528         /* Read modem status and update control state */
 529         mct_u232_get_modem_stat(serial, &last_msr);
 530         spin_lock_irqsave(&priv->lock, flags);
 531         priv->last_msr = last_msr;
 532         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 533         spin_unlock_irqrestore(&priv->lock, flags);
 534
 535         port->read_urb->dev = port->serial->dev;
 536         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
 537         if (retval) {
 538                 dev_err(&port->dev,
 539                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
 540                         port->read_urb->pipe, retval);
 541                 goto error;
 542         }
 543
 544         port->interrupt_in_urb->dev = port->serial->dev;
 545         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 546         if (retval) {
 547                 usb_kill_urb(port->read_urb);
 548                 dev_err(&port->dev,
 549                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
 550                         port->interrupt_in_urb->pipe, retval);
 551                 goto error;
 552         }
 553         return 0;
 554
 555 error:
 556         return retval;
 557 } /* mct_u232_open */
 558
 559 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 560 {
 561         unsigned int control_state;
 562         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 563
 564         spin_lock_irq(&priv->lock);
 565         if (on)
 566                 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
 567         else
 568                 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 569         control_state = priv->control_state;
 570         spin_unlock_irq(&priv->lock);
 571
 572         mct_u232_set_modem_ctrl(port->serial, control_state);
 573 }
 574
 575 static void mct_u232_close(struct usb_serial_port *port)
 576 {
 577         dbg("%s port %d", __func__, port->number);
 578
 579         /*
 580          * Must kill the read urb as it is actually an interrupt urb, which
 581          * generic close thus fails to kill.
 582          */
 583         usb_kill_urb(port->read_urb);
 584         usb_kill_urb(port->interrupt_in_urb);
 585
 586         usb_serial_generic_close(port);
 587 } /* mct_u232_close */
 588
 589
 590 static void mct_u232_read_int_callback(struct urb *urb)
 591 {
 592         struct usb_serial_port *port = urb->context;
 593         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 594         struct usb_serial *serial = port->serial;
 595         struct tty_struct *tty;
 596         unsigned char *data = urb->transfer_buffer;
 597         int retval;
 598         int status = urb->status;
 599         unsigned long flags;
 600
 601         switch (status) {
 602         case 0:
 603                 /* success */
 604                 break;
 605         case -ECONNRESET:
 606         case -ENOENT:
 607         case -ESHUTDOWN:
 608                 /* this urb is terminated, clean up */
 609                 dbg("%s - urb shutting down with status: %d",
 610                     __func__, status);
 611                 return;
 612         default:
 613                 dbg("%s - nonzero urb status received: %d",
 614                     __func__, status);
 615                 goto exit;
 616         }
 617
 618         if (!serial) {
 619                 dbg("%s - bad serial pointer, exiting", __func__);
 620                 return;
 621         }
 622
 623         dbg("%s - port %d", __func__, port->number);
 624         usb_serial_debug_data(debug, &port->dev, __func__,
 625                                         urb->actual_length, data);
 626
 627         /*
 628          * Work-a-round: handle the 'usual' bulk-in pipe here
 629          */
 630         if (urb->transfer_buffer_length > 2) {
 631                 if (urb->actual_length) {
 632                         tty = tty_port_tty_get(&port->port);
 633                         if (tty) {
 634                                 tty_insert_flip_string(tty, data,
 635                                                 urb->actual_length);
 636                                 tty_flip_buffer_push(tty);
 637                         }
 638                         tty_kref_put(tty);
 639                 }
 640                 goto exit;
 641         }
 642
 643         /*
 644          * The interrupt-in pipe signals exceptional conditions (modem line
 645          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
 646          */
 647         spin_lock_irqsave(&priv->lock, flags);
 648         priv->last_msr = data[MCT_U232_MSR_INDEX];
 649
 650         /* Record Control Line states */
 651         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
 652
 653         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
 654
 655 #if 0
 656         /* Not yet handled. See belkin_sa.c for further information */
 657         /* Now to report any errors */
 658         priv->last_lsr = data[MCT_U232_LSR_INDEX];
 659         /*
 660          * fill in the flip buffer here, but I do not know the relation
 661          * to the current/next receive buffer or characters.  I need
 662          * to look in to this before committing any code.
 663          */
 664         if (priv->last_lsr & MCT_U232_LSR_ERR) {
 665                 tty = tty_port_tty_get(&port->port);
 666                 /* Overrun Error */
 667                 if (priv->last_lsr & MCT_U232_LSR_OE) {
 668                 }
 669                 /* Parity Error */
 670                 if (priv->last_lsr & MCT_U232_LSR_PE) {
 671                 }
 672                 /* Framing Error */
 673                 if (priv->last_lsr & MCT_U232_LSR_FE) {
 674                 }
 675                 /* Break Indicator */
 676                 if (priv->last_lsr & MCT_U232_LSR_BI) {
 677                 }
 678                 tty_kref_put(tty);
 679         }
 680 #endif
 681         wake_up_interruptible(&port->delta_msr_wait);
 682         spin_unlock_irqrestore(&priv->lock, flags);
 683 exit:
 684         retval = usb_submit_urb(urb, GFP_ATOMIC);
 685         if (retval)
 686                 dev_err(&port->dev,
 687                         "%s - usb_submit_urb failed with result %d\n",
 688                         __func__, retval);
 689 } /* mct_u232_read_int_callback */
 690
 691 static void mct_u232_set_termios(struct tty_struct *tty,
 692                                  struct usb_serial_port *port,
 693                                  struct ktermios *old_termios)
 694 {
 695         struct usb_serial *serial = port->serial;
 696         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 697         struct ktermios *termios = tty->termios;
 698         unsigned int cflag = termios->c_cflag;
 699         unsigned int old_cflag = old_termios->c_cflag;
 700         unsigned long flags;
 701         unsigned int control_state;
 702         unsigned char last_lcr;
 703
 704         /* get a local copy of the current port settings */
 705         spin_lock_irqsave(&priv->lock, flags);
 706         control_state = priv->control_state;
 707         spin_unlock_irqrestore(&priv->lock, flags);
 708         last_lcr = 0;
 709
 710         /*
 711          * Update baud rate.
 712          * Do not attempt to cache old rates and skip settings,
 713          * disconnects screw such tricks up completely.
 714          * Premature optimization is the root of all evil.
 715          */
 716
 717         /* reassert DTR and RTS on transition from B0 */
 718         if ((old_cflag & CBAUD) == B0) {
 719                 dbg("%s: baud was B0", __func__);
 720                 control_state |= TIOCM_DTR | TIOCM_RTS;
 721                 mct_u232_set_modem_ctrl(serial, control_state);
 722         }
 723
 724         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 725
 726         if ((cflag & CBAUD) == B0) {
 727                 dbg("%s: baud is B0", __func__);
 728                 /* Drop RTS and DTR */
 729                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
 730                 mct_u232_set_modem_ctrl(serial, control_state);
 731         }
 732
 733         /*
 734          * Update line control register (LCR)
 735          */
 736
 737         /* set the parity */
 738         if (cflag & PARENB)
 739                 last_lcr |= (cflag & PARODD) ?
 740                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
 741         else
 742                 last_lcr |= MCT_U232_PARITY_NONE;
 743
 744         /* set the number of data bits */
 745         switch (cflag & CSIZE) {
 746         case CS5:
 747                 last_lcr |= MCT_U232_DATA_BITS_5; break;
 748         case CS6:
 749                 last_lcr |= MCT_U232_DATA_BITS_6; break;
 750         case CS7:
 751                 last_lcr |= MCT_U232_DATA_BITS_7; break;
 752         case CS8:
 753                 last_lcr |= MCT_U232_DATA_BITS_8; break;
 754         default:
 755                 dev_err(&port->dev,
 756                         "CSIZE was not CS5-CS8, using default of 8\n");
 757                 last_lcr |= MCT_U232_DATA_BITS_8;
 758                 break;
 759         }
 760
 761         termios->c_cflag &= ~CMSPAR;
 762
 763         /* set the number of stop bits */
 764         last_lcr |= (cflag & CSTOPB) ?
 765                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 766
 767         mct_u232_set_line_ctrl(serial, last_lcr);
 768
 769         /* save off the modified port settings */
 770         spin_lock_irqsave(&priv->lock, flags);
 771         priv->control_state = control_state;
 772         priv->last_lcr = last_lcr;
 773         spin_unlock_irqrestore(&priv->lock, flags);
 774 } /* mct_u232_set_termios */
 775
 776 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 777 {
 778         struct usb_serial_port *port = tty->driver_data;
 779         struct usb_serial *serial = port->serial;
 780         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 781         unsigned char lcr;
 782         unsigned long flags;
 783
 784         dbg("%sstate=%d", __func__, break_state);
 785
 786         spin_lock_irqsave(&priv->lock, flags);
 787         lcr = priv->last_lcr;
 788
 789         if (break_state)
 790                 lcr |= MCT_U232_SET_BREAK;
 791         spin_unlock_irqrestore(&priv->lock, flags);
 792
 793         mct_u232_set_line_ctrl(serial, lcr);
 794 } /* mct_u232_break_ctl */
 795
 796
 797 static int mct_u232_tiocmget(struct tty_struct *tty)
 798 {
 799         struct usb_serial_port *port = tty->driver_data;
 800         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 801         unsigned int control_state;
 802         unsigned long flags;
 803
 804         dbg("%s", __func__);
 805
 806         spin_lock_irqsave(&priv->lock, flags);
 807         control_state = priv->control_state;
 808         spin_unlock_irqrestore(&priv->lock, flags);
 809
 810         return control_state;
 811 }
 812
 813 static int mct_u232_tiocmset(struct tty_struct *tty,
 814                               unsigned int set, unsigned int clear)
 815 {
 816         struct usb_serial_port *port = tty->driver_data;
 817         struct usb_serial *serial = port->serial;
 818         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 819         unsigned int control_state;
 820         unsigned long flags;
 821
 822         dbg("%s", __func__);
 823
 824         spin_lock_irqsave(&priv->lock, flags);
 825         control_state = priv->control_state;
 826
 827         if (set & TIOCM_RTS)
 828                 control_state |= TIOCM_RTS;
 829         if (set & TIOCM_DTR)
 830                 control_state |= TIOCM_DTR;
 831         if (clear & TIOCM_RTS)
 832                 control_state &= ~TIOCM_RTS;
 833         if (clear & TIOCM_DTR)
 834                 control_state &= ~TIOCM_DTR;
 835
 836         priv->control_state = control_state;
 837         spin_unlock_irqrestore(&priv->lock, flags);
 838         return mct_u232_set_modem_ctrl(serial, control_state);
 839 }
 840
 841 static void mct_u232_throttle(struct tty_struct *tty)
 842 {
 843         struct usb_serial_port *port = tty->driver_data;
 844         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 845         unsigned int control_state;
 846
 847         dbg("%s - port %d", __func__, port->number);
 848
 849         spin_lock_irq(&priv->lock);
 850         priv->rx_flags |= THROTTLED;
 851         if (C_CRTSCTS(tty)) {
 852                 priv->control_state &= ~TIOCM_RTS;
 853                 control_state = priv->control_state;
 854                 spin_unlock_irq(&priv->lock);
 855                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 856         } else {
 857                 spin_unlock_irq(&priv->lock);
 858         }
 859 }
 860
 861 static void mct_u232_unthrottle(struct tty_struct *tty)
 862 {
 863         struct usb_serial_port *port = tty->driver_data;
 864         struct mct_u232_private *priv = usb_get_serial_port_data(port);
 865         unsigned int control_state;
 866
 867         dbg("%s - port %d", __func__, port->number);
 868
 869         spin_lock_irq(&priv->lock);
 870         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
 871                 priv->rx_flags &= ~THROTTLED;
 872                 priv->control_state |= TIOCM_RTS;
 873                 control_state = priv->control_state;
 874                 spin_unlock_irq(&priv->lock);
 875                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
 876         } else {
 877                 spin_unlock_irq(&priv->lock);
 878         }
 879 }
 880
 881 static int  mct_u232_ioctl(struct tty_struct *tty,
 882                         unsigned int cmd, unsigned long arg)
 883 {
 884         DEFINE_WAIT(wait);
 885         struct usb_serial_port *port = tty->driver_data;
 886         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 887         struct async_icount cnow, cprev;
 888         unsigned long flags;
 889
 890         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
 891
 892         switch (cmd) {
 893
 894         case TIOCMIWAIT:
 895
 896                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
 897
 898                 spin_lock_irqsave(&mct_u232_port->lock, flags);
 899                 cprev = mct_u232_port->icount;
 900                 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 901                 for ( ; ; ) {
 902                         prepare_to_wait(&port->delta_msr_wait,
 903                                         &wait, TASK_INTERRUPTIBLE);
 904                         schedule();
 905                         finish_wait(&port->delta_msr_wait, &wait);
 906                         /* see if a signal did it */
 907                         if (signal_pending(current))
 908                                 return -ERESTARTSYS;
 909
 910                         if (port->serial->disconnected)
 911                                 return -EIO;
 912
 913                         spin_lock_irqsave(&mct_u232_port->lock, flags);
 914                         cnow = mct_u232_port->icount;
 915                         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 916                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
 917                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
 918                                 return -EIO; /* no change => error */
 919                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
 920                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
 921                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
 922                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
 923                                 return 0;
 924                         }
 925                         cprev = cnow;
 926                 }
 927
 928         }
 929         return -ENOIOCTLCMD;
 930 }
 931
 932 static int  mct_u232_get_icount(struct tty_struct *tty,
 933                         struct serial_icounter_struct *icount)
 934 {
 935         struct usb_serial_port *port = tty->driver_data;
 936         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
 937         struct async_icount *ic = &mct_u232_port->icount;
 938         unsigned long flags;
 939
 940         spin_lock_irqsave(&mct_u232_port->lock, flags);
 941
 942         icount->cts = ic->cts;
 943         icount->dsr = ic->dsr;
 944         icount->rng = ic->rng;
 945         icount->dcd = ic->dcd;
 946         icount->rx = ic->rx;
 947         icount->tx = ic->tx;
 948         icount->frame = ic->frame;
 949         icount->overrun = ic->overrun;
 950         icount->parity = ic->parity;
 951         icount->brk = ic->brk;
 952         icount->buf_overrun = ic->buf_overrun;
 953
 954         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 955
 956         dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
 957                 __func__,  port->number, icount->rx, icount->tx);
 958         return 0;
 959 }
 960
 961 static int __init mct_u232_init(void)
 962 {
 963         int retval;
 964         retval = usb_serial_register(&mct_u232_device);
 965         if (retval)
 966                 goto failed_usb_serial_register;
 967         retval = usb_register(&mct_u232_driver);
 968         if (retval)
 969                 goto failed_usb_register;
 970         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 971                DRIVER_DESC "\n");
 972         return 0;
 973 failed_usb_register:
 974         usb_serial_deregister(&mct_u232_device);
 975 failed_usb_serial_register:
 976         return retval;
 977 }
 978
 979
 980 static void __exit mct_u232_exit(void)
 981 {
 982         usb_deregister(&mct_u232_driver);
 983         usb_serial_deregister(&mct_u232_device);
 984 }
 985
 986 module_init(mct_u232_init);
 987 module_exit(mct_u232_exit);
 988
 989 MODULE_AUTHOR(DRIVER_AUTHOR);
 990 MODULE_DESCRIPTION(DRIVER_DESC);
 991 MODULE_LICENSE("GPL");
 992
 993 module_param(debug, bool, S_IRUGO | S_IWUSR);
 994 MODULE_PARM_DESC(debug, "Debug enabled or not");