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