blob: 3821c53fcee9ec2c269ce562ef25d7a67ed34965 [file] [log] [blame]
Paul B Schroeder3f542972006-08-31 19:41:47 -05001/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 * Clean ups from Moschip version and a few ioctl implementations by:
17 * Paul B Schroeder <pschroeder "at" uplogix "dot" com>
18 *
19 * Originally based on drivers/usb/serial/io_edgeport.c which is:
20 * Copyright (C) 2000 Inside Out Networks, All rights reserved.
21 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
22 *
23 */
24
25#include <linux/kernel.h>
26#include <linux/errno.h>
Paul B Schroeder3f542972006-08-31 19:41:47 -050027#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/serial.h>
33#include <linux/usb.h>
34#include <linux/usb/serial.h>
Alan Cox880af9d2008-07-22 11:16:12 +010035#include <linux/uaccess.h>
Paul B Schroeder3f542972006-08-31 19:41:47 -050036
Paul B Schroeder3f542972006-08-31 19:41:47 -050037#define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver"
38
39/*
40 * 16C50 UART register defines
41 */
42
43#define LCR_BITS_5 0x00 /* 5 bits/char */
44#define LCR_BITS_6 0x01 /* 6 bits/char */
45#define LCR_BITS_7 0x02 /* 7 bits/char */
46#define LCR_BITS_8 0x03 /* 8 bits/char */
47#define LCR_BITS_MASK 0x03 /* Mask for bits/char field */
48
49#define LCR_STOP_1 0x00 /* 1 stop bit */
50#define LCR_STOP_1_5 0x04 /* 1.5 stop bits (if 5 bits/char) */
51#define LCR_STOP_2 0x04 /* 2 stop bits (if 6-8 bits/char) */
52#define LCR_STOP_MASK 0x04 /* Mask for stop bits field */
53
54#define LCR_PAR_NONE 0x00 /* No parity */
55#define LCR_PAR_ODD 0x08 /* Odd parity */
56#define LCR_PAR_EVEN 0x18 /* Even parity */
57#define LCR_PAR_MARK 0x28 /* Force parity bit to 1 */
58#define LCR_PAR_SPACE 0x38 /* Force parity bit to 0 */
59#define LCR_PAR_MASK 0x38 /* Mask for parity field */
60
61#define LCR_SET_BREAK 0x40 /* Set Break condition */
62#define LCR_DL_ENABLE 0x80 /* Enable access to divisor latch */
63
64#define MCR_DTR 0x01 /* Assert DTR */
65#define MCR_RTS 0x02 /* Assert RTS */
66#define MCR_OUT1 0x04 /* Loopback only: Sets state of RI */
67#define MCR_MASTER_IE 0x08 /* Enable interrupt outputs */
68#define MCR_LOOPBACK 0x10 /* Set internal (digital) loopback mode */
69#define MCR_XON_ANY 0x20 /* Enable any char to exit XOFF mode */
70
71#define MOS7840_MSR_CTS 0x10 /* Current state of CTS */
72#define MOS7840_MSR_DSR 0x20 /* Current state of DSR */
73#define MOS7840_MSR_RI 0x40 /* Current state of RI */
74#define MOS7840_MSR_CD 0x80 /* Current state of CD */
75
76/*
77 * Defines used for sending commands to port
78 */
79
Mark Ferrell1e658482012-07-24 13:38:31 -050080#define MOS_WDR_TIMEOUT 5000 /* default urb timeout */
Paul B Schroeder3f542972006-08-31 19:41:47 -050081
82#define MOS_PORT1 0x0200
83#define MOS_PORT2 0x0300
84#define MOS_VENREG 0x0000
85#define MOS_MAX_PORT 0x02
86#define MOS_WRITE 0x0E
87#define MOS_READ 0x0D
88
89/* Requests */
90#define MCS_RD_RTYPE 0xC0
91#define MCS_WR_RTYPE 0x40
92#define MCS_RDREQ 0x0D
93#define MCS_WRREQ 0x0E
94#define MCS_CTRL_TIMEOUT 500
95#define VENDOR_READ_LENGTH (0x01)
96
97#define MAX_NAME_LEN 64
98
Alan Cox880af9d2008-07-22 11:16:12 +010099#define ZLP_REG1 0x3A /* Zero_Flag_Reg1 58 */
100#define ZLP_REG5 0x3E /* Zero_Flag_Reg5 62 */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500101
102/* For higher baud Rates use TIOCEXBAUD */
103#define TIOCEXBAUD 0x5462
104
105/* vendor id and device id defines */
106
David Ludlow11e1abb2008-02-25 17:30:52 -0500107/* The native mos7840/7820 component */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500108#define USB_VENDOR_ID_MOSCHIP 0x9710
109#define MOSCHIP_DEVICE_ID_7840 0x7840
110#define MOSCHIP_DEVICE_ID_7820 0x7820
Donald0eafe4d2012-04-19 15:00:45 +0800111#define MOSCHIP_DEVICE_ID_7810 0x7810
David Ludlow11e1abb2008-02-25 17:30:52 -0500112/* The native component can have its vendor/device id's overridden
113 * in vendor-specific implementations. Such devices can be handled
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -0700114 * by making a change here, in id_table.
David Ludlow11e1abb2008-02-25 17:30:52 -0500115 */
Dave Ludlow870408c2010-09-01 12:33:30 -0400116#define USB_VENDOR_ID_BANDB 0x0856
117#define BANDB_DEVICE_ID_USO9ML2_2 0xAC22
118#define BANDB_DEVICE_ID_USO9ML2_2P 0xBC00
119#define BANDB_DEVICE_ID_USO9ML2_4 0xAC24
120#define BANDB_DEVICE_ID_USO9ML2_4P 0xBC01
121#define BANDB_DEVICE_ID_US9ML2_2 0xAC29
122#define BANDB_DEVICE_ID_US9ML2_4 0xAC30
123#define BANDB_DEVICE_ID_USPTL4_2 0xAC31
124#define BANDB_DEVICE_ID_USPTL4_4 0xAC32
125#define BANDB_DEVICE_ID_USOPTL4_2 0xAC42
126#define BANDB_DEVICE_ID_USOPTL4_2P 0xBC02
127#define BANDB_DEVICE_ID_USOPTL4_4 0xAC44
128#define BANDB_DEVICE_ID_USOPTL4_4P 0xBC03
129#define BANDB_DEVICE_ID_USOPTL2_4 0xAC24
Paul B Schroeder3f542972006-08-31 19:41:47 -0500130
Russell Lang9d498be2009-07-17 19:29:20 +1000131/* This driver also supports
132 * ATEN UC2324 device using Moschip MCS7840
133 * ATEN UC2322 device using Moschip MCS7820
134 */
Tony Cooke9b8cff2009-04-18 22:42:18 +0930135#define USB_VENDOR_ID_ATENINTL 0x0557
136#define ATENINTL_DEVICE_ID_UC2324 0x2011
Russell Lang9d498be2009-07-17 19:29:20 +1000137#define ATENINTL_DEVICE_ID_UC2322 0x7820
Tony Cooke9b8cff2009-04-18 22:42:18 +0930138
David Ludlow11e1abb2008-02-25 17:30:52 -0500139/* Interrupt Routine Defines */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500140
141#define SERIAL_IIR_RLS 0x06
142#define SERIAL_IIR_MS 0x00
143
144/*
145 * Emulation of the bit mask on the LINE STATUS REGISTER.
146 */
147#define SERIAL_LSR_DR 0x0001
148#define SERIAL_LSR_OE 0x0002
149#define SERIAL_LSR_PE 0x0004
150#define SERIAL_LSR_FE 0x0008
151#define SERIAL_LSR_BI 0x0010
152
153#define MOS_MSR_DELTA_CTS 0x10
154#define MOS_MSR_DELTA_DSR 0x20
155#define MOS_MSR_DELTA_RI 0x40
156#define MOS_MSR_DELTA_CD 0x80
157
Alan Cox880af9d2008-07-22 11:16:12 +0100158/* Serial Port register Address */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500159#define INTERRUPT_ENABLE_REGISTER ((__u16)(0x01))
160#define FIFO_CONTROL_REGISTER ((__u16)(0x02))
161#define LINE_CONTROL_REGISTER ((__u16)(0x03))
162#define MODEM_CONTROL_REGISTER ((__u16)(0x04))
163#define LINE_STATUS_REGISTER ((__u16)(0x05))
164#define MODEM_STATUS_REGISTER ((__u16)(0x06))
165#define SCRATCH_PAD_REGISTER ((__u16)(0x07))
166#define DIVISOR_LATCH_LSB ((__u16)(0x00))
167#define DIVISOR_LATCH_MSB ((__u16)(0x01))
168
169#define CLK_MULTI_REGISTER ((__u16)(0x02))
170#define CLK_START_VALUE_REGISTER ((__u16)(0x03))
Donald Lee093ea2d2012-03-14 15:26:33 +0800171#define GPIO_REGISTER ((__u16)(0x07))
Paul B Schroeder3f542972006-08-31 19:41:47 -0500172
173#define SERIAL_LCR_DLAB ((__u16)(0x0080))
174
175/*
176 * URB POOL related defines
177 */
178#define NUM_URBS 16 /* URB Count */
179#define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */
180
Donald0eafe4d2012-04-19 15:00:45 +0800181/* LED on/off milliseconds*/
182#define LED_ON_MS 500
183#define LED_OFF_MS 500
184
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200185enum mos7840_flag {
186 MOS7840_FLAG_CTRL_BUSY,
Johan Hovold05cf0de2013-07-26 11:55:19 +0200187 MOS7840_FLAG_LED_BUSY,
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200188};
Paul B Schroeder3f542972006-08-31 19:41:47 -0500189
Tony Zelenoffb9c87662012-06-05 17:58:04 +0400190static const struct usb_device_id id_table[] = {
Paul B Schroeder3f542972006-08-31 19:41:47 -0500191 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
192 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
Donald0eafe4d2012-04-19 15:00:45 +0800193 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7810)},
Cliff Brakeacf509a2009-12-01 09:53:43 -0500194 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)},
Dave Ludlow870408c2010-09-01 12:33:30 -0400195 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P)},
Cliff Brakeacf509a2009-12-01 09:53:43 -0500196 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)},
Dave Ludlow870408c2010-09-01 12:33:30 -0400197 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P)},
Cliff Brakeacf509a2009-12-01 09:53:43 -0500198 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)},
199 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)},
200 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)},
201 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)},
David Ludlow11e1abb2008-02-25 17:30:52 -0500202 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)},
Dave Ludlow870408c2010-09-01 12:33:30 -0400203 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P)},
Cliff Brakeacf509a2009-12-01 09:53:43 -0500204 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
Dave Ludlow870408c2010-09-01 12:33:30 -0400205 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P)},
Blaise Gassend27f12812009-12-18 15:23:38 -0800206 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL2_4)},
Tony Cooke9b8cff2009-04-18 22:42:18 +0930207 {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)},
Russell Lang9d498be2009-07-17 19:29:20 +1000208 {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)},
Paul B Schroeder3f542972006-08-31 19:41:47 -0500209 {} /* terminating entry */
210};
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -0700211MODULE_DEVICE_TABLE(usb, id_table);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500212
213/* This structure holds all of the local port information */
214
215struct moschip_port {
216 int port_num; /*Actual port number in the device(1,2,etc) */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500217 struct urb *read_urb; /* read URB for this port */
218 __u8 shadowLCR; /* last LCR value received */
219 __u8 shadowMCR; /* last MCR value received */
220 char open;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100221 char open_ports;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500222 struct usb_serial_port *port; /* loop back to the owner of this object */
223
Alan Cox880af9d2008-07-22 11:16:12 +0100224 /* Offsets */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500225 __u8 SpRegOffset;
226 __u8 ControlRegOffset;
227 __u8 DcrRegOffset;
Alan Cox880af9d2008-07-22 11:16:12 +0100228 /* for processing control URBS in interrupt context */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500229 struct urb *control_urb;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100230 struct usb_ctrlrequest *dr;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500231 char *ctrl_buf;
232 int MsrLsr;
233
Oliver Neukum0de9a702007-03-16 20:28:28 +0100234 spinlock_t pool_lock;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500235 struct urb *write_urb_pool[NUM_URBS];
Oliver Neukum0de9a702007-03-16 20:28:28 +0100236 char busy[NUM_URBS];
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800237 bool read_urb_busy;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500238
Donald0eafe4d2012-04-19 15:00:45 +0800239 /* For device(s) with LED indicator */
240 bool has_led;
Donald0eafe4d2012-04-19 15:00:45 +0800241 struct timer_list led_timer1; /* Timer for LED on */
242 struct timer_list led_timer2; /* Timer for LED off */
Johan Hovold05cf0de2013-07-26 11:55:19 +0200243 struct urb *led_urb;
244 struct usb_ctrlrequest *led_dr;
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200245
246 unsigned long flags;
Donald0eafe4d2012-04-19 15:00:45 +0800247};
Paul B Schroeder3f542972006-08-31 19:41:47 -0500248
Paul B Schroeder3f542972006-08-31 19:41:47 -0500249/*
250 * mos7840_set_reg_sync
251 * To set the Control register by calling usb_fill_control_urb function
252 * by passing usb_sndctrlpipe function as parameter.
253 */
254
255static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg,
256 __u16 val)
257{
258 struct usb_device *dev = port->serial->dev;
259 val = val & 0x00ff;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700260 dev_dbg(&port->dev, "mos7840_set_reg_sync offset is %x, value %x\n", reg, val);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500261
262 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
263 MCS_WR_RTYPE, val, reg, NULL, 0,
264 MOS_WDR_TIMEOUT);
265}
266
267/*
268 * mos7840_get_reg_sync
269 * To set the Uart register by calling usb_fill_control_urb function by
270 * passing usb_rcvctrlpipe function as parameter.
271 */
272
273static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
Alan Cox880af9d2008-07-22 11:16:12 +0100274 __u16 *val)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500275{
276 struct usb_device *dev = port->serial->dev;
277 int ret = 0;
Johan Hovold9e221a32009-12-28 23:01:55 +0100278 u8 *buf;
279
280 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
281 if (!buf)
282 return -ENOMEM;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500283
284 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
Johan Hovold9e221a32009-12-28 23:01:55 +0100285 MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
Paul B Schroeder3f542972006-08-31 19:41:47 -0500286 MOS_WDR_TIMEOUT);
Johan Hovoldcd8db052017-01-12 14:56:18 +0100287 if (ret < VENDOR_READ_LENGTH) {
288 if (ret >= 0)
289 ret = -EIO;
290 goto out;
291 }
292
Johan Hovold9e221a32009-12-28 23:01:55 +0100293 *val = buf[0];
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700294 dev_dbg(&port->dev, "%s offset is %x, return val %x\n", __func__, reg, *val);
Johan Hovoldcd8db052017-01-12 14:56:18 +0100295out:
Johan Hovold9e221a32009-12-28 23:01:55 +0100296 kfree(buf);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500297 return ret;
298}
299
300/*
301 * mos7840_set_uart_reg
302 * To set the Uart register by calling usb_fill_control_urb function by
303 * passing usb_sndctrlpipe function as parameter.
304 */
305
306static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg,
307 __u16 val)
308{
309
310 struct usb_device *dev = port->serial->dev;
311 val = val & 0x00ff;
Alan Cox880af9d2008-07-22 11:16:12 +0100312 /* For the UART control registers, the application number need
313 to be Or'ed */
Oliver Neukum0de9a702007-03-16 20:28:28 +0100314 if (port->serial->num_ports == 4) {
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700315 val |= ((__u16)port->port_number + 1) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500316 } else {
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700317 if (port->port_number == 0) {
318 val |= ((__u16)port->port_number + 1) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500319 } else {
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700320 val |= ((__u16)port->port_number + 2) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500321 }
322 }
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700323 dev_dbg(&port->dev, "%s application number is %x\n", __func__, val);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500324 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
325 MCS_WR_RTYPE, val, reg, NULL, 0,
326 MOS_WDR_TIMEOUT);
327
328}
329
330/*
331 * mos7840_get_uart_reg
332 * To set the Control register by calling usb_fill_control_urb function
333 * by passing usb_rcvctrlpipe function as parameter.
334 */
335static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
Alan Cox880af9d2008-07-22 11:16:12 +0100336 __u16 *val)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500337{
338 struct usb_device *dev = port->serial->dev;
339 int ret = 0;
340 __u16 Wval;
Johan Hovold9e221a32009-12-28 23:01:55 +0100341 u8 *buf;
342
343 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
344 if (!buf)
345 return -ENOMEM;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500346
Alan Cox880af9d2008-07-22 11:16:12 +0100347 /* Wval is same as application number */
Oliver Neukum0de9a702007-03-16 20:28:28 +0100348 if (port->serial->num_ports == 4) {
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700349 Wval = ((__u16)port->port_number + 1) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500350 } else {
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700351 if (port->port_number == 0) {
352 Wval = ((__u16)port->port_number + 1) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500353 } else {
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700354 Wval = ((__u16)port->port_number + 2) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500355 }
356 }
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700357 dev_dbg(&port->dev, "%s application number is %x\n", __func__, Wval);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500358 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
Johan Hovold9e221a32009-12-28 23:01:55 +0100359 MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
Paul B Schroeder3f542972006-08-31 19:41:47 -0500360 MOS_WDR_TIMEOUT);
Johan Hovoldcd8db052017-01-12 14:56:18 +0100361 if (ret < VENDOR_READ_LENGTH) {
362 if (ret >= 0)
363 ret = -EIO;
364 goto out;
365 }
Johan Hovold9e221a32009-12-28 23:01:55 +0100366 *val = buf[0];
Johan Hovoldcd8db052017-01-12 14:56:18 +0100367out:
Johan Hovold9e221a32009-12-28 23:01:55 +0100368 kfree(buf);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500369 return ret;
370}
371
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700372static void mos7840_dump_serial_port(struct usb_serial_port *port,
373 struct moschip_port *mos7840_port)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500374{
375
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700376 dev_dbg(&port->dev, "SpRegOffset is %2x\n", mos7840_port->SpRegOffset);
377 dev_dbg(&port->dev, "ControlRegOffset is %2x\n", mos7840_port->ControlRegOffset);
378 dev_dbg(&port->dev, "DCRRegOffset is %2x\n", mos7840_port->DcrRegOffset);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500379
380}
381
382/************************************************************************/
383/************************************************************************/
384/* I N T E R F A C E F U N C T I O N S */
385/* I N T E R F A C E F U N C T I O N S */
386/************************************************************************/
387/************************************************************************/
388
389static inline void mos7840_set_port_private(struct usb_serial_port *port,
390 struct moschip_port *data)
391{
392 usb_set_serial_port_data(port, (void *)data);
393}
394
395static inline struct moschip_port *mos7840_get_port_private(struct
396 usb_serial_port
397 *port)
398{
399 return (struct moschip_port *)usb_get_serial_port_data(port);
400}
401
Oliver Neukum0de9a702007-03-16 20:28:28 +0100402static void mos7840_handle_new_msr(struct moschip_port *port, __u8 new_msr)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500403{
404 struct moschip_port *mos7840_port;
405 struct async_icount *icount;
406 mos7840_port = port;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500407 if (new_msr &
408 (MOS_MSR_DELTA_CTS | MOS_MSR_DELTA_DSR | MOS_MSR_DELTA_RI |
409 MOS_MSR_DELTA_CD)) {
Johan Hovold8c1a07f2013-03-21 12:37:16 +0100410 icount = &mos7840_port->port->icount;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500411
412 /* update input line counters */
Johan Hovoldc9fac852013-03-21 12:37:15 +0100413 if (new_msr & MOS_MSR_DELTA_CTS)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500414 icount->cts++;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100415 if (new_msr & MOS_MSR_DELTA_DSR)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500416 icount->dsr++;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100417 if (new_msr & MOS_MSR_DELTA_CD)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500418 icount->dcd++;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100419 if (new_msr & MOS_MSR_DELTA_RI)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500420 icount->rng++;
Johan Hovolde670c6a2013-03-19 09:21:19 +0100421
Johan Hovold0c6133712013-03-21 12:37:17 +0100422 wake_up_interruptible(&port->port->port.delta_msr_wait);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500423 }
Paul B Schroeder3f542972006-08-31 19:41:47 -0500424}
425
Oliver Neukum0de9a702007-03-16 20:28:28 +0100426static void mos7840_handle_new_lsr(struct moschip_port *port, __u8 new_lsr)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500427{
428 struct async_icount *icount;
429
Paul B Schroeder3f542972006-08-31 19:41:47 -0500430 if (new_lsr & SERIAL_LSR_BI) {
Alan Cox880af9d2008-07-22 11:16:12 +0100431 /*
432 * Parity and Framing errors only count if they
433 * occur exclusive of a break being
434 * received.
435 */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500436 new_lsr &= (__u8) (SERIAL_LSR_OE | SERIAL_LSR_BI);
437 }
438
439 /* update input line counters */
Johan Hovold8c1a07f2013-03-21 12:37:16 +0100440 icount = &port->port->icount;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100441 if (new_lsr & SERIAL_LSR_BI)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500442 icount->brk++;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100443 if (new_lsr & SERIAL_LSR_OE)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500444 icount->overrun++;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100445 if (new_lsr & SERIAL_LSR_PE)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500446 icount->parity++;
Johan Hovoldc9fac852013-03-21 12:37:15 +0100447 if (new_lsr & SERIAL_LSR_FE)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500448 icount->frame++;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500449}
450
451/************************************************************************/
452/************************************************************************/
453/* U S B C A L L B A C K F U N C T I O N S */
454/* U S B C A L L B A C K F U N C T I O N S */
455/************************************************************************/
456/************************************************************************/
457
David Howells7d12e782006-10-05 14:55:46 +0100458static void mos7840_control_callback(struct urb *urb)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500459{
460 unsigned char *data;
461 struct moschip_port *mos7840_port;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700462 struct device *dev = &urb->dev->dev;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500463 __u8 regval = 0x0;
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700464 int status = urb->status;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500465
Ming Leicdc97792008-02-24 18:41:47 +0800466 mos7840_port = urb->context;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100467
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700468 switch (status) {
Paul B Schroeder3f542972006-08-31 19:41:47 -0500469 case 0:
470 /* success */
471 break;
472 case -ECONNRESET:
473 case -ENOENT:
474 case -ESHUTDOWN:
475 /* this urb is terminated, clean up */
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700476 dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200477 goto out;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500478 default:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700479 dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200480 goto out;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500481 }
482
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700483 dev_dbg(dev, "%s urb buffer size is %d\n", __func__, urb->actual_length);
484 dev_dbg(dev, "%s mos7840_port->MsrLsr is %d port %d\n", __func__,
485 mos7840_port->MsrLsr, mos7840_port->port_num);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500486 data = urb->transfer_buffer;
487 regval = (__u8) data[0];
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700488 dev_dbg(dev, "%s data is %x\n", __func__, regval);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500489 if (mos7840_port->MsrLsr == 0)
490 mos7840_handle_new_msr(mos7840_port, regval);
491 else if (mos7840_port->MsrLsr == 1)
492 mos7840_handle_new_lsr(mos7840_port, regval);
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200493out:
494 clear_bit_unlock(MOS7840_FLAG_CTRL_BUSY, &mos7840_port->flags);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500495}
496
497static int mos7840_get_reg(struct moschip_port *mcs, __u16 Wval, __u16 reg,
Alan Cox880af9d2008-07-22 11:16:12 +0100498 __u16 *val)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500499{
500 struct usb_device *dev = mcs->port->serial->dev;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100501 struct usb_ctrlrequest *dr = mcs->dr;
502 unsigned char *buffer = mcs->ctrl_buf;
503 int ret;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500504
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200505 if (test_and_set_bit_lock(MOS7840_FLAG_CTRL_BUSY, &mcs->flags))
506 return -EBUSY;
507
Paul B Schroeder3f542972006-08-31 19:41:47 -0500508 dr->bRequestType = MCS_RD_RTYPE;
509 dr->bRequest = MCS_RDREQ;
Alan Cox880af9d2008-07-22 11:16:12 +0100510 dr->wValue = cpu_to_le16(Wval); /* 0 */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500511 dr->wIndex = cpu_to_le16(reg);
512 dr->wLength = cpu_to_le16(2);
513
514 usb_fill_control_urb(mcs->control_urb, dev, usb_rcvctrlpipe(dev, 0),
515 (unsigned char *)dr, buffer, 2,
516 mos7840_control_callback, mcs);
517 mcs->control_urb->transfer_buffer_length = 2;
518 ret = usb_submit_urb(mcs->control_urb, GFP_ATOMIC);
Johan Hovoldd8a083c2013-07-26 11:55:17 +0200519 if (ret)
520 clear_bit_unlock(MOS7840_FLAG_CTRL_BUSY, &mcs->flags);
521
Paul B Schroeder3f542972006-08-31 19:41:47 -0500522 return ret;
523}
524
Donald0eafe4d2012-04-19 15:00:45 +0800525static void mos7840_set_led_callback(struct urb *urb)
526{
527 switch (urb->status) {
528 case 0:
529 /* Success */
530 break;
531 case -ECONNRESET:
532 case -ENOENT:
533 case -ESHUTDOWN:
534 /* This urb is terminated, clean up */
Johan Hovoldd9a38a82014-03-12 19:09:42 +0100535 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n",
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700536 __func__, urb->status);
Donald0eafe4d2012-04-19 15:00:45 +0800537 break;
538 default:
Johan Hovoldd9a38a82014-03-12 19:09:42 +0100539 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n",
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700540 __func__, urb->status);
Donald0eafe4d2012-04-19 15:00:45 +0800541 }
542}
543
544static void mos7840_set_led_async(struct moschip_port *mcs, __u16 wval,
545 __u16 reg)
546{
547 struct usb_device *dev = mcs->port->serial->dev;
Johan Hovold05cf0de2013-07-26 11:55:19 +0200548 struct usb_ctrlrequest *dr = mcs->led_dr;
Donald0eafe4d2012-04-19 15:00:45 +0800549
550 dr->bRequestType = MCS_WR_RTYPE;
551 dr->bRequest = MCS_WRREQ;
552 dr->wValue = cpu_to_le16(wval);
553 dr->wIndex = cpu_to_le16(reg);
554 dr->wLength = cpu_to_le16(0);
555
Johan Hovold05cf0de2013-07-26 11:55:19 +0200556 usb_fill_control_urb(mcs->led_urb, dev, usb_sndctrlpipe(dev, 0),
Donald0eafe4d2012-04-19 15:00:45 +0800557 (unsigned char *)dr, NULL, 0, mos7840_set_led_callback, NULL);
558
Johan Hovold05cf0de2013-07-26 11:55:19 +0200559 usb_submit_urb(mcs->led_urb, GFP_ATOMIC);
Donald0eafe4d2012-04-19 15:00:45 +0800560}
561
562static void mos7840_set_led_sync(struct usb_serial_port *port, __u16 reg,
563 __u16 val)
564{
565 struct usb_device *dev = port->serial->dev;
566
567 usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, MCS_WR_RTYPE,
568 val, reg, NULL, 0, MOS_WDR_TIMEOUT);
569}
570
571static void mos7840_led_off(unsigned long arg)
572{
573 struct moschip_port *mcs = (struct moschip_port *) arg;
574
575 /* Turn off LED */
576 mos7840_set_led_async(mcs, 0x0300, MODEM_CONTROL_REGISTER);
577 mod_timer(&mcs->led_timer2,
578 jiffies + msecs_to_jiffies(LED_OFF_MS));
579}
580
581static void mos7840_led_flag_off(unsigned long arg)
582{
583 struct moschip_port *mcs = (struct moschip_port *) arg;
584
Johan Hovold05cf0de2013-07-26 11:55:19 +0200585 clear_bit_unlock(MOS7840_FLAG_LED_BUSY, &mcs->flags);
586}
587
588static void mos7840_led_activity(struct usb_serial_port *port)
589{
590 struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
591
592 if (test_and_set_bit_lock(MOS7840_FLAG_LED_BUSY, &mos7840_port->flags))
593 return;
594
595 mos7840_set_led_async(mos7840_port, 0x0301, MODEM_CONTROL_REGISTER);
596 mod_timer(&mos7840_port->led_timer1,
597 jiffies + msecs_to_jiffies(LED_ON_MS));
Donald0eafe4d2012-04-19 15:00:45 +0800598}
599
Paul B Schroeder3f542972006-08-31 19:41:47 -0500600/*****************************************************************************
601 * mos7840_interrupt_callback
602 * this is the callback function for when we have received data on the
603 * interrupt endpoint.
604 *****************************************************************************/
605
David Howells7d12e782006-10-05 14:55:46 +0100606static void mos7840_interrupt_callback(struct urb *urb)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500607{
608 int result;
609 int length;
610 struct moschip_port *mos7840_port;
611 struct usb_serial *serial;
612 __u16 Data;
613 unsigned char *data;
614 __u8 sp[5], st;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100615 int i, rv = 0;
616 __u16 wval, wreg = 0;
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700617 int status = urb->status;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500618
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700619 switch (status) {
Paul B Schroeder3f542972006-08-31 19:41:47 -0500620 case 0:
621 /* success */
622 break;
623 case -ECONNRESET:
624 case -ENOENT:
625 case -ESHUTDOWN:
626 /* this urb is terminated, clean up */
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700627 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
628 __func__, status);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500629 return;
630 default:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700631 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
632 __func__, status);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500633 goto exit;
634 }
635
636 length = urb->actual_length;
637 data = urb->transfer_buffer;
638
Ming Leicdc97792008-02-24 18:41:47 +0800639 serial = urb->context;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500640
641 /* Moschip get 5 bytes
642 * Byte 1 IIR Port 1 (port.number is 0)
643 * Byte 2 IIR Port 2 (port.number is 1)
644 * Byte 3 IIR Port 3 (port.number is 2)
645 * Byte 4 IIR Port 4 (port.number is 3)
646 * Byte 5 FIFO status for both */
647
Geyslan G. Bem365a0442015-12-11 06:46:42 -0300648 if (length > 5) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700649 dev_dbg(&urb->dev->dev, "%s", "Wrong data !!!\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -0500650 return;
651 }
652
653 sp[0] = (__u8) data[0];
654 sp[1] = (__u8) data[1];
655 sp[2] = (__u8) data[2];
656 sp[3] = (__u8) data[3];
657 st = (__u8) data[4];
658
659 for (i = 0; i < serial->num_ports; i++) {
660 mos7840_port = mos7840_get_port_private(serial->port[i]);
Greg Kroah-Hartman11438322013-06-06 10:32:00 -0700661 wval = ((__u16)serial->port[i]->port_number + 1) << 8;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500662 if (mos7840_port->open) {
663 if (sp[i] & 0x01) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700664 dev_dbg(&urb->dev->dev, "SP%d No Interrupt !!!\n", i);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500665 } else {
666 switch (sp[i] & 0x0f) {
667 case SERIAL_IIR_RLS:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700668 dev_dbg(&urb->dev->dev, "Serial Port %d: Receiver status error or \n", i);
669 dev_dbg(&urb->dev->dev, "address bit detected in 9-bit mode\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -0500670 mos7840_port->MsrLsr = 1;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100671 wreg = LINE_STATUS_REGISTER;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500672 break;
673 case SERIAL_IIR_MS:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700674 dev_dbg(&urb->dev->dev, "Serial Port %d: Modem status change\n", i);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500675 mos7840_port->MsrLsr = 0;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100676 wreg = MODEM_STATUS_REGISTER;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500677 break;
678 }
Johan Hovolde681b662012-10-25 18:56:33 +0200679 rv = mos7840_get_reg(mos7840_port, wval, wreg, &Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500680 }
681 }
682 }
Alan Cox880af9d2008-07-22 11:16:12 +0100683 if (!(rv < 0))
684 /* the completion handler for the control urb will resubmit */
Oliver Neukum0de9a702007-03-16 20:28:28 +0100685 return;
686exit:
Paul B Schroeder3f542972006-08-31 19:41:47 -0500687 result = usb_submit_urb(urb, GFP_ATOMIC);
688 if (result) {
689 dev_err(&urb->dev->dev,
690 "%s - Error %d submitting interrupt urb\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800691 __func__, result);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500692 }
Paul B Schroeder3f542972006-08-31 19:41:47 -0500693}
694
695static int mos7840_port_paranoia_check(struct usb_serial_port *port,
696 const char *function)
697{
698 if (!port) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700699 pr_debug("%s - port == NULL\n", function);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500700 return -1;
701 }
702 if (!port->serial) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700703 pr_debug("%s - port->serial == NULL\n", function);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500704 return -1;
705 }
706
707 return 0;
708}
709
710/* Inline functions to check the sanity of a pointer that is passed to us */
711static int mos7840_serial_paranoia_check(struct usb_serial *serial,
712 const char *function)
713{
714 if (!serial) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700715 pr_debug("%s - serial == NULL\n", function);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500716 return -1;
717 }
718 if (!serial->type) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700719 pr_debug("%s - serial->type == NULL!\n", function);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500720 return -1;
721 }
722
723 return 0;
724}
725
726static struct usb_serial *mos7840_get_usb_serial(struct usb_serial_port *port,
727 const char *function)
728{
729 /* if no port was specified, or it fails a paranoia check */
730 if (!port ||
731 mos7840_port_paranoia_check(port, function) ||
732 mos7840_serial_paranoia_check(port->serial, function)) {
Alan Cox880af9d2008-07-22 11:16:12 +0100733 /* then say that we don't have a valid usb_serial thing,
734 * which will end up genrating -ENODEV return values */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500735 return NULL;
736 }
737
738 return port->serial;
739}
740
741/*****************************************************************************
742 * mos7840_bulk_in_callback
743 * this is the callback function for when we have received data on the
744 * bulk in endpoint.
745 *****************************************************************************/
746
David Howells7d12e782006-10-05 14:55:46 +0100747static void mos7840_bulk_in_callback(struct urb *urb)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500748{
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700749 int retval;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500750 unsigned char *data;
751 struct usb_serial *serial;
752 struct usb_serial_port *port;
753 struct moschip_port *mos7840_port;
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700754 int status = urb->status;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500755
Ming Leicdc97792008-02-24 18:41:47 +0800756 mos7840_port = urb->context;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700757 if (!mos7840_port)
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800758 return;
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800759
760 if (status) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700761 dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800762 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500763 return;
764 }
765
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700766 port = mos7840_port->port;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800767 if (mos7840_port_paranoia_check(port, __func__)) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800768 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500769 return;
770 }
771
Harvey Harrison441b62c2008-03-03 16:08:34 -0800772 serial = mos7840_get_usb_serial(port, __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500773 if (!serial) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800774 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500775 return;
776 }
777
Paul B Schroeder3f542972006-08-31 19:41:47 -0500778 data = urb->transfer_buffer;
Greg Kroah-Hartman59d33f22012-09-18 09:58:57 +0100779 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500780
Paul B Schroeder3f542972006-08-31 19:41:47 -0500781 if (urb->actual_length) {
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100782 struct tty_port *tport = &mos7840_port->port->port;
Jiri Slaby2e124b42013-01-03 15:53:06 +0100783 tty_insert_flip_string(tport, data, urb->actual_length);
784 tty_flip_buffer_push(tport);
Johan Hovold8c1a07f2013-03-21 12:37:16 +0100785 port->icount.rx += urb->actual_length;
786 dev_dbg(&port->dev, "icount.rx is %d:\n", port->icount.rx);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500787 }
788
789 if (!mos7840_port->read_urb) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700790 dev_dbg(&port->dev, "%s", "URB KILLED !!!\n");
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800791 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500792 return;
793 }
794
Johan Hovold05cf0de2013-07-26 11:55:19 +0200795 if (mos7840_port->has_led)
796 mos7840_led_activity(port);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500797
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800798 mos7840_port->read_urb_busy = true;
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700799 retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
Oliver Neukum0de9a702007-03-16 20:28:28 +0100800
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700801 if (retval) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700802 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800803 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500804 }
805}
806
807/*****************************************************************************
808 * mos7840_bulk_out_data_callback
Alan Cox880af9d2008-07-22 11:16:12 +0100809 * this is the callback function for when we have finished sending
810 * serial data on the bulk out endpoint.
Paul B Schroeder3f542972006-08-31 19:41:47 -0500811 *****************************************************************************/
812
David Howells7d12e782006-10-05 14:55:46 +0100813static void mos7840_bulk_out_data_callback(struct urb *urb)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500814{
815 struct moschip_port *mos7840_port;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700816 struct usb_serial_port *port;
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700817 int status = urb->status;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100818 int i;
819
Ming Leicdc97792008-02-24 18:41:47 +0800820 mos7840_port = urb->context;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700821 port = mos7840_port->port;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100822 spin_lock(&mos7840_port->pool_lock);
823 for (i = 0; i < NUM_URBS; i++) {
824 if (urb == mos7840_port->write_urb_pool[i]) {
825 mos7840_port->busy[i] = 0;
826 break;
827 }
828 }
829 spin_unlock(&mos7840_port->pool_lock);
830
Greg Kroah-Hartman0643c722007-06-15 15:44:13 -0700831 if (status) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700832 dev_dbg(&port->dev, "nonzero write bulk status received:%d\n", status);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500833 return;
834 }
835
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700836 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -0500837 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500838
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100839 if (mos7840_port->open)
840 tty_port_tty_wakeup(&port->port);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500841
842}
843
844/************************************************************************/
845/* D R I V E R T T Y I N T E R F A C E F U N C T I O N S */
846/************************************************************************/
Paul B Schroeder3f542972006-08-31 19:41:47 -0500847
848/*****************************************************************************
849 * mos7840_open
850 * this function is called by the tty driver when a port is opened
851 * If successful, we return 0
852 * Otherwise we return a negative error number.
853 *****************************************************************************/
854
Alan Coxa509a7e2009-09-19 13:13:26 -0700855static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500856{
857 int response;
858 int j;
859 struct usb_serial *serial;
860 struct urb *urb;
861 __u16 Data;
862 int status;
863 struct moschip_port *mos7840_port;
Oliver Neukum0de9a702007-03-16 20:28:28 +0100864 struct moschip_port *port0;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500865
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700866 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -0500867 return -ENODEV;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500868
Paul B Schroeder3f542972006-08-31 19:41:47 -0500869 serial = port->serial;
870
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700871 if (mos7840_serial_paranoia_check(serial, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -0500872 return -ENODEV;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500873
874 mos7840_port = mos7840_get_port_private(port);
Oliver Neukum0de9a702007-03-16 20:28:28 +0100875 port0 = mos7840_get_port_private(serial->port[0]);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500876
Oliver Neukum0de9a702007-03-16 20:28:28 +0100877 if (mos7840_port == NULL || port0 == NULL)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500878 return -ENODEV;
879
880 usb_clear_halt(serial->dev, port->write_urb->pipe);
881 usb_clear_halt(serial->dev, port->read_urb->pipe);
Oliver Neukum0de9a702007-03-16 20:28:28 +0100882 port0->open_ports++;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500883
884 /* Initialising the write urb pool */
885 for (j = 0; j < NUM_URBS; ++j) {
Oliver Neukum0de9a702007-03-16 20:28:28 +0100886 urb = usb_alloc_urb(0, GFP_KERNEL);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500887 mos7840_port->write_urb_pool[j] = urb;
Johan Hovold10c642d2013-12-29 19:22:56 +0100888 if (!urb)
Paul B Schroeder3f542972006-08-31 19:41:47 -0500889 continue;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500890
Alan Cox880af9d2008-07-22 11:16:12 +0100891 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
892 GFP_KERNEL);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500893 if (!urb->transfer_buffer) {
Oliver Neukum0de9a702007-03-16 20:28:28 +0100894 usb_free_urb(urb);
895 mos7840_port->write_urb_pool[j] = NULL;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500896 continue;
897 }
898 }
899
900/*****************************************************************************
901 * Initialize MCS7840 -- Write Init values to corresponding Registers
902 *
903 * Register Index
904 * 1 : IER
905 * 2 : FCR
906 * 3 : LCR
907 * 4 : MCR
908 *
909 * 0x08 : SP1/2 Control Reg
910 *****************************************************************************/
911
Alan Cox880af9d2008-07-22 11:16:12 +0100912 /* NEED to check the following Block */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500913
Paul B Schroeder3f542972006-08-31 19:41:47 -0500914 Data = 0x0;
915 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
916 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700917 dev_dbg(&port->dev, "Reading Spreg failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200918 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500919 }
920 Data |= 0x80;
921 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
922 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700923 dev_dbg(&port->dev, "writing Spreg failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200924 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500925 }
926
927 Data &= ~0x80;
928 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
929 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700930 dev_dbg(&port->dev, "writing Spreg failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200931 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500932 }
Alan Cox880af9d2008-07-22 11:16:12 +0100933 /* End of block to be checked */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500934
Paul B Schroeder3f542972006-08-31 19:41:47 -0500935 Data = 0x0;
Alan Cox880af9d2008-07-22 11:16:12 +0100936 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
937 &Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500938 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700939 dev_dbg(&port->dev, "Reading Controlreg failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200940 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500941 }
Alan Cox880af9d2008-07-22 11:16:12 +0100942 Data |= 0x08; /* Driver done bit */
943 Data |= 0x20; /* rx_disable */
944 status = mos7840_set_reg_sync(port,
945 mos7840_port->ControlRegOffset, Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -0500946 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700947 dev_dbg(&port->dev, "writing Controlreg failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200948 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500949 }
Alan Cox880af9d2008-07-22 11:16:12 +0100950 /* do register settings here */
951 /* Set all regs to the device default values. */
952 /***********************************
953 * First Disable all interrupts.
954 ***********************************/
Paul B Schroeder3f542972006-08-31 19:41:47 -0500955 Data = 0x00;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500956 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
957 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700958 dev_dbg(&port->dev, "disabling interrupts failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200959 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500960 }
Alan Cox880af9d2008-07-22 11:16:12 +0100961 /* Set FIFO_CONTROL_REGISTER to the default value */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500962 Data = 0x00;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500963 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
964 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700965 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200966 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500967 }
968
969 Data = 0xcf;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500970 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
971 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -0700972 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER failed\n");
Johan Hovold5f8a2e62013-07-01 14:03:33 +0200973 goto err;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500974 }
975
976 Data = 0x03;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500977 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
978 mos7840_port->shadowLCR = Data;
979
980 Data = 0x0b;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500981 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
982 mos7840_port->shadowMCR = Data;
983
984 Data = 0x00;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500985 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
986 mos7840_port->shadowLCR = Data;
987
Alan Cox880af9d2008-07-22 11:16:12 +0100988 Data |= SERIAL_LCR_DLAB; /* data latch enable in LCR 0x80 */
Paul B Schroeder3f542972006-08-31 19:41:47 -0500989 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
990
991 Data = 0x0c;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500992 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
993
994 Data = 0x0;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500995 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
996
997 Data = 0x00;
Paul B Schroeder3f542972006-08-31 19:41:47 -0500998 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
999
1000 Data = Data & ~SERIAL_LCR_DLAB;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001001 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1002 mos7840_port->shadowLCR = Data;
1003
Alan Cox880af9d2008-07-22 11:16:12 +01001004 /* clearing Bulkin and Bulkout Fifo */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001005 Data = 0x0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001006 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
1007
1008 Data = Data | 0x0c;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001009 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
1010
1011 Data = Data & ~0x0c;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001012 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
Alan Cox880af9d2008-07-22 11:16:12 +01001013 /* Finally enable all interrupts */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001014 Data = 0x0c;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001015 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1016
Alan Cox880af9d2008-07-22 11:16:12 +01001017 /* clearing rx_disable */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001018 Data = 0x0;
Alan Cox880af9d2008-07-22 11:16:12 +01001019 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
1020 &Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001021 Data = Data & ~0x20;
Alan Cox880af9d2008-07-22 11:16:12 +01001022 status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
1023 Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001024
Alan Cox880af9d2008-07-22 11:16:12 +01001025 /* rx_negate */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001026 Data = 0x0;
Alan Cox880af9d2008-07-22 11:16:12 +01001027 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
1028 &Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001029 Data = Data | 0x10;
Alan Cox880af9d2008-07-22 11:16:12 +01001030 status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
1031 Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001032
Alan Cox880af9d2008-07-22 11:16:12 +01001033 /* Check to see if we've set up our endpoint info yet *
1034 * (can't set it up in mos7840_startup as the structures *
1035 * were not set up at that time.) */
Oliver Neukum0de9a702007-03-16 20:28:28 +01001036 if (port0->open_ports == 1) {
Johan Hovold5182c2c2017-02-09 12:11:41 +01001037 /* FIXME: Buffer never NULL, so URB is not submitted. */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001038 if (serial->port[0]->interrupt_in_buffer == NULL) {
Paul B Schroeder3f542972006-08-31 19:41:47 -05001039 /* set up interrupt urb */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001040 usb_fill_int_urb(serial->port[0]->interrupt_in_urb,
Alan Cox880af9d2008-07-22 11:16:12 +01001041 serial->dev,
1042 usb_rcvintpipe(serial->dev,
1043 serial->port[0]->interrupt_in_endpointAddress),
1044 serial->port[0]->interrupt_in_buffer,
1045 serial->port[0]->interrupt_in_urb->
1046 transfer_buffer_length,
1047 mos7840_interrupt_callback,
1048 serial,
1049 serial->port[0]->interrupt_in_urb->interval);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001050
Johan Hovold472d7e52017-01-03 16:39:57 +01001051 /* start interrupt read for mos7840 */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001052 response =
1053 usb_submit_urb(serial->port[0]->interrupt_in_urb,
1054 GFP_KERNEL);
1055 if (response) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001056 dev_err(&port->dev, "%s - Error %d submitting "
1057 "interrupt urb\n", __func__, response);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001058 }
1059
1060 }
1061
1062 }
1063
1064 /* see if we've set up our endpoint info yet *
1065 * (can't set it up in mos7840_startup as the *
1066 * structures were not set up at that time.) */
1067
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001068 dev_dbg(&port->dev, "port number is %d\n", port->port_number);
Greg Kroah-Hartmane5b1e202013-06-07 11:04:28 -07001069 dev_dbg(&port->dev, "minor number is %d\n", port->minor);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001070 dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
1071 dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
1072 dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
1073 dev_dbg(&port->dev, "port's number in the device is %d\n", mos7840_port->port_num);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001074 mos7840_port->read_urb = port->read_urb;
1075
1076 /* set up our bulk in urb */
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001077 if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
Donald Lee093ea2d2012-03-14 15:26:33 +08001078 usb_fill_bulk_urb(mos7840_port->read_urb,
1079 serial->dev,
1080 usb_rcvbulkpipe(serial->dev,
1081 (port->bulk_in_endpointAddress) + 2),
1082 port->bulk_in_buffer,
1083 mos7840_port->read_urb->transfer_buffer_length,
1084 mos7840_bulk_in_callback, mos7840_port);
1085 } else {
1086 usb_fill_bulk_urb(mos7840_port->read_urb,
1087 serial->dev,
1088 usb_rcvbulkpipe(serial->dev,
1089 port->bulk_in_endpointAddress),
1090 port->bulk_in_buffer,
1091 mos7840_port->read_urb->transfer_buffer_length,
1092 mos7840_bulk_in_callback, mos7840_port);
1093 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001094
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001095 dev_dbg(&port->dev, "%s: bulkin endpoint is %d\n", __func__, port->bulk_in_endpointAddress);
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001096 mos7840_port->read_urb_busy = true;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001097 response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1098 if (response) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001099 dev_err(&port->dev, "%s - Error %d submitting control urb\n",
1100 __func__, response);
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001101 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001102 }
1103
Paul B Schroeder3f542972006-08-31 19:41:47 -05001104 /* initialize our port settings */
Alan Cox880af9d2008-07-22 11:16:12 +01001105 /* Must set to enable ints! */
1106 mos7840_port->shadowMCR = MCR_MASTER_IE;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001107 /* send a open port command */
1108 mos7840_port->open = 1;
Alan Cox880af9d2008-07-22 11:16:12 +01001109 /* mos7840_change_port_settings(mos7840_port,old_termios); */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001110
Paul B Schroeder3f542972006-08-31 19:41:47 -05001111 return 0;
Johan Hovold5f8a2e62013-07-01 14:03:33 +02001112err:
1113 for (j = 0; j < NUM_URBS; ++j) {
1114 urb = mos7840_port->write_urb_pool[j];
1115 if (!urb)
1116 continue;
1117 kfree(urb->transfer_buffer);
1118 usb_free_urb(urb);
1119 }
1120 return status;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001121}
1122
1123/*****************************************************************************
1124 * mos7840_chars_in_buffer
1125 * this function is called by the tty driver when it wants to know how many
1126 * bytes of data we currently have outstanding in the port (data that has
1127 * been written, but hasn't made it out the port yet)
1128 * If successful, we return the number of bytes left to be written in the
1129 * system,
Alan Cox95da3102008-07-22 11:09:07 +01001130 * Otherwise we return zero.
Paul B Schroeder3f542972006-08-31 19:41:47 -05001131 *****************************************************************************/
1132
Alan Cox95da3102008-07-22 11:09:07 +01001133static int mos7840_chars_in_buffer(struct tty_struct *tty)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001134{
Alan Cox95da3102008-07-22 11:09:07 +01001135 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001136 int i;
1137 int chars = 0;
Oliver Neukum0de9a702007-03-16 20:28:28 +01001138 unsigned long flags;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001139 struct moschip_port *mos7840_port;
1140
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001141 if (mos7840_port_paranoia_check(port, __func__))
Alan Cox95da3102008-07-22 11:09:07 +01001142 return 0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001143
1144 mos7840_port = mos7840_get_port_private(port);
Greg Kroah-Hartman33631552012-05-03 16:44:33 -07001145 if (mos7840_port == NULL)
Alan Cox95da3102008-07-22 11:09:07 +01001146 return 0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001147
Alan Cox880af9d2008-07-22 11:16:12 +01001148 spin_lock_irqsave(&mos7840_port->pool_lock, flags);
Mark Ferrell5c263b92012-07-24 14:15:13 -05001149 for (i = 0; i < NUM_URBS; ++i) {
1150 if (mos7840_port->busy[i]) {
1151 struct urb *urb = mos7840_port->write_urb_pool[i];
1152 chars += urb->transfer_buffer_length;
1153 }
1154 }
Alan Cox880af9d2008-07-22 11:16:12 +01001155 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001156 dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
Oliver Neukum0de9a702007-03-16 20:28:28 +01001157 return chars;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001158
1159}
1160
Paul B Schroeder3f542972006-08-31 19:41:47 -05001161/*****************************************************************************
1162 * mos7840_close
1163 * this function is called by the tty driver when a port is closed
1164 *****************************************************************************/
1165
Alan Cox335f8512009-06-11 12:26:29 +01001166static void mos7840_close(struct usb_serial_port *port)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001167{
1168 struct usb_serial *serial;
1169 struct moschip_port *mos7840_port;
Oliver Neukum0de9a702007-03-16 20:28:28 +01001170 struct moschip_port *port0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001171 int j;
1172 __u16 Data;
1173
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001174 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001175 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001176
Harvey Harrison441b62c2008-03-03 16:08:34 -08001177 serial = mos7840_get_usb_serial(port, __func__);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001178 if (!serial)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001179 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001180
1181 mos7840_port = mos7840_get_port_private(port);
Oliver Neukum0de9a702007-03-16 20:28:28 +01001182 port0 = mos7840_get_port_private(serial->port[0]);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001183
Oliver Neukum0de9a702007-03-16 20:28:28 +01001184 if (mos7840_port == NULL || port0 == NULL)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001185 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001186
1187 for (j = 0; j < NUM_URBS; ++j)
1188 usb_kill_urb(mos7840_port->write_urb_pool[j]);
1189
1190 /* Freeing Write URBs */
1191 for (j = 0; j < NUM_URBS; ++j) {
1192 if (mos7840_port->write_urb_pool[j]) {
Fabian Frederick91c72df2014-06-28 14:44:09 +02001193 kfree(mos7840_port->write_urb_pool[j]->transfer_buffer);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001194 usb_free_urb(mos7840_port->write_urb_pool[j]);
1195 }
1196 }
1197
Johan Hovoldbb3529c2013-03-21 12:36:35 +01001198 usb_kill_urb(mos7840_port->read_urb);
1199 mos7840_port->read_urb_busy = false;
1200
Oliver Neukum0de9a702007-03-16 20:28:28 +01001201 port0->open_ports--;
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001202 dev_dbg(&port->dev, "%s in close%d\n", __func__, port0->open_ports);
Oliver Neukum0de9a702007-03-16 20:28:28 +01001203 if (port0->open_ports == 0) {
Paul B Schroeder3f542972006-08-31 19:41:47 -05001204 if (serial->port[0]->interrupt_in_urb) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001205 dev_dbg(&port->dev, "Shutdown interrupt_in_urb\n");
Oliver Neukum0de9a702007-03-16 20:28:28 +01001206 usb_kill_urb(serial->port[0]->interrupt_in_urb);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001207 }
1208 }
1209
Paul B Schroeder3f542972006-08-31 19:41:47 -05001210 Data = 0x0;
1211 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1212
1213 Data = 0x00;
1214 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1215
1216 mos7840_port->open = 0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001217}
1218
Paul B Schroeder3f542972006-08-31 19:41:47 -05001219/*****************************************************************************
1220 * mos7840_break
1221 * this function sends a break to the port
1222 *****************************************************************************/
Alan Cox95da3102008-07-22 11:09:07 +01001223static void mos7840_break(struct tty_struct *tty, int break_state)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001224{
Alan Cox95da3102008-07-22 11:09:07 +01001225 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001226 unsigned char data;
1227 struct usb_serial *serial;
1228 struct moschip_port *mos7840_port;
1229
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001230 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001231 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001232
Harvey Harrison441b62c2008-03-03 16:08:34 -08001233 serial = mos7840_get_usb_serial(port, __func__);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001234 if (!serial)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001235 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001236
1237 mos7840_port = mos7840_get_port_private(port);
1238
Alan Cox880af9d2008-07-22 11:16:12 +01001239 if (mos7840_port == NULL)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001240 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001241
Alan Cox95da3102008-07-22 11:09:07 +01001242 if (break_state == -1)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001243 data = mos7840_port->shadowLCR | LCR_SET_BREAK;
Alan Cox95da3102008-07-22 11:09:07 +01001244 else
Paul B Schroeder3f542972006-08-31 19:41:47 -05001245 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001246
Alan Cox6b447f042009-01-02 13:48:56 +00001247 /* FIXME: no locking on shadowLCR anywhere in driver */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001248 mos7840_port->shadowLCR = data;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001249 dev_dbg(&port->dev, "%s mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001250 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
1251 mos7840_port->shadowLCR);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001252}
1253
1254/*****************************************************************************
1255 * mos7840_write_room
1256 * this function is called by the tty driver when it wants to know how many
1257 * bytes of data we can accept for a specific port.
1258 * If successful, we return the amount of room that we have for this port
1259 * Otherwise we return a negative error number.
1260 *****************************************************************************/
1261
Alan Cox95da3102008-07-22 11:09:07 +01001262static int mos7840_write_room(struct tty_struct *tty)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001263{
Alan Cox95da3102008-07-22 11:09:07 +01001264 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001265 int i;
1266 int room = 0;
Oliver Neukum0de9a702007-03-16 20:28:28 +01001267 unsigned long flags;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001268 struct moschip_port *mos7840_port;
1269
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001270 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001271 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001272
1273 mos7840_port = mos7840_get_port_private(port);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001274 if (mos7840_port == NULL)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001275 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001276
Oliver Neukum0de9a702007-03-16 20:28:28 +01001277 spin_lock_irqsave(&mos7840_port->pool_lock, flags);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001278 for (i = 0; i < NUM_URBS; ++i) {
Alan Cox880af9d2008-07-22 11:16:12 +01001279 if (!mos7840_port->busy[i])
Paul B Schroeder3f542972006-08-31 19:41:47 -05001280 room += URB_TRANSFER_BUFFER_SIZE;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001281 }
Oliver Neukum0de9a702007-03-16 20:28:28 +01001282 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001283
Oliver Neukum0de9a702007-03-16 20:28:28 +01001284 room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001285 dev_dbg(&mos7840_port->port->dev, "%s - returns %d\n", __func__, room);
Oliver Neukum0de9a702007-03-16 20:28:28 +01001286 return room;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001287
1288}
1289
1290/*****************************************************************************
1291 * mos7840_write
1292 * this function is called by the tty driver when data should be written to
1293 * the port.
1294 * If successful, we return the number of bytes written, otherwise we
1295 * return a negative error number.
1296 *****************************************************************************/
1297
Alan Cox95da3102008-07-22 11:09:07 +01001298static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
Paul B Schroeder3f542972006-08-31 19:41:47 -05001299 const unsigned char *data, int count)
1300{
1301 int status;
1302 int i;
1303 int bytes_sent = 0;
1304 int transfer_size;
Oliver Neukum0de9a702007-03-16 20:28:28 +01001305 unsigned long flags;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001306
1307 struct moschip_port *mos7840_port;
1308 struct usb_serial *serial;
1309 struct urb *urb;
Alan Cox880af9d2008-07-22 11:16:12 +01001310 /* __u16 Data; */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001311 const unsigned char *current_position = data;
1312 unsigned char *data1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001313
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001314 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001315 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001316
1317 serial = port->serial;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001318 if (mos7840_serial_paranoia_check(serial, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001319 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001320
1321 mos7840_port = mos7840_get_port_private(port);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001322 if (mos7840_port == NULL)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001323 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001324
1325 /* try to find a free urb in the list */
1326 urb = NULL;
1327
Oliver Neukum0de9a702007-03-16 20:28:28 +01001328 spin_lock_irqsave(&mos7840_port->pool_lock, flags);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001329 for (i = 0; i < NUM_URBS; ++i) {
Oliver Neukum0de9a702007-03-16 20:28:28 +01001330 if (!mos7840_port->busy[i]) {
1331 mos7840_port->busy[i] = 1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001332 urb = mos7840_port->write_urb_pool[i];
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001333 dev_dbg(&port->dev, "URB:%d\n", i);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001334 break;
1335 }
1336 }
Oliver Neukum0de9a702007-03-16 20:28:28 +01001337 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001338
1339 if (urb == NULL) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001340 dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001341 goto exit;
1342 }
1343
1344 if (urb->transfer_buffer == NULL) {
Alexey Khoroshilov3b7c7e52016-08-12 01:05:09 +03001345 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
1346 GFP_ATOMIC);
Johan Hovold10c642d2013-12-29 19:22:56 +01001347 if (!urb->transfer_buffer)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001348 goto exit;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001349 }
1350 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1351
Al Viro97c49652006-10-09 20:29:03 +01001352 memcpy(urb->transfer_buffer, current_position, transfer_size);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001353
1354 /* fill urb with data and submit */
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001355 if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
Donald Lee093ea2d2012-03-14 15:26:33 +08001356 usb_fill_bulk_urb(urb,
1357 serial->dev,
1358 usb_sndbulkpipe(serial->dev,
1359 (port->bulk_out_endpointAddress) + 2),
1360 urb->transfer_buffer,
1361 transfer_size,
1362 mos7840_bulk_out_data_callback, mos7840_port);
1363 } else {
1364 usb_fill_bulk_urb(urb,
1365 serial->dev,
1366 usb_sndbulkpipe(serial->dev,
1367 port->bulk_out_endpointAddress),
1368 urb->transfer_buffer,
1369 transfer_size,
1370 mos7840_bulk_out_data_callback, mos7840_port);
1371 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001372
1373 data1 = urb->transfer_buffer;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001374 dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001375
Johan Hovold05cf0de2013-07-26 11:55:19 +02001376 if (mos7840_port->has_led)
1377 mos7840_led_activity(port);
Donald0eafe4d2012-04-19 15:00:45 +08001378
Paul B Schroeder3f542972006-08-31 19:41:47 -05001379 /* send it down the pipe */
1380 status = usb_submit_urb(urb, GFP_ATOMIC);
1381
1382 if (status) {
Oliver Neukum0de9a702007-03-16 20:28:28 +01001383 mos7840_port->busy[i] = 0;
Johan Hovold22a416c2012-02-10 13:20:51 +01001384 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001385 "with status = %d\n", __func__, status);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001386 bytes_sent = status;
1387 goto exit;
1388 }
1389 bytes_sent = transfer_size;
Johan Hovold8c1a07f2013-03-21 12:37:16 +01001390 port->icount.tx += transfer_size;
1391 dev_dbg(&port->dev, "icount.tx is %d:\n", port->icount.tx);
Alan Cox95da3102008-07-22 11:09:07 +01001392exit:
Paul B Schroeder3f542972006-08-31 19:41:47 -05001393 return bytes_sent;
1394
1395}
1396
1397/*****************************************************************************
1398 * mos7840_throttle
1399 * this function is called by the tty driver when it wants to stop the data
1400 * being read from the port.
1401 *****************************************************************************/
1402
Alan Cox95da3102008-07-22 11:09:07 +01001403static void mos7840_throttle(struct tty_struct *tty)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001404{
Alan Cox95da3102008-07-22 11:09:07 +01001405 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001406 struct moschip_port *mos7840_port;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001407 int status;
1408
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001409 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001410 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001411
1412 mos7840_port = mos7840_get_port_private(port);
1413
1414 if (mos7840_port == NULL)
1415 return;
1416
1417 if (!mos7840_port->open) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001418 dev_dbg(&port->dev, "%s", "port not opened\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001419 return;
1420 }
1421
Paul B Schroeder3f542972006-08-31 19:41:47 -05001422 /* if we are implementing XON/XOFF, send the stop character */
1423 if (I_IXOFF(tty)) {
1424 unsigned char stop_char = STOP_CHAR(tty);
Alan Cox95da3102008-07-22 11:09:07 +01001425 status = mos7840_write(tty, port, &stop_char, 1);
1426 if (status <= 0)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001427 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001428 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001429 /* if we are implementing RTS/CTS, toggle that line */
Peter Hurley9db276f2016-01-10 20:36:15 -08001430 if (C_CRTSCTS(tty)) {
Paul B Schroeder3f542972006-08-31 19:41:47 -05001431 mos7840_port->shadowMCR &= ~MCR_RTS;
Alan Cox95da3102008-07-22 11:09:07 +01001432 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
Paul B Schroeder3f542972006-08-31 19:41:47 -05001433 mos7840_port->shadowMCR);
Alan Cox95da3102008-07-22 11:09:07 +01001434 if (status < 0)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001435 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001436 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001437}
1438
1439/*****************************************************************************
1440 * mos7840_unthrottle
Alan Cox880af9d2008-07-22 11:16:12 +01001441 * this function is called by the tty driver when it wants to resume
1442 * the data being read from the port (called after mos7840_throttle is
1443 * called)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001444 *****************************************************************************/
Alan Cox95da3102008-07-22 11:09:07 +01001445static void mos7840_unthrottle(struct tty_struct *tty)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001446{
Alan Cox95da3102008-07-22 11:09:07 +01001447 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001448 int status;
1449 struct moschip_port *mos7840_port = mos7840_get_port_private(port);
1450
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001451 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001452 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001453
1454 if (mos7840_port == NULL)
1455 return;
1456
1457 if (!mos7840_port->open) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001458 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001459 return;
1460 }
1461
Paul B Schroeder3f542972006-08-31 19:41:47 -05001462 /* if we are implementing XON/XOFF, send the start character */
1463 if (I_IXOFF(tty)) {
1464 unsigned char start_char = START_CHAR(tty);
Alan Cox95da3102008-07-22 11:09:07 +01001465 status = mos7840_write(tty, port, &start_char, 1);
1466 if (status <= 0)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001467 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001468 }
1469
1470 /* if we are implementing RTS/CTS, toggle that line */
Peter Hurley9db276f2016-01-10 20:36:15 -08001471 if (C_CRTSCTS(tty)) {
Paul B Schroeder3f542972006-08-31 19:41:47 -05001472 mos7840_port->shadowMCR |= MCR_RTS;
Alan Cox95da3102008-07-22 11:09:07 +01001473 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
Paul B Schroeder3f542972006-08-31 19:41:47 -05001474 mos7840_port->shadowMCR);
Alan Cox95da3102008-07-22 11:09:07 +01001475 if (status < 0)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001476 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001477 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001478}
1479
Alan Cox60b33c12011-02-14 16:26:14 +00001480static int mos7840_tiocmget(struct tty_struct *tty)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001481{
Alan Cox95da3102008-07-22 11:09:07 +01001482 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001483 struct moschip_port *mos7840_port;
1484 unsigned int result;
1485 __u16 msr;
1486 __u16 mcr;
Alan Cox880af9d2008-07-22 11:16:12 +01001487 int status;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001488 mos7840_port = mos7840_get_port_private(port);
1489
Paul B Schroeder3f542972006-08-31 19:41:47 -05001490 if (mos7840_port == NULL)
1491 return -ENODEV;
1492
1493 status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
Johan Hovoldcd8db052017-01-12 14:56:18 +01001494 if (status < 0)
Johan Hovolda91ccd22013-10-09 17:01:09 +02001495 return -EIO;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001496 status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
Johan Hovoldcd8db052017-01-12 14:56:18 +01001497 if (status < 0)
Johan Hovolda91ccd22013-10-09 17:01:09 +02001498 return -EIO;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001499 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
1500 | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
1501 | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
1502 | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)
1503 | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)
1504 | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
1505 | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
1506
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001507 dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001508
1509 return result;
1510}
1511
Alan Cox20b9d172011-02-14 16:26:50 +00001512static int mos7840_tiocmset(struct tty_struct *tty,
Paul B Schroeder3f542972006-08-31 19:41:47 -05001513 unsigned int set, unsigned int clear)
1514{
Alan Cox95da3102008-07-22 11:09:07 +01001515 struct usb_serial_port *port = tty->driver_data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001516 struct moschip_port *mos7840_port;
1517 unsigned int mcr;
Roel Kluin87521c42008-04-17 06:16:24 +02001518 int status;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001519
Paul B Schroeder3f542972006-08-31 19:41:47 -05001520 mos7840_port = mos7840_get_port_private(port);
1521
1522 if (mos7840_port == NULL)
1523 return -ENODEV;
1524
Alan Coxe2984492008-02-20 20:51:45 +00001525 /* FIXME: What locks the port registers ? */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001526 mcr = mos7840_port->shadowMCR;
1527 if (clear & TIOCM_RTS)
1528 mcr &= ~MCR_RTS;
1529 if (clear & TIOCM_DTR)
1530 mcr &= ~MCR_DTR;
1531 if (clear & TIOCM_LOOP)
1532 mcr &= ~MCR_LOOPBACK;
1533
1534 if (set & TIOCM_RTS)
1535 mcr |= MCR_RTS;
1536 if (set & TIOCM_DTR)
1537 mcr |= MCR_DTR;
1538 if (set & TIOCM_LOOP)
1539 mcr |= MCR_LOOPBACK;
1540
1541 mos7840_port->shadowMCR = mcr;
1542
Paul B Schroeder3f542972006-08-31 19:41:47 -05001543 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
1544 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001545 dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n");
Roel Kluin87521c42008-04-17 06:16:24 +02001546 return status;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001547 }
1548
1549 return 0;
1550}
1551
1552/*****************************************************************************
1553 * mos7840_calc_baud_rate_divisor
1554 * this function calculates the proper baud rate divisor for the specified
1555 * baud rate.
1556 *****************************************************************************/
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001557static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
1558 int baudRate, int *divisor,
Alan Cox880af9d2008-07-22 11:16:12 +01001559 __u16 *clk_sel_val)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001560{
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001561 dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001562
1563 if (baudRate <= 115200) {
1564 *divisor = 115200 / baudRate;
1565 *clk_sel_val = 0x0;
1566 }
1567 if ((baudRate > 115200) && (baudRate <= 230400)) {
1568 *divisor = 230400 / baudRate;
1569 *clk_sel_val = 0x10;
1570 } else if ((baudRate > 230400) && (baudRate <= 403200)) {
1571 *divisor = 403200 / baudRate;
1572 *clk_sel_val = 0x20;
1573 } else if ((baudRate > 403200) && (baudRate <= 460800)) {
1574 *divisor = 460800 / baudRate;
1575 *clk_sel_val = 0x30;
1576 } else if ((baudRate > 460800) && (baudRate <= 806400)) {
1577 *divisor = 806400 / baudRate;
1578 *clk_sel_val = 0x40;
1579 } else if ((baudRate > 806400) && (baudRate <= 921600)) {
1580 *divisor = 921600 / baudRate;
1581 *clk_sel_val = 0x50;
1582 } else if ((baudRate > 921600) && (baudRate <= 1572864)) {
1583 *divisor = 1572864 / baudRate;
1584 *clk_sel_val = 0x60;
1585 } else if ((baudRate > 1572864) && (baudRate <= 3145728)) {
1586 *divisor = 3145728 / baudRate;
1587 *clk_sel_val = 0x70;
1588 }
1589 return 0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001590}
1591
1592/*****************************************************************************
1593 * mos7840_send_cmd_write_baud_rate
1594 * this function sends the proper command to change the baud rate of the
1595 * specified port.
1596 *****************************************************************************/
1597
1598static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
1599 int baudRate)
1600{
1601 int divisor = 0;
1602 int status;
1603 __u16 Data;
1604 unsigned char number;
1605 __u16 clk_sel_val;
1606 struct usb_serial_port *port;
1607
1608 if (mos7840_port == NULL)
1609 return -1;
1610
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001611 port = mos7840_port->port;
1612 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001613 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001614
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001615 if (mos7840_serial_paranoia_check(port->serial, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001616 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001617
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001618 number = mos7840_port->port->port_number;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001619
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001620 dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudRate);
Alan Cox880af9d2008-07-22 11:16:12 +01001621 /* reset clk_uart_sel in spregOffset */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001622 if (baudRate > 115200) {
1623#ifdef HW_flow_control
Alan Cox880af9d2008-07-22 11:16:12 +01001624 /* NOTE: need to see the pther register to modify */
1625 /* setting h/w flow control bit to 1 */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001626 Data = 0x2b;
1627 mos7840_port->shadowMCR = Data;
Alan Cox880af9d2008-07-22 11:16:12 +01001628 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1629 Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001630 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001631 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001632 return -1;
1633 }
1634#endif
1635
1636 } else {
1637#ifdef HW_flow_control
Donald Lee093ea2d2012-03-14 15:26:33 +08001638 /* setting h/w flow control bit to 0 */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001639 Data = 0xb;
1640 mos7840_port->shadowMCR = Data;
Alan Cox880af9d2008-07-22 11:16:12 +01001641 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1642 Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001643 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001644 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001645 return -1;
1646 }
1647#endif
1648
1649 }
1650
Alan Cox880af9d2008-07-22 11:16:12 +01001651 if (1) { /* baudRate <= 115200) */
Paul B Schroeder3f542972006-08-31 19:41:47 -05001652 clk_sel_val = 0x0;
1653 Data = 0x0;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001654 status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor,
Paul B Schroeder3f542972006-08-31 19:41:47 -05001655 &clk_sel_val);
Alan Cox880af9d2008-07-22 11:16:12 +01001656 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
1657 &Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001658 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001659 dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001660 return -1;
1661 }
1662 Data = (Data & 0x8f) | clk_sel_val;
Alan Cox880af9d2008-07-22 11:16:12 +01001663 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
1664 Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001665 if (status < 0) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001666 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001667 return -1;
1668 }
1669 /* Calculate the Divisor */
1670
1671 if (status) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001672 dev_err(&port->dev, "%s - bad baud rate\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001673 return status;
1674 }
1675 /* Enable access to divisor latch */
1676 Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB;
1677 mos7840_port->shadowLCR = Data;
1678 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1679
1680 /* Write the divisor */
1681 Data = (unsigned char)(divisor & 0xff);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001682 dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001683 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1684
1685 Data = (unsigned char)((divisor & 0xff00) >> 8);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001686 dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001687 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1688
1689 /* Disable access to divisor latch */
1690 Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB;
1691 mos7840_port->shadowLCR = Data;
1692 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1693
1694 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001695 return status;
1696}
1697
1698/*****************************************************************************
1699 * mos7840_change_port_settings
1700 * This routine is called to set the UART on the device to match
1701 * the specified new settings.
1702 *****************************************************************************/
1703
Alan Cox95da3102008-07-22 11:09:07 +01001704static void mos7840_change_port_settings(struct tty_struct *tty,
1705 struct moschip_port *mos7840_port, struct ktermios *old_termios)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001706{
Paul B Schroeder3f542972006-08-31 19:41:47 -05001707 int baud;
1708 unsigned cflag;
1709 unsigned iflag;
1710 __u8 lData;
1711 __u8 lParity;
1712 __u8 lStop;
1713 int status;
1714 __u16 Data;
1715 struct usb_serial_port *port;
1716 struct usb_serial *serial;
1717
1718 if (mos7840_port == NULL)
1719 return;
1720
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001721 port = mos7840_port->port;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001722
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001723 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001724 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001725
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001726 if (mos7840_serial_paranoia_check(port->serial, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001727 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001728
1729 serial = port->serial;
1730
Paul B Schroeder3f542972006-08-31 19:41:47 -05001731 if (!mos7840_port->open) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001732 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001733 return;
1734 }
1735
Paul B Schroeder3f542972006-08-31 19:41:47 -05001736 lData = LCR_BITS_8;
1737 lStop = LCR_STOP_1;
1738 lParity = LCR_PAR_NONE;
1739
Alan Coxadc8d742012-07-14 15:31:47 +01001740 cflag = tty->termios.c_cflag;
1741 iflag = tty->termios.c_iflag;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001742
1743 /* Change the number of bits */
Colin Leitner78692cc2013-11-08 22:52:34 +01001744 switch (cflag & CSIZE) {
1745 case CS5:
1746 lData = LCR_BITS_5;
1747 break;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001748
Colin Leitner78692cc2013-11-08 22:52:34 +01001749 case CS6:
1750 lData = LCR_BITS_6;
1751 break;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001752
Colin Leitner78692cc2013-11-08 22:52:34 +01001753 case CS7:
1754 lData = LCR_BITS_7;
1755 break;
1756
1757 default:
1758 case CS8:
1759 lData = LCR_BITS_8;
1760 break;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001761 }
Colin Leitner78692cc2013-11-08 22:52:34 +01001762
Paul B Schroeder3f542972006-08-31 19:41:47 -05001763 /* Change the Parity bit */
1764 if (cflag & PARENB) {
1765 if (cflag & PARODD) {
1766 lParity = LCR_PAR_ODD;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001767 dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001768 } else {
1769 lParity = LCR_PAR_EVEN;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001770 dev_dbg(&port->dev, "%s - parity = even\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001771 }
1772
1773 } else {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001774 dev_dbg(&port->dev, "%s - parity = none\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001775 }
1776
Alan Cox880af9d2008-07-22 11:16:12 +01001777 if (cflag & CMSPAR)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001778 lParity = lParity | 0x20;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001779
1780 /* Change the Stop bit */
1781 if (cflag & CSTOPB) {
1782 lStop = LCR_STOP_2;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001783 dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001784 } else {
1785 lStop = LCR_STOP_1;
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001786 dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001787 }
1788
1789 /* Update the LCR with the correct value */
1790 mos7840_port->shadowLCR &=
1791 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1792 mos7840_port->shadowLCR |= (lData | lParity | lStop);
1793
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001794 dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__,
1795 mos7840_port->shadowLCR);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001796 /* Disable Interrupts */
1797 Data = 0x00;
1798 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1799
1800 Data = 0x00;
1801 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1802
1803 Data = 0xcf;
1804 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1805
1806 /* Send the updated LCR value to the mos7840 */
1807 Data = mos7840_port->shadowLCR;
1808
1809 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1810
1811 Data = 0x00b;
1812 mos7840_port->shadowMCR = Data;
1813 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1814 Data = 0x00b;
1815 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1816
1817 /* set up the MCR register and send it to the mos7840 */
1818
1819 mos7840_port->shadowMCR = MCR_MASTER_IE;
Alan Cox880af9d2008-07-22 11:16:12 +01001820 if (cflag & CBAUD)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001821 mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001822
Alan Cox880af9d2008-07-22 11:16:12 +01001823 if (cflag & CRTSCTS)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001824 mos7840_port->shadowMCR |= (MCR_XON_ANY);
Alan Cox880af9d2008-07-22 11:16:12 +01001825 else
Paul B Schroeder3f542972006-08-31 19:41:47 -05001826 mos7840_port->shadowMCR &= ~(MCR_XON_ANY);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001827
1828 Data = mos7840_port->shadowMCR;
1829 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1830
1831 /* Determine divisor based on baud rate */
1832 baud = tty_get_baud_rate(tty);
1833
1834 if (!baud) {
1835 /* pick a default, any default... */
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001836 dev_dbg(&port->dev, "%s", "Picked default baud...\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001837 baud = 9600;
1838 }
1839
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001840 dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001841 status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
1842
1843 /* Enable Interrupts */
1844 Data = 0x0c;
1845 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1846
Mathieu OTHACEHEce9d8562016-02-04 19:01:29 +01001847 if (!mos7840_port->read_urb_busy) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001848 mos7840_port->read_urb_busy = true;
Johan Hovold9d380192014-10-29 09:07:34 +01001849 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001850 if (status) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001851 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
Paul B Schroeder3f542972006-08-31 19:41:47 -05001852 status);
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001853 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001854 }
1855 }
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001856 dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__,
1857 mos7840_port->shadowLCR);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001858}
1859
1860/*****************************************************************************
1861 * mos7840_set_termios
1862 * this function is called by the tty driver when it wants to change
1863 * the termios structure
1864 *****************************************************************************/
1865
Alan Cox95da3102008-07-22 11:09:07 +01001866static void mos7840_set_termios(struct tty_struct *tty,
1867 struct usb_serial_port *port,
Alan Cox606d0992006-12-08 02:38:45 -08001868 struct ktermios *old_termios)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001869{
1870 int status;
1871 unsigned int cflag;
1872 struct usb_serial *serial;
1873 struct moschip_port *mos7840_port;
Greg Kroah-Hartman33631552012-05-03 16:44:33 -07001874
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001875 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001876 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001877
1878 serial = port->serial;
1879
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001880 if (mos7840_serial_paranoia_check(serial, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001881 return;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001882
1883 mos7840_port = mos7840_get_port_private(port);
1884
1885 if (mos7840_port == NULL)
1886 return;
1887
Paul B Schroeder3f542972006-08-31 19:41:47 -05001888 if (!mos7840_port->open) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001889 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001890 return;
1891 }
1892
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001893 dev_dbg(&port->dev, "%s", "setting termios - \n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001894
Alan Coxadc8d742012-07-14 15:31:47 +01001895 cflag = tty->termios.c_cflag;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001896
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001897 dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,
Linus Torvaldsd9a80742012-10-01 13:23:01 -07001898 tty->termios.c_cflag, RELEVANT_IFLAG(tty->termios.c_iflag));
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001899 dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,
1900 old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag));
Paul B Schroeder3f542972006-08-31 19:41:47 -05001901
1902 /* change the port settings to the new ones specified */
1903
Alan Cox95da3102008-07-22 11:09:07 +01001904 mos7840_change_port_settings(tty, mos7840_port, old_termios);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001905
1906 if (!mos7840_port->read_urb) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001907 dev_dbg(&port->dev, "%s", "URB KILLED !!!!!\n");
Paul B Schroeder3f542972006-08-31 19:41:47 -05001908 return;
1909 }
1910
Mathieu OTHACEHEce9d8562016-02-04 19:01:29 +01001911 if (!mos7840_port->read_urb_busy) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001912 mos7840_port->read_urb_busy = true;
Johan Hovold9d380192014-10-29 09:07:34 +01001913 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001914 if (status) {
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001915 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
Paul B Schroeder3f542972006-08-31 19:41:47 -05001916 status);
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001917 mos7840_port->read_urb_busy = false;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001918 }
1919 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05001920}
1921
1922/*****************************************************************************
1923 * mos7840_get_lsr_info - get line status register info
1924 *
1925 * Purpose: Let user call ioctl() to get info when the UART physically
1926 * is emptied. On bus types like RS485, the transmitter must
1927 * release the bus after transmitting. This must be done when
1928 * the transmit shift register is empty, not be done when the
1929 * transmit holding register is empty. This functionality
1930 * allows an RS485 driver to be written in user space.
1931 *****************************************************************************/
1932
Alan Cox95da3102008-07-22 11:09:07 +01001933static int mos7840_get_lsr_info(struct tty_struct *tty,
Al Viro97c49652006-10-09 20:29:03 +01001934 unsigned int __user *value)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001935{
1936 int count;
1937 unsigned int result = 0;
1938
Alan Cox95da3102008-07-22 11:09:07 +01001939 count = mos7840_chars_in_buffer(tty);
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001940 if (count == 0)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001941 result = TIOCSER_TEMT;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001942
1943 if (copy_to_user(value, &result, sizeof(int)))
1944 return -EFAULT;
1945 return 0;
1946}
1947
1948/*****************************************************************************
Paul B Schroeder3f542972006-08-31 19:41:47 -05001949 * mos7840_get_serial_info
1950 * function to get information about serial port
1951 *****************************************************************************/
1952
1953static int mos7840_get_serial_info(struct moschip_port *mos7840_port,
Al Viro97c49652006-10-09 20:29:03 +01001954 struct serial_struct __user *retinfo)
Paul B Schroeder3f542972006-08-31 19:41:47 -05001955{
1956 struct serial_struct tmp;
1957
1958 if (mos7840_port == NULL)
1959 return -1;
1960
Paul B Schroeder3f542972006-08-31 19:41:47 -05001961 memset(&tmp, 0, sizeof(tmp));
1962
1963 tmp.type = PORT_16550A;
Greg Kroah-Hartmane5b1e202013-06-07 11:04:28 -07001964 tmp.line = mos7840_port->port->minor;
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001965 tmp.port = mos7840_port->port->port_number;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001966 tmp.irq = 0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001967 tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE;
1968 tmp.baud_base = 9600;
1969 tmp.close_delay = 5 * HZ;
1970 tmp.closing_wait = 30 * HZ;
1971
1972 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1973 return -EFAULT;
1974 return 0;
1975}
1976
1977/*****************************************************************************
1978 * SerialIoctl
1979 * this function handles any ioctl calls to the driver
1980 *****************************************************************************/
1981
Alan Cox00a0d0d2011-02-14 16:27:06 +00001982static int mos7840_ioctl(struct tty_struct *tty,
Paul B Schroeder3f542972006-08-31 19:41:47 -05001983 unsigned int cmd, unsigned long arg)
1984{
Alan Cox95da3102008-07-22 11:09:07 +01001985 struct usb_serial_port *port = tty->driver_data;
Al Viro97c49652006-10-09 20:29:03 +01001986 void __user *argp = (void __user *)arg;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001987 struct moschip_port *mos7840_port;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001988
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07001989 if (mos7840_port_paranoia_check(port, __func__))
Paul B Schroeder3f542972006-08-31 19:41:47 -05001990 return -1;
Paul B Schroeder3f542972006-08-31 19:41:47 -05001991
1992 mos7840_port = mos7840_get_port_private(port);
Paul B Schroeder3f542972006-08-31 19:41:47 -05001993
1994 if (mos7840_port == NULL)
1995 return -1;
1996
Paul B Schroeder3f542972006-08-31 19:41:47 -05001997 switch (cmd) {
1998 /* return number of bytes available */
1999
Paul B Schroeder3f542972006-08-31 19:41:47 -05002000 case TIOCSERGETLSR:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07002001 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
Alan Cox95da3102008-07-22 11:09:07 +01002002 return mos7840_get_lsr_info(tty, argp);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002003
Paul B Schroeder3f542972006-08-31 19:41:47 -05002004 case TIOCGSERIAL:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07002005 dev_dbg(&port->dev, "%s TIOCGSERIAL\n", __func__);
Al Viro97c49652006-10-09 20:29:03 +01002006 return mos7840_get_serial_info(mos7840_port, argp);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002007
2008 case TIOCSSERIAL:
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07002009 dev_dbg(&port->dev, "%s TIOCSSERIAL\n", __func__);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002010 break;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002011 default:
2012 break;
2013 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05002014 return -ENOIOCTLCMD;
2015}
2016
Donald0eafe4d2012-04-19 15:00:45 +08002017static int mos7810_check(struct usb_serial *serial)
2018{
2019 int i, pass_count = 0;
Johan Hovold15ee89c332013-05-27 14:44:40 +02002020 u8 *buf;
Donald0eafe4d2012-04-19 15:00:45 +08002021 __u16 data = 0, mcr_data = 0;
2022 __u16 test_pattern = 0x55AA;
Johan Hovold15ee89c332013-05-27 14:44:40 +02002023 int res;
2024
2025 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
2026 if (!buf)
2027 return 0; /* failed to identify 7810 */
Donald0eafe4d2012-04-19 15:00:45 +08002028
2029 /* Store MCR setting */
Johan Hovold15ee89c332013-05-27 14:44:40 +02002030 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
Donald0eafe4d2012-04-19 15:00:45 +08002031 MCS_RDREQ, MCS_RD_RTYPE, 0x0300, MODEM_CONTROL_REGISTER,
Johan Hovold15ee89c332013-05-27 14:44:40 +02002032 buf, VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
2033 if (res == VENDOR_READ_LENGTH)
2034 mcr_data = *buf;
Donald0eafe4d2012-04-19 15:00:45 +08002035
2036 for (i = 0; i < 16; i++) {
2037 /* Send the 1-bit test pattern out to MCS7810 test pin */
2038 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2039 MCS_WRREQ, MCS_WR_RTYPE,
2040 (0x0300 | (((test_pattern >> i) & 0x0001) << 1)),
2041 MODEM_CONTROL_REGISTER, NULL, 0, MOS_WDR_TIMEOUT);
2042
2043 /* Read the test pattern back */
Johan Hovold15ee89c332013-05-27 14:44:40 +02002044 res = usb_control_msg(serial->dev,
2045 usb_rcvctrlpipe(serial->dev, 0), MCS_RDREQ,
2046 MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
2047 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
2048 if (res == VENDOR_READ_LENGTH)
2049 data = *buf;
Donald0eafe4d2012-04-19 15:00:45 +08002050
2051 /* If this is a MCS7810 device, both test patterns must match */
2052 if (((test_pattern >> i) ^ (~data >> 1)) & 0x0001)
2053 break;
2054
2055 pass_count++;
2056 }
2057
2058 /* Restore MCR setting */
2059 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), MCS_WRREQ,
2060 MCS_WR_RTYPE, 0x0300 | mcr_data, MODEM_CONTROL_REGISTER, NULL,
2061 0, MOS_WDR_TIMEOUT);
2062
Johan Hovold15ee89c332013-05-27 14:44:40 +02002063 kfree(buf);
2064
Donald0eafe4d2012-04-19 15:00:45 +08002065 if (pass_count == 16)
2066 return 1;
2067
2068 return 0;
2069}
2070
Johan Hovold40c24f22013-07-26 11:55:18 +02002071static int mos7840_probe(struct usb_serial *serial,
2072 const struct usb_device_id *id)
Paul B Schroeder3f542972006-08-31 19:41:47 -05002073{
Johan Hovoldd551ec92013-08-11 16:49:20 +02002074 u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
Johan Hovold15ee89c332013-05-27 14:44:40 +02002075 u8 *buf;
Johan Hovold40c24f22013-07-26 11:55:18 +02002076 int device_type;
2077
2078 if (product == MOSCHIP_DEVICE_ID_7810 ||
2079 product == MOSCHIP_DEVICE_ID_7820) {
2080 device_type = product;
2081 goto out;
2082 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05002083
Johan Hovold15ee89c332013-05-27 14:44:40 +02002084 buf = kzalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
Johan Hovold40c24f22013-07-26 11:55:18 +02002085 if (!buf)
2086 return -ENOMEM;
2087
2088 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
Johan Hovold15ee89c332013-05-27 14:44:40 +02002089 MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
2090 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
Donald Lee093ea2d2012-03-14 15:26:33 +08002091
Johan Hovold40c24f22013-07-26 11:55:18 +02002092 /* For a MCS7840 device GPIO0 must be set to 1 */
2093 if (buf[0] & 0x01)
2094 device_type = MOSCHIP_DEVICE_ID_7840;
2095 else if (mos7810_check(serial))
2096 device_type = MOSCHIP_DEVICE_ID_7810;
2097 else
2098 device_type = MOSCHIP_DEVICE_ID_7820;
2099
2100 kfree(buf);
2101out:
Johan Hovold683a0e42013-07-27 13:34:42 +02002102 usb_set_serial_data(serial, (void *)(unsigned long)device_type);
Johan Hovold40c24f22013-07-26 11:55:18 +02002103
2104 return 0;
2105}
2106
2107static int mos7840_calc_num_ports(struct usb_serial *serial)
2108{
Johan Hovold683a0e42013-07-27 13:34:42 +02002109 int device_type = (unsigned long)usb_get_serial_data(serial);
Johan Hovold40c24f22013-07-26 11:55:18 +02002110 int mos7840_num_ports;
Donald Lee093ea2d2012-03-14 15:26:33 +08002111
Donald0eafe4d2012-04-19 15:00:45 +08002112 mos7840_num_ports = (device_type >> 4) & 0x000F;
Donald0eafe4d2012-04-19 15:00:45 +08002113
Paul B Schroeder3f542972006-08-31 19:41:47 -05002114 return mos7840_num_ports;
2115}
2116
Johan Hovold5c756332017-01-03 16:39:55 +01002117static int mos7840_attach(struct usb_serial *serial)
2118{
2119 if (serial->num_bulk_in < serial->num_ports ||
Johan Hovold5182c2c2017-02-09 12:11:41 +01002120 serial->num_bulk_out < serial->num_ports ||
2121 serial->num_interrupt_in < 1) {
Johan Hovold5c756332017-01-03 16:39:55 +01002122 dev_err(&serial->interface->dev, "missing endpoints\n");
2123 return -ENODEV;
2124 }
2125
2126 return 0;
2127}
2128
Johan Hovold80c00752012-10-25 18:56:34 +02002129static int mos7840_port_probe(struct usb_serial_port *port)
Paul B Schroeder3f542972006-08-31 19:41:47 -05002130{
Johan Hovold80c00752012-10-25 18:56:34 +02002131 struct usb_serial *serial = port->serial;
Johan Hovold683a0e42013-07-27 13:34:42 +02002132 int device_type = (unsigned long)usb_get_serial_data(serial);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002133 struct moschip_port *mos7840_port;
Johan Hovold80c00752012-10-25 18:56:34 +02002134 int status;
2135 int pnum;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002136 __u16 Data;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002137
Paul B Schroeder3f542972006-08-31 19:41:47 -05002138 /* we set up the pointers to the endpoints in the mos7840_open *
2139 * function, as the structures aren't created yet. */
2140
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07002141 pnum = port->port_number;
Johan Hovold80c00752012-10-25 18:56:34 +02002142
Johan Hovoldae685ef2012-10-25 18:56:35 +02002143 dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum);
2144 mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
Johan Hovold10c642d2013-12-29 19:22:56 +01002145 if (!mos7840_port)
Johan Hovoldae685ef2012-10-25 18:56:35 +02002146 return -ENOMEM;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002147
Johan Hovoldae685ef2012-10-25 18:56:35 +02002148 /* Initialize all port interrupt end point to port 0 int
2149 * endpoint. Our device has only one interrupt end point
2150 * common to all port */
Paul B Schroeder3f542972006-08-31 19:41:47 -05002151
Johan Hovoldae685ef2012-10-25 18:56:35 +02002152 mos7840_port->port = port;
2153 mos7840_set_port_private(port, mos7840_port);
2154 spin_lock_init(&mos7840_port->pool_lock);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002155
Johan Hovoldae685ef2012-10-25 18:56:35 +02002156 /* minor is not initialised until later by
2157 * usb-serial.c:get_free_serial() and cannot therefore be used
2158 * to index device instances */
2159 mos7840_port->port_num = pnum + 1;
Greg Kroah-Hartmane5b1e202013-06-07 11:04:28 -07002160 dev_dbg(&port->dev, "port->minor = %d\n", port->minor);
Johan Hovoldae685ef2012-10-25 18:56:35 +02002161 dev_dbg(&port->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002162
Johan Hovoldae685ef2012-10-25 18:56:35 +02002163 if (mos7840_port->port_num == 1) {
2164 mos7840_port->SpRegOffset = 0x0;
2165 mos7840_port->ControlRegOffset = 0x1;
2166 mos7840_port->DcrRegOffset = 0x4;
2167 } else if ((mos7840_port->port_num == 2) && (serial->num_ports == 4)) {
2168 mos7840_port->SpRegOffset = 0x8;
2169 mos7840_port->ControlRegOffset = 0x9;
2170 mos7840_port->DcrRegOffset = 0x16;
2171 } else if ((mos7840_port->port_num == 2) && (serial->num_ports == 2)) {
2172 mos7840_port->SpRegOffset = 0xa;
2173 mos7840_port->ControlRegOffset = 0xb;
2174 mos7840_port->DcrRegOffset = 0x19;
2175 } else if ((mos7840_port->port_num == 3) && (serial->num_ports == 4)) {
2176 mos7840_port->SpRegOffset = 0xa;
2177 mos7840_port->ControlRegOffset = 0xb;
2178 mos7840_port->DcrRegOffset = 0x19;
2179 } else if ((mos7840_port->port_num == 4) && (serial->num_ports == 4)) {
2180 mos7840_port->SpRegOffset = 0xc;
2181 mos7840_port->ControlRegOffset = 0xd;
2182 mos7840_port->DcrRegOffset = 0x1c;
2183 }
2184 mos7840_dump_serial_port(port, mos7840_port);
2185 mos7840_set_port_private(port, mos7840_port);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002186
Johan Hovoldae685ef2012-10-25 18:56:35 +02002187 /* enable rx_disable bit in control register */
2188 status = mos7840_get_reg_sync(port,
2189 mos7840_port->ControlRegOffset, &Data);
2190 if (status < 0) {
2191 dev_dbg(&port->dev, "Reading ControlReg failed status-0x%x\n", status);
2192 goto out;
2193 } else
2194 dev_dbg(&port->dev, "ControlReg Reading success val is %x, status%d\n", Data, status);
2195 Data |= 0x08; /* setting driver done bit */
2196 Data |= 0x04; /* sp1_bit to have cts change reflect in
2197 modem status reg */
Paul B Schroeder3f542972006-08-31 19:41:47 -05002198
Johan Hovoldae685ef2012-10-25 18:56:35 +02002199 /* Data |= 0x20; //rx_disable bit */
2200 status = mos7840_set_reg_sync(port,
2201 mos7840_port->ControlRegOffset, Data);
2202 if (status < 0) {
2203 dev_dbg(&port->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status);
2204 goto out;
2205 } else
2206 dev_dbg(&port->dev, "ControlReg Writing success(rx_disable) status%d\n", status);
2207
2208 /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
2209 and 0x24 in DCR3 */
2210 Data = 0x01;
2211 status = mos7840_set_reg_sync(port,
2212 (__u16) (mos7840_port->DcrRegOffset + 0), Data);
2213 if (status < 0) {
2214 dev_dbg(&port->dev, "Writing DCR0 failed status-0x%x\n", status);
2215 goto out;
2216 } else
2217 dev_dbg(&port->dev, "DCR0 Writing success status%d\n", status);
2218
2219 Data = 0x05;
2220 status = mos7840_set_reg_sync(port,
2221 (__u16) (mos7840_port->DcrRegOffset + 1), Data);
2222 if (status < 0) {
2223 dev_dbg(&port->dev, "Writing DCR1 failed status-0x%x\n", status);
2224 goto out;
2225 } else
2226 dev_dbg(&port->dev, "DCR1 Writing success status%d\n", status);
2227
2228 Data = 0x24;
2229 status = mos7840_set_reg_sync(port,
2230 (__u16) (mos7840_port->DcrRegOffset + 2), Data);
2231 if (status < 0) {
2232 dev_dbg(&port->dev, "Writing DCR2 failed status-0x%x\n", status);
2233 goto out;
2234 } else
2235 dev_dbg(&port->dev, "DCR2 Writing success status%d\n", status);
2236
2237 /* write values in clkstart0x0 and clkmulti 0x20 */
2238 Data = 0x0;
2239 status = mos7840_set_reg_sync(port, CLK_START_VALUE_REGISTER, Data);
2240 if (status < 0) {
2241 dev_dbg(&port->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status);
2242 goto out;
2243 } else
2244 dev_dbg(&port->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status);
2245
2246 Data = 0x20;
2247 status = mos7840_set_reg_sync(port, CLK_MULTI_REGISTER, Data);
2248 if (status < 0) {
2249 dev_dbg(&port->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status);
2250 goto error;
2251 } else
2252 dev_dbg(&port->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status);
2253
2254 /* write value 0x0 to scratchpad register */
2255 Data = 0x00;
2256 status = mos7840_set_uart_reg(port, SCRATCH_PAD_REGISTER, Data);
2257 if (status < 0) {
2258 dev_dbg(&port->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status);
2259 goto out;
2260 } else
2261 dev_dbg(&port->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status);
2262
2263 /* Zero Length flag register */
2264 if ((mos7840_port->port_num != 1) && (serial->num_ports == 2)) {
2265 Data = 0xff;
Johan Hovold80c00752012-10-25 18:56:34 +02002266 status = mos7840_set_reg_sync(port,
Johan Hovoldae685ef2012-10-25 18:56:35 +02002267 (__u16) (ZLP_REG1 +
2268 ((__u16)mos7840_port->port_num)), Data);
2269 dev_dbg(&port->dev, "ZLIP offset %x\n",
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07002270 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num)));
Johan Hovoldae685ef2012-10-25 18:56:35 +02002271 if (status < 0) {
2272 dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 2, status);
2273 goto out;
2274 } else
2275 dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 2, status);
2276 } else {
2277 Data = 0xff;
2278 status = mos7840_set_reg_sync(port,
2279 (__u16) (ZLP_REG1 +
2280 ((__u16)mos7840_port->port_num) - 0x1), Data);
2281 dev_dbg(&port->dev, "ZLIP offset %x\n",
Greg Kroah-Hartman9c134a12012-09-14 16:06:04 -07002282 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1));
Johan Hovoldae685ef2012-10-25 18:56:35 +02002283 if (status < 0) {
2284 dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 1, status);
2285 goto out;
2286 } else
2287 dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 1, status);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002288
Johan Hovoldae685ef2012-10-25 18:56:35 +02002289 }
2290 mos7840_port->control_urb = usb_alloc_urb(0, GFP_KERNEL);
2291 mos7840_port->ctrl_buf = kmalloc(16, GFP_KERNEL);
2292 mos7840_port->dr = kmalloc(sizeof(struct usb_ctrlrequest),
2293 GFP_KERNEL);
2294 if (!mos7840_port->control_urb || !mos7840_port->ctrl_buf ||
2295 !mos7840_port->dr) {
2296 status = -ENOMEM;
2297 goto error;
2298 }
Donald0eafe4d2012-04-19 15:00:45 +08002299
Johan Hovoldae685ef2012-10-25 18:56:35 +02002300 mos7840_port->has_led = false;
Donald0eafe4d2012-04-19 15:00:45 +08002301
Johan Hovoldae685ef2012-10-25 18:56:35 +02002302 /* Initialize LED timers */
2303 if (device_type == MOSCHIP_DEVICE_ID_7810) {
2304 mos7840_port->has_led = true;
Donald0eafe4d2012-04-19 15:00:45 +08002305
Johan Hovold05cf0de2013-07-26 11:55:19 +02002306 mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL);
2307 mos7840_port->led_dr = kmalloc(sizeof(*mos7840_port->led_dr),
2308 GFP_KERNEL);
2309 if (!mos7840_port->led_urb || !mos7840_port->led_dr) {
2310 status = -ENOMEM;
2311 goto error;
2312 }
2313
Vaishali Thakkarf05b7cb2015-06-01 06:41:57 +05302314 setup_timer(&mos7840_port->led_timer1, mos7840_led_off,
2315 (unsigned long)mos7840_port);
Johan Hovoldae685ef2012-10-25 18:56:35 +02002316 mos7840_port->led_timer1.expires =
2317 jiffies + msecs_to_jiffies(LED_ON_MS);
Vaishali Thakkarf05b7cb2015-06-01 06:41:57 +05302318 setup_timer(&mos7840_port->led_timer2, mos7840_led_flag_off,
2319 (unsigned long)mos7840_port);
Johan Hovoldae685ef2012-10-25 18:56:35 +02002320 mos7840_port->led_timer2.expires =
2321 jiffies + msecs_to_jiffies(LED_OFF_MS);
Donald0eafe4d2012-04-19 15:00:45 +08002322
Johan Hovoldae685ef2012-10-25 18:56:35 +02002323 /* Turn off LED */
2324 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
2325 }
2326out:
Johan Hovold80c00752012-10-25 18:56:34 +02002327 if (pnum == serial->num_ports - 1) {
2328 /* Zero Length flag enable */
2329 Data = 0x0f;
2330 status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data);
2331 if (status < 0) {
2332 dev_dbg(&port->dev, "Writing ZLP_REG5 failed status-0x%x\n", status);
2333 goto error;
2334 } else
2335 dev_dbg(&port->dev, "ZLP_REG5 Writing success status%d\n", status);
2336
2337 /* setting configuration feature to one */
2338 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2339 0x03, 0x00, 0x01, 0x00, NULL, 0x00,
2340 MOS_WDR_TIMEOUT);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002341 }
Paul B Schroeder3f542972006-08-31 19:41:47 -05002342 return 0;
Oliver Neukum0de9a702007-03-16 20:28:28 +01002343error:
Johan Hovold05cf0de2013-07-26 11:55:19 +02002344 kfree(mos7840_port->led_dr);
2345 usb_free_urb(mos7840_port->led_urb);
Johan Hovold80c00752012-10-25 18:56:34 +02002346 kfree(mos7840_port->dr);
2347 kfree(mos7840_port->ctrl_buf);
2348 usb_free_urb(mos7840_port->control_urb);
2349 kfree(mos7840_port);
Oliver Neukum0de9a702007-03-16 20:28:28 +01002350
Oliver Neukum0de9a702007-03-16 20:28:28 +01002351 return status;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002352}
2353
Johan Hovold80c00752012-10-25 18:56:34 +02002354static int mos7840_port_remove(struct usb_serial_port *port)
Paul B Schroeder3f542972006-08-31 19:41:47 -05002355{
Paul B Schroeder3f542972006-08-31 19:41:47 -05002356 struct moschip_port *mos7840_port;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002357
Johan Hovold80c00752012-10-25 18:56:34 +02002358 mos7840_port = mos7840_get_port_private(port);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002359
Johan Hovold80c00752012-10-25 18:56:34 +02002360 if (mos7840_port->has_led) {
2361 /* Turn off LED */
2362 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002363
Johan Hovold80c00752012-10-25 18:56:34 +02002364 del_timer_sync(&mos7840_port->led_timer1);
2365 del_timer_sync(&mos7840_port->led_timer2);
Johan Hovold05cf0de2013-07-26 11:55:19 +02002366
2367 usb_kill_urb(mos7840_port->led_urb);
2368 usb_free_urb(mos7840_port->led_urb);
2369 kfree(mos7840_port->led_dr);
Alan Sternf9c99bb2009-06-02 11:53:55 -04002370 }
Johan Hovold80c00752012-10-25 18:56:34 +02002371 usb_kill_urb(mos7840_port->control_urb);
2372 usb_free_urb(mos7840_port->control_urb);
2373 kfree(mos7840_port->ctrl_buf);
2374 kfree(mos7840_port->dr);
2375 kfree(mos7840_port);
Alan Sternf9c99bb2009-06-02 11:53:55 -04002376
Johan Hovold80c00752012-10-25 18:56:34 +02002377 return 0;
Paul B Schroeder3f542972006-08-31 19:41:47 -05002378}
2379
2380static struct usb_serial_driver moschip7840_4port_device = {
2381 .driver = {
2382 .owner = THIS_MODULE,
2383 .name = "mos7840",
2384 },
2385 .description = DRIVER_DESC,
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07002386 .id_table = id_table,
Paul B Schroeder3f542972006-08-31 19:41:47 -05002387 .num_ports = 4,
Paul B Schroeder3f542972006-08-31 19:41:47 -05002388 .open = mos7840_open,
2389 .close = mos7840_close,
2390 .write = mos7840_write,
2391 .write_room = mos7840_write_room,
2392 .chars_in_buffer = mos7840_chars_in_buffer,
2393 .throttle = mos7840_throttle,
2394 .unthrottle = mos7840_unthrottle,
2395 .calc_num_ports = mos7840_calc_num_ports,
Johan Hovold40c24f22013-07-26 11:55:18 +02002396 .probe = mos7840_probe,
Paul B Schroeder3f542972006-08-31 19:41:47 -05002397 .ioctl = mos7840_ioctl,
2398 .set_termios = mos7840_set_termios,
2399 .break_ctl = mos7840_break,
2400 .tiocmget = mos7840_tiocmget,
2401 .tiocmset = mos7840_tiocmset,
Johan Hovold0c6133712013-03-21 12:37:17 +01002402 .tiocmiwait = usb_serial_generic_tiocmiwait,
Johan Hovold8c1a07f2013-03-21 12:37:16 +01002403 .get_icount = usb_serial_generic_get_icount,
Johan Hovold5c756332017-01-03 16:39:55 +01002404 .attach = mos7840_attach,
Johan Hovold80c00752012-10-25 18:56:34 +02002405 .port_probe = mos7840_port_probe,
2406 .port_remove = mos7840_port_remove,
Paul B Schroeder3f542972006-08-31 19:41:47 -05002407 .read_bulk_callback = mos7840_bulk_in_callback,
2408 .read_int_callback = mos7840_interrupt_callback,
2409};
2410
Alan Stern4d2a7af2012-02-23 14:57:09 -05002411static struct usb_serial_driver * const serial_drivers[] = {
2412 &moschip7840_4port_device, NULL
2413};
2414
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07002415module_usb_serial_driver(serial_drivers, id_table);
Paul B Schroeder3f542972006-08-31 19:41:47 -05002416
Paul B Schroeder3f542972006-08-31 19:41:47 -05002417MODULE_DESCRIPTION(DRIVER_DESC);
2418MODULE_LICENSE("GPL");