15fd54aceSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0+
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * Belkin USB Serial Adapter Driver
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com)
61da177e4SLinus Torvalds * Copyright (C) 2000-2001 Greg Kroah-Hartman (greg@kroah.com)
72afd8287SJohan Hovold * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com)
81da177e4SLinus Torvalds *
91da177e4SLinus Torvalds * This program is largely derived from work by the linux-usb group
101da177e4SLinus Torvalds * and associated source files. Please see the usb/serial files for
111da177e4SLinus Torvalds * individual credits and copyrights.
121da177e4SLinus Torvalds *
13ecefae6dSMauro Carvalho Chehab * See Documentation/usb/usb-serial.rst for more information on using this
14b69c1499SAlan Cox * driver
151da177e4SLinus Torvalds *
161da177e4SLinus Torvalds * TODO:
17cd8c5053SRahul Bedarkar * -- Add true modem control line query capability. Currently we track the
181da177e4SLinus Torvalds * states reported by the interrupt and the states we request.
191da177e4SLinus Torvalds * -- Add support for flush commands
201da177e4SLinus Torvalds */
211da177e4SLinus Torvalds
221da177e4SLinus Torvalds #include <linux/kernel.h>
231da177e4SLinus Torvalds #include <linux/errno.h>
241da177e4SLinus Torvalds #include <linux/slab.h>
251da177e4SLinus Torvalds #include <linux/tty.h>
261da177e4SLinus Torvalds #include <linux/tty_driver.h>
271da177e4SLinus Torvalds #include <linux/tty_flip.h>
281da177e4SLinus Torvalds #include <linux/module.h>
291da177e4SLinus Torvalds #include <linux/spinlock.h>
30b69c1499SAlan Cox #include <linux/uaccess.h>
311da177e4SLinus Torvalds #include <linux/usb.h>
32a969888cSGreg Kroah-Hartman #include <linux/usb/serial.h>
331da177e4SLinus Torvalds #include "belkin_sa.h"
341da177e4SLinus Torvalds
351da177e4SLinus Torvalds #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
361da177e4SLinus Torvalds #define DRIVER_DESC "USB Belkin Serial converter driver"
371da177e4SLinus Torvalds
381da177e4SLinus Torvalds /* function prototypes for a Belkin USB Serial Adapter F5U103 */
39fa919751SJohan Hovold static int belkin_sa_port_probe(struct usb_serial_port *port);
40c5d1448fSUwe Kleine-König static void belkin_sa_port_remove(struct usb_serial_port *port);
41b69c1499SAlan Cox static int belkin_sa_open(struct tty_struct *tty,
42a509a7e4SAlan Cox struct usb_serial_port *port);
43335f8514SAlan Cox static void belkin_sa_close(struct usb_serial_port *port);
447d12e780SDavid Howells static void belkin_sa_read_int_callback(struct urb *urb);
452afd8287SJohan Hovold static void belkin_sa_process_read_urb(struct urb *urb);
46b69c1499SAlan Cox static void belkin_sa_set_termios(struct tty_struct *tty,
47f6d47fe5SIlpo Järvinen struct usb_serial_port *port,
48f6d47fe5SIlpo Järvinen const struct ktermios *old_termios);
49*6ff58ae1SJohan Hovold static int belkin_sa_break_ctl(struct tty_struct *tty, int break_state);
5060b33c13SAlan Cox static int belkin_sa_tiocmget(struct tty_struct *tty);
5120b9d177SAlan Cox static int belkin_sa_tiocmset(struct tty_struct *tty,
52b69c1499SAlan Cox unsigned int set, unsigned int clear);
531da177e4SLinus Torvalds
541da177e4SLinus Torvalds
5568e24113SGreg Kroah-Hartman static const struct usb_device_id id_table[] = {
561da177e4SLinus Torvalds { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
571da177e4SLinus Torvalds { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
581da177e4SLinus Torvalds { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
591da177e4SLinus Torvalds { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
601da177e4SLinus Torvalds { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) },
611da177e4SLinus Torvalds { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
621da177e4SLinus Torvalds { } /* Terminating entry */
631da177e4SLinus Torvalds };
6468e24113SGreg Kroah-Hartman MODULE_DEVICE_TABLE(usb, id_table);
651da177e4SLinus Torvalds
661da177e4SLinus Torvalds /* All of the device info needed for the serial converters */
67ea65370dSGreg Kroah-Hartman static struct usb_serial_driver belkin_device = {
6818fcac35SGreg Kroah-Hartman .driver = {
691da177e4SLinus Torvalds .owner = THIS_MODULE,
70269bda1cSGreg Kroah-Hartman .name = "belkin",
7118fcac35SGreg Kroah-Hartman },
72269bda1cSGreg Kroah-Hartman .description = "Belkin / Peracom / GoHubs USB Serial Adapter",
7368e24113SGreg Kroah-Hartman .id_table = id_table,
741da177e4SLinus Torvalds .num_ports = 1,
751da177e4SLinus Torvalds .open = belkin_sa_open,
761da177e4SLinus Torvalds .close = belkin_sa_close,
77b69c1499SAlan Cox .read_int_callback = belkin_sa_read_int_callback,
782afd8287SJohan Hovold .process_read_urb = belkin_sa_process_read_urb,
791da177e4SLinus Torvalds .set_termios = belkin_sa_set_termios,
801da177e4SLinus Torvalds .break_ctl = belkin_sa_break_ctl,
811da177e4SLinus Torvalds .tiocmget = belkin_sa_tiocmget,
821da177e4SLinus Torvalds .tiocmset = belkin_sa_tiocmset,
83fa919751SJohan Hovold .port_probe = belkin_sa_port_probe,
84fa919751SJohan Hovold .port_remove = belkin_sa_port_remove,
851da177e4SLinus Torvalds };
861da177e4SLinus Torvalds
8708a4f6bcSAlan Stern static struct usb_serial_driver * const serial_drivers[] = {
8808a4f6bcSAlan Stern &belkin_device, NULL
8908a4f6bcSAlan Stern };
9008a4f6bcSAlan Stern
911da177e4SLinus Torvalds struct belkin_sa_private {
921da177e4SLinus Torvalds spinlock_t lock;
931da177e4SLinus Torvalds unsigned long control_state;
941da177e4SLinus Torvalds unsigned char last_lsr;
951da177e4SLinus Torvalds unsigned char last_msr;
961da177e4SLinus Torvalds int bad_flow_control;
971da177e4SLinus Torvalds };
981da177e4SLinus Torvalds
991da177e4SLinus Torvalds
1001da177e4SLinus Torvalds /*
1011da177e4SLinus Torvalds * ***************************************************************************
1021da177e4SLinus Torvalds * Belkin USB Serial Adapter F5U103 specific driver functions
1031da177e4SLinus Torvalds * ***************************************************************************
1041da177e4SLinus Torvalds */
1051da177e4SLinus Torvalds
1061da177e4SLinus Torvalds #define WDR_TIMEOUT 5000 /* default urb timeout */
1071da177e4SLinus Torvalds
1081da177e4SLinus Torvalds /* assumes that struct usb_serial *serial is available */
1091da177e4SLinus Torvalds #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
1101da177e4SLinus Torvalds (c), BELKIN_SA_SET_REQUEST_TYPE, \
1111da177e4SLinus Torvalds (v), 0, NULL, 0, WDR_TIMEOUT)
1121da177e4SLinus Torvalds
belkin_sa_port_probe(struct usb_serial_port * port)113fa919751SJohan Hovold static int belkin_sa_port_probe(struct usb_serial_port *port)
1141da177e4SLinus Torvalds {
115fa919751SJohan Hovold struct usb_device *dev = port->serial->dev;
1161da177e4SLinus Torvalds struct belkin_sa_private *priv;
1171da177e4SLinus Torvalds
1181da177e4SLinus Torvalds priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
1191da177e4SLinus Torvalds if (!priv)
120fa919751SJohan Hovold return -ENOMEM;
121fa919751SJohan Hovold
1221da177e4SLinus Torvalds spin_lock_init(&priv->lock);
1231da177e4SLinus Torvalds priv->control_state = 0;
1241da177e4SLinus Torvalds priv->last_lsr = 0;
1251da177e4SLinus Torvalds priv->last_msr = 0;
1261da177e4SLinus Torvalds /* see comments at top of file */
127b69c1499SAlan Cox priv->bad_flow_control =
128b69c1499SAlan Cox (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
129c197a8dbSGreg Kroah-Hartman dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n",
130b69c1499SAlan Cox le16_to_cpu(dev->descriptor.bcdDevice),
131b69c1499SAlan Cox priv->bad_flow_control);
1321da177e4SLinus Torvalds
133fa919751SJohan Hovold usb_set_serial_port_data(port, priv);
1341da177e4SLinus Torvalds
135b69c1499SAlan Cox return 0;
1361da177e4SLinus Torvalds }
1371da177e4SLinus Torvalds
belkin_sa_port_remove(struct usb_serial_port * port)138c5d1448fSUwe Kleine-König static void belkin_sa_port_remove(struct usb_serial_port *port)
1391da177e4SLinus Torvalds {
140fa919751SJohan Hovold struct belkin_sa_private *priv;
1411da177e4SLinus Torvalds
142fa919751SJohan Hovold priv = usb_get_serial_port_data(port);
143fa919751SJohan Hovold kfree(priv);
1441da177e4SLinus Torvalds }
1451da177e4SLinus Torvalds
belkin_sa_open(struct tty_struct * tty,struct usb_serial_port * port)146b69c1499SAlan Cox static int belkin_sa_open(struct tty_struct *tty,
147a509a7e4SAlan Cox struct usb_serial_port *port)
1481da177e4SLinus Torvalds {
149f2f8b7feSJohan Hovold int retval;
1501da177e4SLinus Torvalds
1511da177e4SLinus Torvalds retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
1521da177e4SLinus Torvalds if (retval) {
153194343d9SGreg Kroah-Hartman dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
154f2f8b7feSJohan Hovold return retval;
1551da177e4SLinus Torvalds }
1561da177e4SLinus Torvalds
157f2f8b7feSJohan Hovold retval = usb_serial_generic_open(tty, port);
158f2f8b7feSJohan Hovold if (retval)
159f2f8b7feSJohan Hovold usb_kill_urb(port->interrupt_in_urb);
160f2f8b7feSJohan Hovold
1611da177e4SLinus Torvalds return retval;
162726ef428SJohan Hovold }
1631da177e4SLinus Torvalds
belkin_sa_close(struct usb_serial_port * port)164335f8514SAlan Cox static void belkin_sa_close(struct usb_serial_port *port)
1651da177e4SLinus Torvalds {
166f26788daSJohan Hovold usb_serial_generic_close(port);
1671da177e4SLinus Torvalds usb_kill_urb(port->interrupt_in_urb);
168726ef428SJohan Hovold }
1691da177e4SLinus Torvalds
belkin_sa_read_int_callback(struct urb * urb)1707d12e780SDavid Howells static void belkin_sa_read_int_callback(struct urb *urb)
1711da177e4SLinus Torvalds {
172cdc97792SMing Lei struct usb_serial_port *port = urb->context;
1731da177e4SLinus Torvalds struct belkin_sa_private *priv;
1741da177e4SLinus Torvalds unsigned char *data = urb->transfer_buffer;
1751da177e4SLinus Torvalds int retval;
176f26aad25SGreg Kroah-Hartman int status = urb->status;
1771da177e4SLinus Torvalds unsigned long flags;
1781da177e4SLinus Torvalds
179f26aad25SGreg Kroah-Hartman switch (status) {
1801da177e4SLinus Torvalds case 0:
1811da177e4SLinus Torvalds /* success */
1821da177e4SLinus Torvalds break;
1831da177e4SLinus Torvalds case -ECONNRESET:
1841da177e4SLinus Torvalds case -ENOENT:
1851da177e4SLinus Torvalds case -ESHUTDOWN:
1861da177e4SLinus Torvalds /* this urb is terminated, clean up */
187c89aa638SGreg Kroah-Hartman dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
188441b62c1SHarvey Harrison __func__, status);
1891da177e4SLinus Torvalds return;
1901da177e4SLinus Torvalds default:
191c89aa638SGreg Kroah-Hartman dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
192441b62c1SHarvey Harrison __func__, status);
1931da177e4SLinus Torvalds goto exit;
1941da177e4SLinus Torvalds }
1951da177e4SLinus Torvalds
19659d33f2fSGreg Kroah-Hartman usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
1971da177e4SLinus Torvalds
1981da177e4SLinus Torvalds /* Handle known interrupt data */
1991da177e4SLinus Torvalds /* ignore data[0] and data[1] */
2001da177e4SLinus Torvalds
2011da177e4SLinus Torvalds priv = usb_get_serial_port_data(port);
2021da177e4SLinus Torvalds spin_lock_irqsave(&priv->lock, flags);
2031da177e4SLinus Torvalds priv->last_msr = data[BELKIN_SA_MSR_INDEX];
2041da177e4SLinus Torvalds
2051da177e4SLinus Torvalds /* Record Control Line states */
2061da177e4SLinus Torvalds if (priv->last_msr & BELKIN_SA_MSR_DSR)
2071da177e4SLinus Torvalds priv->control_state |= TIOCM_DSR;
2081da177e4SLinus Torvalds else
2091da177e4SLinus Torvalds priv->control_state &= ~TIOCM_DSR;
2101da177e4SLinus Torvalds
2111da177e4SLinus Torvalds if (priv->last_msr & BELKIN_SA_MSR_CTS)
2121da177e4SLinus Torvalds priv->control_state |= TIOCM_CTS;
2131da177e4SLinus Torvalds else
2141da177e4SLinus Torvalds priv->control_state &= ~TIOCM_CTS;
2151da177e4SLinus Torvalds
2161da177e4SLinus Torvalds if (priv->last_msr & BELKIN_SA_MSR_RI)
2171da177e4SLinus Torvalds priv->control_state |= TIOCM_RI;
2181da177e4SLinus Torvalds else
2191da177e4SLinus Torvalds priv->control_state &= ~TIOCM_RI;
2201da177e4SLinus Torvalds
2211da177e4SLinus Torvalds if (priv->last_msr & BELKIN_SA_MSR_CD)
2221da177e4SLinus Torvalds priv->control_state |= TIOCM_CD;
2231da177e4SLinus Torvalds else
2241da177e4SLinus Torvalds priv->control_state &= ~TIOCM_CD;
2251da177e4SLinus Torvalds
2261da177e4SLinus Torvalds priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
2271da177e4SLinus Torvalds spin_unlock_irqrestore(&priv->lock, flags);
2281da177e4SLinus Torvalds exit:
2291da177e4SLinus Torvalds retval = usb_submit_urb(urb, GFP_ATOMIC);
2301da177e4SLinus Torvalds if (retval)
231194343d9SGreg Kroah-Hartman dev_err(&port->dev, "%s - usb_submit_urb failed with "
232194343d9SGreg Kroah-Hartman "result %d\n", __func__, retval);
2331da177e4SLinus Torvalds }
2341da177e4SLinus Torvalds
belkin_sa_process_read_urb(struct urb * urb)2352afd8287SJohan Hovold static void belkin_sa_process_read_urb(struct urb *urb)
2362afd8287SJohan Hovold {
2372afd8287SJohan Hovold struct usb_serial_port *port = urb->context;
2382afd8287SJohan Hovold struct belkin_sa_private *priv = usb_get_serial_port_data(port);
2392afd8287SJohan Hovold unsigned char *data = urb->transfer_buffer;
2402afd8287SJohan Hovold unsigned long flags;
2412afd8287SJohan Hovold unsigned char status;
2422afd8287SJohan Hovold char tty_flag;
2432afd8287SJohan Hovold
2442afd8287SJohan Hovold /* Update line status */
2452afd8287SJohan Hovold tty_flag = TTY_NORMAL;
2462afd8287SJohan Hovold
2472afd8287SJohan Hovold spin_lock_irqsave(&priv->lock, flags);
2482afd8287SJohan Hovold status = priv->last_lsr;
2492afd8287SJohan Hovold priv->last_lsr &= ~BELKIN_SA_LSR_ERR;
2502afd8287SJohan Hovold spin_unlock_irqrestore(&priv->lock, flags);
2512afd8287SJohan Hovold
2522afd8287SJohan Hovold if (!urb->actual_length)
2532afd8287SJohan Hovold return;
2542afd8287SJohan Hovold
2552afd8287SJohan Hovold if (status & BELKIN_SA_LSR_ERR) {
2562afd8287SJohan Hovold /* Break takes precedence over parity, which takes precedence
2572afd8287SJohan Hovold * over framing errors. */
2582afd8287SJohan Hovold if (status & BELKIN_SA_LSR_BI)
2592afd8287SJohan Hovold tty_flag = TTY_BREAK;
2602afd8287SJohan Hovold else if (status & BELKIN_SA_LSR_PE)
2612afd8287SJohan Hovold tty_flag = TTY_PARITY;
2622afd8287SJohan Hovold else if (status & BELKIN_SA_LSR_FE)
2632afd8287SJohan Hovold tty_flag = TTY_FRAME;
2642afd8287SJohan Hovold dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag);
2652afd8287SJohan Hovold
2662afd8287SJohan Hovold /* Overrun is special, not associated with a char. */
2672afd8287SJohan Hovold if (status & BELKIN_SA_LSR_OE)
26892a19f9cSJiri Slaby tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
2692afd8287SJohan Hovold }
2702afd8287SJohan Hovold
2712f693357SJiri Slaby tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
2722afd8287SJohan Hovold urb->actual_length);
2732e124b4aSJiri Slaby tty_flip_buffer_push(&port->port);
2742afd8287SJohan Hovold }
2752afd8287SJohan Hovold
belkin_sa_set_termios(struct tty_struct * tty,struct usb_serial_port * port,const struct ktermios * old_termios)27695da310eSAlan Cox static void belkin_sa_set_termios(struct tty_struct *tty,
277f6d47fe5SIlpo Järvinen struct usb_serial_port *port,
278f6d47fe5SIlpo Järvinen const struct ktermios *old_termios)
2791da177e4SLinus Torvalds {
2801da177e4SLinus Torvalds struct usb_serial *serial = port->serial;
2811da177e4SLinus Torvalds struct belkin_sa_private *priv = usb_get_serial_port_data(port);
2821da177e4SLinus Torvalds unsigned int iflag;
2831da177e4SLinus Torvalds unsigned int cflag;
2841da177e4SLinus Torvalds unsigned int old_iflag = 0;
2851da177e4SLinus Torvalds unsigned int old_cflag = 0;
2861da177e4SLinus Torvalds __u16 urb_value = 0; /* Will hold the new flags */
2871da177e4SLinus Torvalds unsigned long flags;
2881da177e4SLinus Torvalds unsigned long control_state;
2891da177e4SLinus Torvalds int bad_flow_control;
2909a8baec7SAlan Cox speed_t baud;
291adc8d746SAlan Cox struct ktermios *termios = &tty->termios;
2921da177e4SLinus Torvalds
2933ec466b4SAlan Cox iflag = termios->c_iflag;
2943ec466b4SAlan Cox cflag = termios->c_cflag;
2951da177e4SLinus Torvalds
2963ec466b4SAlan Cox termios->c_cflag &= ~CMSPAR;
2971da177e4SLinus Torvalds
2981da177e4SLinus Torvalds /* get a local copy of the current port settings */
2991da177e4SLinus Torvalds spin_lock_irqsave(&priv->lock, flags);
3001da177e4SLinus Torvalds control_state = priv->control_state;
3011da177e4SLinus Torvalds bad_flow_control = priv->bad_flow_control;
3021da177e4SLinus Torvalds spin_unlock_irqrestore(&priv->lock, flags);
3031da177e4SLinus Torvalds
3041da177e4SLinus Torvalds old_iflag = old_termios->c_iflag;
3051da177e4SLinus Torvalds old_cflag = old_termios->c_cflag;
3061da177e4SLinus Torvalds
3071da177e4SLinus Torvalds /* Set the baud rate */
3081da177e4SLinus Torvalds if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
3091da177e4SLinus Torvalds /* reassert DTR and (maybe) RTS on transition from B0 */
3101da177e4SLinus Torvalds if ((old_cflag & CBAUD) == B0) {
3111da177e4SLinus Torvalds control_state |= (TIOCM_DTR|TIOCM_RTS);
3121da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
313194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set DTR error\n");
3141da177e4SLinus Torvalds /* don't set RTS if using hardware flow control */
3151da177e4SLinus Torvalds if (!(old_cflag & CRTSCTS))
316b69c1499SAlan Cox if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
317b69c1499SAlan Cox , 1) < 0)
318194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set RTS error\n");
3191da177e4SLinus Torvalds }
3201da177e4SLinus Torvalds }
3219a8baec7SAlan Cox
32295da310eSAlan Cox baud = tty_get_baud_rate(tty);
3233ec466b4SAlan Cox if (baud) {
3249a8baec7SAlan Cox urb_value = BELKIN_SA_BAUD(baud);
3259a8baec7SAlan Cox /* Clip to maximum speed */
3269a8baec7SAlan Cox if (urb_value == 0)
3279a8baec7SAlan Cox urb_value = 1;
3289a8baec7SAlan Cox /* Turn it back into a resulting real baud rate */
3299a8baec7SAlan Cox baud = BELKIN_SA_BAUD(urb_value);
3309a8baec7SAlan Cox
3313ec466b4SAlan Cox /* Report the actual baud rate back to the caller */
33295da310eSAlan Cox tty_encode_baud_rate(tty, baud, baud);
3331da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
334194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set baudrate error\n");
3351da177e4SLinus Torvalds } else {
3361da177e4SLinus Torvalds /* Disable flow control */
337b69c1499SAlan Cox if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,
338b69c1499SAlan Cox BELKIN_SA_FLOW_NONE) < 0)
339194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Disable flowcontrol error\n");
3401da177e4SLinus Torvalds /* Drop RTS and DTR */
3411da177e4SLinus Torvalds control_state &= ~(TIOCM_DTR | TIOCM_RTS);
3421da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
343194343d9SGreg Kroah-Hartman dev_err(&port->dev, "DTR LOW error\n");
3441da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
345194343d9SGreg Kroah-Hartman dev_err(&port->dev, "RTS LOW error\n");
3461da177e4SLinus Torvalds }
3471da177e4SLinus Torvalds
3481da177e4SLinus Torvalds /* set the parity */
349b69c1499SAlan Cox if ((cflag ^ old_cflag) & (PARENB | PARODD)) {
3501da177e4SLinus Torvalds if (cflag & PARENB)
351b69c1499SAlan Cox urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD
352b69c1499SAlan Cox : BELKIN_SA_PARITY_EVEN;
3531da177e4SLinus Torvalds else
3541da177e4SLinus Torvalds urb_value = BELKIN_SA_PARITY_NONE;
3551da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
356194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set parity error\n");
3571da177e4SLinus Torvalds }
3581da177e4SLinus Torvalds
3591da177e4SLinus Torvalds /* set the number of data bits */
3601da177e4SLinus Torvalds if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
3613ec2ff37SJiri Slaby urb_value = BELKIN_SA_DATA_BITS(tty_get_char_size(cflag));
3621da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
363194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set data bits error\n");
3641da177e4SLinus Torvalds }
3651da177e4SLinus Torvalds
3661da177e4SLinus Torvalds /* set the number of stop bits */
3671da177e4SLinus Torvalds if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
368b69c1499SAlan Cox urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2)
369b69c1499SAlan Cox : BELKIN_SA_STOP_BITS(1);
370b69c1499SAlan Cox if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST,
371b69c1499SAlan Cox urb_value) < 0)
372194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set stop bits error\n");
3731da177e4SLinus Torvalds }
3741da177e4SLinus Torvalds
3751da177e4SLinus Torvalds /* Set flow control */
376b69c1499SAlan Cox if (((iflag ^ old_iflag) & (IXOFF | IXON)) ||
377b69c1499SAlan Cox ((cflag ^ old_cflag) & CRTSCTS)) {
3781da177e4SLinus Torvalds urb_value = 0;
3791da177e4SLinus Torvalds if ((iflag & IXOFF) || (iflag & IXON))
3801da177e4SLinus Torvalds urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
3811da177e4SLinus Torvalds else
3821da177e4SLinus Torvalds urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
3831da177e4SLinus Torvalds
3841da177e4SLinus Torvalds if (cflag & CRTSCTS)
3851da177e4SLinus Torvalds urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
3861da177e4SLinus Torvalds else
3871da177e4SLinus Torvalds urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
3881da177e4SLinus Torvalds
3891da177e4SLinus Torvalds if (bad_flow_control)
3901da177e4SLinus Torvalds urb_value &= ~(BELKIN_SA_FLOW_IRTS);
3911da177e4SLinus Torvalds
3921da177e4SLinus Torvalds if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
393194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set flow control error\n");
3941da177e4SLinus Torvalds }
3951da177e4SLinus Torvalds
3961da177e4SLinus Torvalds /* save off the modified port settings */
3971da177e4SLinus Torvalds spin_lock_irqsave(&priv->lock, flags);
3981da177e4SLinus Torvalds priv->control_state = control_state;
3991da177e4SLinus Torvalds spin_unlock_irqrestore(&priv->lock, flags);
400726ef428SJohan Hovold }
4011da177e4SLinus Torvalds
belkin_sa_break_ctl(struct tty_struct * tty,int break_state)402*6ff58ae1SJohan Hovold static int belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
4031da177e4SLinus Torvalds {
40495da310eSAlan Cox struct usb_serial_port *port = tty->driver_data;
4051da177e4SLinus Torvalds struct usb_serial *serial = port->serial;
406*6ff58ae1SJohan Hovold int ret;
4071da177e4SLinus Torvalds
408*6ff58ae1SJohan Hovold ret = BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0);
409*6ff58ae1SJohan Hovold if (ret < 0) {
410194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set break_ctl %d\n", break_state);
411*6ff58ae1SJohan Hovold return ret;
412*6ff58ae1SJohan Hovold }
413*6ff58ae1SJohan Hovold
414*6ff58ae1SJohan Hovold return 0;
4151da177e4SLinus Torvalds }
4161da177e4SLinus Torvalds
belkin_sa_tiocmget(struct tty_struct * tty)41760b33c13SAlan Cox static int belkin_sa_tiocmget(struct tty_struct *tty)
4181da177e4SLinus Torvalds {
41995da310eSAlan Cox struct usb_serial_port *port = tty->driver_data;
4201da177e4SLinus Torvalds struct belkin_sa_private *priv = usb_get_serial_port_data(port);
4211da177e4SLinus Torvalds unsigned long control_state;
4221da177e4SLinus Torvalds unsigned long flags;
4231da177e4SLinus Torvalds
4241da177e4SLinus Torvalds spin_lock_irqsave(&priv->lock, flags);
4251da177e4SLinus Torvalds control_state = priv->control_state;
4261da177e4SLinus Torvalds spin_unlock_irqrestore(&priv->lock, flags);
4271da177e4SLinus Torvalds
4281da177e4SLinus Torvalds return control_state;
4291da177e4SLinus Torvalds }
4301da177e4SLinus Torvalds
belkin_sa_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)43120b9d177SAlan Cox static int belkin_sa_tiocmset(struct tty_struct *tty,
4321da177e4SLinus Torvalds unsigned int set, unsigned int clear)
4331da177e4SLinus Torvalds {
43495da310eSAlan Cox struct usb_serial_port *port = tty->driver_data;
4351da177e4SLinus Torvalds struct usb_serial *serial = port->serial;
4361da177e4SLinus Torvalds struct belkin_sa_private *priv = usb_get_serial_port_data(port);
4371da177e4SLinus Torvalds unsigned long control_state;
4381da177e4SLinus Torvalds unsigned long flags;
4391da177e4SLinus Torvalds int retval;
4401da177e4SLinus Torvalds int rts = 0;
4411da177e4SLinus Torvalds int dtr = 0;
4421da177e4SLinus Torvalds
4431da177e4SLinus Torvalds spin_lock_irqsave(&priv->lock, flags);
4441da177e4SLinus Torvalds control_state = priv->control_state;
4451da177e4SLinus Torvalds
4461da177e4SLinus Torvalds if (set & TIOCM_RTS) {
4471da177e4SLinus Torvalds control_state |= TIOCM_RTS;
4481da177e4SLinus Torvalds rts = 1;
4491da177e4SLinus Torvalds }
4501da177e4SLinus Torvalds if (set & TIOCM_DTR) {
4511da177e4SLinus Torvalds control_state |= TIOCM_DTR;
4521da177e4SLinus Torvalds dtr = 1;
4531da177e4SLinus Torvalds }
4541da177e4SLinus Torvalds if (clear & TIOCM_RTS) {
4551da177e4SLinus Torvalds control_state &= ~TIOCM_RTS;
4561da177e4SLinus Torvalds rts = 0;
4571da177e4SLinus Torvalds }
4581da177e4SLinus Torvalds if (clear & TIOCM_DTR) {
4591da177e4SLinus Torvalds control_state &= ~TIOCM_DTR;
4601da177e4SLinus Torvalds dtr = 0;
4611da177e4SLinus Torvalds }
4621da177e4SLinus Torvalds
4631da177e4SLinus Torvalds priv->control_state = control_state;
4641da177e4SLinus Torvalds spin_unlock_irqrestore(&priv->lock, flags);
4651da177e4SLinus Torvalds
4661da177e4SLinus Torvalds retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
4671da177e4SLinus Torvalds if (retval < 0) {
468194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set RTS error %d\n", retval);
4691da177e4SLinus Torvalds goto exit;
4701da177e4SLinus Torvalds }
4711da177e4SLinus Torvalds
4721da177e4SLinus Torvalds retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
4731da177e4SLinus Torvalds if (retval < 0) {
474194343d9SGreg Kroah-Hartman dev_err(&port->dev, "Set DTR error %d\n", retval);
4751da177e4SLinus Torvalds goto exit;
4761da177e4SLinus Torvalds }
4771da177e4SLinus Torvalds exit:
4781da177e4SLinus Torvalds return retval;
4791da177e4SLinus Torvalds }
4801da177e4SLinus Torvalds
48168e24113SGreg Kroah-Hartman module_usb_serial_driver(serial_drivers, id_table);
4821da177e4SLinus Torvalds
4831da177e4SLinus Torvalds MODULE_AUTHOR(DRIVER_AUTHOR);
4841da177e4SLinus Torvalds MODULE_DESCRIPTION(DRIVER_DESC);
4851da177e4SLinus Torvalds MODULE_LICENSE("GPL");
486