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