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.
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.
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
16 * Clean ups from Moschip version and a few ioctl implementations by:
17 * Paul B Schroeder <pschroeder "at" uplogix "dot" com>
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>
25 #include <linux/kernel.h>
26 #include <linux/errno.h>
27 #include <linux/slab.h>
28 #include <linux/tty.h>
29 #include <linux/tty_driver.h>
30 #include <linux/tty_flip.h>
31 #include <linux/module.h>
32 #include <linux/serial.h>
33 #include <linux/usb.h>
34 #include <linux/usb/serial.h>
35 #include <linux/uaccess.h>
37 #define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver"
40 * 16C50 UART register defines
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 */
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 */
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 */
61 #define LCR_SET_BREAK 0x40 /* Set Break condition */
62 #define LCR_DL_ENABLE 0x80 /* Enable access to divisor latch */
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 */
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 */
77 * Defines used for sending commands to port
80 #define MOS_WDR_TIMEOUT 5000 /* default urb timeout */
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
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)
97 #define MAX_NAME_LEN 64
99 #define ZLP_REG1 0x3A /* Zero_Flag_Reg1 58 */
100 #define ZLP_REG5 0x3E /* Zero_Flag_Reg5 62 */
102 /* For higher baud Rates use TIOCEXBAUD */
103 #define TIOCEXBAUD 0x5462
105 /* vendor id and device id defines */
107 /* The native mos7840/7820 component */
108 #define USB_VENDOR_ID_MOSCHIP 0x9710
109 #define MOSCHIP_DEVICE_ID_7840 0x7840
110 #define MOSCHIP_DEVICE_ID_7820 0x7820
111 #define MOSCHIP_DEVICE_ID_7810 0x7810
112 /* The native component can have its vendor/device id's overridden
113 * in vendor-specific implementations. Such devices can be handled
114 * by making a change here, in id_table.
116 #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
130 /* This driver also supports
131 * ATEN UC2324 device using Moschip MCS7840
132 * ATEN UC2322 device using Moschip MCS7820
133 * MOXA UPort 2210 device using Moschip MCS7820
135 #define USB_VENDOR_ID_ATENINTL 0x0557
136 #define ATENINTL_DEVICE_ID_UC2324 0x2011
137 #define ATENINTL_DEVICE_ID_UC2322 0x7820
139 #define USB_VENDOR_ID_MOXA 0x110a
140 #define MOXA_DEVICE_ID_2210 0x2210
142 /* Interrupt Routine Defines */
144 #define SERIAL_IIR_RLS 0x06
145 #define SERIAL_IIR_MS 0x00
148 * Emulation of the bit mask on the LINE STATUS REGISTER.
150 #define SERIAL_LSR_DR 0x0001
151 #define SERIAL_LSR_OE 0x0002
152 #define SERIAL_LSR_PE 0x0004
153 #define SERIAL_LSR_FE 0x0008
154 #define SERIAL_LSR_BI 0x0010
156 #define MOS_MSR_DELTA_CTS 0x10
157 #define MOS_MSR_DELTA_DSR 0x20
158 #define MOS_MSR_DELTA_RI 0x40
159 #define MOS_MSR_DELTA_CD 0x80
161 /* Serial Port register Address */
162 #define INTERRUPT_ENABLE_REGISTER ((__u16)(0x01))
163 #define FIFO_CONTROL_REGISTER ((__u16)(0x02))
164 #define LINE_CONTROL_REGISTER ((__u16)(0x03))
165 #define MODEM_CONTROL_REGISTER ((__u16)(0x04))
166 #define LINE_STATUS_REGISTER ((__u16)(0x05))
167 #define MODEM_STATUS_REGISTER ((__u16)(0x06))
168 #define SCRATCH_PAD_REGISTER ((__u16)(0x07))
169 #define DIVISOR_LATCH_LSB ((__u16)(0x00))
170 #define DIVISOR_LATCH_MSB ((__u16)(0x01))
172 #define CLK_MULTI_REGISTER ((__u16)(0x02))
173 #define CLK_START_VALUE_REGISTER ((__u16)(0x03))
174 #define GPIO_REGISTER ((__u16)(0x07))
176 #define SERIAL_LCR_DLAB ((__u16)(0x0080))
179 * URB POOL related defines
181 #define NUM_URBS 16 /* URB Count */
182 #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */
184 /* LED on/off milliseconds*/
185 #define LED_ON_MS 500
186 #define LED_OFF_MS 500
189 MOS7840_FLAG_CTRL_BUSY,
190 MOS7840_FLAG_LED_BUSY,
193 static const struct usb_device_id id_table[] = {
194 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
195 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
196 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7810)},
197 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)},
198 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P)},
199 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)},
200 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P)},
201 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)},
202 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)},
203 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)},
204 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)},
205 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)},
206 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P)},
207 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
208 {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P)},
209 {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)},
210 {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)},
211 {USB_DEVICE(USB_VENDOR_ID_MOXA, MOXA_DEVICE_ID_2210)},
212 {} /* terminating entry */
214 MODULE_DEVICE_TABLE(usb, id_table);
216 /* This structure holds all of the local port information */
218 struct moschip_port {
219 int port_num; /*Actual port number in the device(1,2,etc) */
220 struct urb *read_urb; /* read URB for this port */
221 __u8 shadowLCR; /* last LCR value received */
222 __u8 shadowMCR; /* last MCR value received */
225 struct usb_serial_port *port; /* loop back to the owner of this object */
229 __u8 ControlRegOffset;
231 /* for processing control URBS in interrupt context */
232 struct urb *control_urb;
233 struct usb_ctrlrequest *dr;
237 spinlock_t pool_lock;
238 struct urb *write_urb_pool[NUM_URBS];
242 /* For device(s) with LED indicator */
244 struct timer_list led_timer1; /* Timer for LED on */
245 struct timer_list led_timer2; /* Timer for LED off */
247 struct usb_ctrlrequest *led_dr;
253 * mos7840_set_reg_sync
254 * To set the Control register by calling usb_fill_control_urb function
255 * by passing usb_sndctrlpipe function as parameter.
258 static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg,
261 struct usb_device *dev = port->serial->dev;
263 dev_dbg(&port->dev, "mos7840_set_reg_sync offset is %x, value %x\n", reg, val);
265 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
266 MCS_WR_RTYPE, val, reg, NULL, 0,
271 * mos7840_get_reg_sync
272 * To set the Uart register by calling usb_fill_control_urb function by
273 * passing usb_rcvctrlpipe function as parameter.
276 static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
279 struct usb_device *dev = port->serial->dev;
283 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
287 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
288 MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
290 if (ret < VENDOR_READ_LENGTH) {
297 dev_dbg(&port->dev, "%s offset is %x, return val %x\n", __func__, reg, *val);
304 * mos7840_set_uart_reg
305 * To set the Uart register by calling usb_fill_control_urb function by
306 * passing usb_sndctrlpipe function as parameter.
309 static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg,
313 struct usb_device *dev = port->serial->dev;
315 /* For the UART control registers, the application number need
317 if (port->serial->num_ports == 4) {
318 val |= ((__u16)port->port_number + 1) << 8;
320 if (port->port_number == 0) {
321 val |= ((__u16)port->port_number + 1) << 8;
323 val |= ((__u16)port->port_number + 2) << 8;
326 dev_dbg(&port->dev, "%s application number is %x\n", __func__, val);
327 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
328 MCS_WR_RTYPE, val, reg, NULL, 0,
334 * mos7840_get_uart_reg
335 * To set the Control register by calling usb_fill_control_urb function
336 * by passing usb_rcvctrlpipe function as parameter.
338 static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
341 struct usb_device *dev = port->serial->dev;
346 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
350 /* Wval is same as application number */
351 if (port->serial->num_ports == 4) {
352 Wval = ((__u16)port->port_number + 1) << 8;
354 if (port->port_number == 0) {
355 Wval = ((__u16)port->port_number + 1) << 8;
357 Wval = ((__u16)port->port_number + 2) << 8;
360 dev_dbg(&port->dev, "%s application number is %x\n", __func__, Wval);
361 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
362 MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
364 if (ret < VENDOR_READ_LENGTH) {
375 static void mos7840_dump_serial_port(struct usb_serial_port *port,
376 struct moschip_port *mos7840_port)
379 dev_dbg(&port->dev, "SpRegOffset is %2x\n", mos7840_port->SpRegOffset);
380 dev_dbg(&port->dev, "ControlRegOffset is %2x\n", mos7840_port->ControlRegOffset);
381 dev_dbg(&port->dev, "DCRRegOffset is %2x\n", mos7840_port->DcrRegOffset);
385 /************************************************************************/
386 /************************************************************************/
387 /* I N T E R F A C E F U N C T I O N S */
388 /* I N T E R F A C E F U N C T I O N S */
389 /************************************************************************/
390 /************************************************************************/
392 static inline void mos7840_set_port_private(struct usb_serial_port *port,
393 struct moschip_port *data)
395 usb_set_serial_port_data(port, (void *)data);
398 static inline struct moschip_port *mos7840_get_port_private(struct
402 return (struct moschip_port *)usb_get_serial_port_data(port);
405 static void mos7840_handle_new_msr(struct moschip_port *port, __u8 new_msr)
407 struct moschip_port *mos7840_port;
408 struct async_icount *icount;
411 (MOS_MSR_DELTA_CTS | MOS_MSR_DELTA_DSR | MOS_MSR_DELTA_RI |
413 icount = &mos7840_port->port->icount;
415 /* update input line counters */
416 if (new_msr & MOS_MSR_DELTA_CTS)
418 if (new_msr & MOS_MSR_DELTA_DSR)
420 if (new_msr & MOS_MSR_DELTA_CD)
422 if (new_msr & MOS_MSR_DELTA_RI)
425 wake_up_interruptible(&port->port->port.delta_msr_wait);
429 static void mos7840_handle_new_lsr(struct moschip_port *port, __u8 new_lsr)
431 struct async_icount *icount;
433 if (new_lsr & SERIAL_LSR_BI) {
435 * Parity and Framing errors only count if they
436 * occur exclusive of a break being
439 new_lsr &= (__u8) (SERIAL_LSR_OE | SERIAL_LSR_BI);
442 /* update input line counters */
443 icount = &port->port->icount;
444 if (new_lsr & SERIAL_LSR_BI)
446 if (new_lsr & SERIAL_LSR_OE)
448 if (new_lsr & SERIAL_LSR_PE)
450 if (new_lsr & SERIAL_LSR_FE)
454 /************************************************************************/
455 /************************************************************************/
456 /* U S B C A L L B A C K F U N C T I O N S */
457 /* U S B C A L L B A C K F U N C T I O N S */
458 /************************************************************************/
459 /************************************************************************/
461 static void mos7840_control_callback(struct urb *urb)
464 struct moschip_port *mos7840_port;
465 struct device *dev = &urb->dev->dev;
467 int status = urb->status;
469 mos7840_port = urb->context;
478 /* this urb is terminated, clean up */
479 dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
482 dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
486 dev_dbg(dev, "%s urb buffer size is %d\n", __func__, urb->actual_length);
487 if (urb->actual_length < 1)
490 dev_dbg(dev, "%s mos7840_port->MsrLsr is %d port %d\n", __func__,
491 mos7840_port->MsrLsr, mos7840_port->port_num);
492 data = urb->transfer_buffer;
493 regval = (__u8) data[0];
494 dev_dbg(dev, "%s data is %x\n", __func__, regval);
495 if (mos7840_port->MsrLsr == 0)
496 mos7840_handle_new_msr(mos7840_port, regval);
497 else if (mos7840_port->MsrLsr == 1)
498 mos7840_handle_new_lsr(mos7840_port, regval);
500 clear_bit_unlock(MOS7840_FLAG_CTRL_BUSY, &mos7840_port->flags);
503 static int mos7840_get_reg(struct moschip_port *mcs, __u16 Wval, __u16 reg,
506 struct usb_device *dev = mcs->port->serial->dev;
507 struct usb_ctrlrequest *dr = mcs->dr;
508 unsigned char *buffer = mcs->ctrl_buf;
511 if (test_and_set_bit_lock(MOS7840_FLAG_CTRL_BUSY, &mcs->flags))
514 dr->bRequestType = MCS_RD_RTYPE;
515 dr->bRequest = MCS_RDREQ;
516 dr->wValue = cpu_to_le16(Wval); /* 0 */
517 dr->wIndex = cpu_to_le16(reg);
518 dr->wLength = cpu_to_le16(2);
520 usb_fill_control_urb(mcs->control_urb, dev, usb_rcvctrlpipe(dev, 0),
521 (unsigned char *)dr, buffer, 2,
522 mos7840_control_callback, mcs);
523 mcs->control_urb->transfer_buffer_length = 2;
524 ret = usb_submit_urb(mcs->control_urb, GFP_ATOMIC);
526 clear_bit_unlock(MOS7840_FLAG_CTRL_BUSY, &mcs->flags);
531 static void mos7840_set_led_callback(struct urb *urb)
533 switch (urb->status) {
540 /* This urb is terminated, clean up */
541 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n",
542 __func__, urb->status);
545 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n",
546 __func__, urb->status);
550 static void mos7840_set_led_async(struct moschip_port *mcs, __u16 wval,
553 struct usb_device *dev = mcs->port->serial->dev;
554 struct usb_ctrlrequest *dr = mcs->led_dr;
556 dr->bRequestType = MCS_WR_RTYPE;
557 dr->bRequest = MCS_WRREQ;
558 dr->wValue = cpu_to_le16(wval);
559 dr->wIndex = cpu_to_le16(reg);
560 dr->wLength = cpu_to_le16(0);
562 usb_fill_control_urb(mcs->led_urb, dev, usb_sndctrlpipe(dev, 0),
563 (unsigned char *)dr, NULL, 0, mos7840_set_led_callback, NULL);
565 usb_submit_urb(mcs->led_urb, GFP_ATOMIC);
568 static void mos7840_set_led_sync(struct usb_serial_port *port, __u16 reg,
571 struct usb_device *dev = port->serial->dev;
573 usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, MCS_WR_RTYPE,
574 val, reg, NULL, 0, MOS_WDR_TIMEOUT);
577 static void mos7840_led_off(unsigned long arg)
579 struct moschip_port *mcs = (struct moschip_port *) arg;
582 mos7840_set_led_async(mcs, 0x0300, MODEM_CONTROL_REGISTER);
583 mod_timer(&mcs->led_timer2,
584 jiffies + msecs_to_jiffies(LED_OFF_MS));
587 static void mos7840_led_flag_off(unsigned long arg)
589 struct moschip_port *mcs = (struct moschip_port *) arg;
591 clear_bit_unlock(MOS7840_FLAG_LED_BUSY, &mcs->flags);
594 static void mos7840_led_activity(struct usb_serial_port *port)
596 struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
598 if (test_and_set_bit_lock(MOS7840_FLAG_LED_BUSY, &mos7840_port->flags))
601 mos7840_set_led_async(mos7840_port, 0x0301, MODEM_CONTROL_REGISTER);
602 mod_timer(&mos7840_port->led_timer1,
603 jiffies + msecs_to_jiffies(LED_ON_MS));
606 /*****************************************************************************
607 * mos7840_interrupt_callback
608 * this is the callback function for when we have received data on the
609 * interrupt endpoint.
610 *****************************************************************************/
612 static void mos7840_interrupt_callback(struct urb *urb)
616 struct moschip_port *mos7840_port;
617 struct usb_serial *serial;
622 __u16 wval, wreg = 0;
623 int status = urb->status;
632 /* this urb is terminated, clean up */
633 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
637 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
642 length = urb->actual_length;
643 data = urb->transfer_buffer;
645 serial = urb->context;
647 /* Moschip get 5 bytes
648 * Byte 1 IIR Port 1 (port.number is 0)
649 * Byte 2 IIR Port 2 (port.number is 1)
650 * Byte 3 IIR Port 3 (port.number is 2)
651 * Byte 4 IIR Port 4 (port.number is 3)
652 * Byte 5 FIFO status for both */
655 dev_dbg(&urb->dev->dev, "%s", "Wrong data !!!\n");
659 sp[0] = (__u8) data[0];
660 sp[1] = (__u8) data[1];
661 sp[2] = (__u8) data[2];
662 sp[3] = (__u8) data[3];
665 for (i = 0; i < serial->num_ports; i++) {
666 mos7840_port = mos7840_get_port_private(serial->port[i]);
667 wval = ((__u16)serial->port[i]->port_number + 1) << 8;
668 if (mos7840_port->open) {
670 dev_dbg(&urb->dev->dev, "SP%d No Interrupt !!!\n", i);
672 switch (sp[i] & 0x0f) {
674 dev_dbg(&urb->dev->dev, "Serial Port %d: Receiver status error or \n", i);
675 dev_dbg(&urb->dev->dev, "address bit detected in 9-bit mode\n");
676 mos7840_port->MsrLsr = 1;
677 wreg = LINE_STATUS_REGISTER;
680 dev_dbg(&urb->dev->dev, "Serial Port %d: Modem status change\n", i);
681 mos7840_port->MsrLsr = 0;
682 wreg = MODEM_STATUS_REGISTER;
685 rv = mos7840_get_reg(mos7840_port, wval, wreg, &Data);
690 /* the completion handler for the control urb will resubmit */
693 result = usb_submit_urb(urb, GFP_ATOMIC);
695 dev_err(&urb->dev->dev,
696 "%s - Error %d submitting interrupt urb\n",
701 static int mos7840_port_paranoia_check(struct usb_serial_port *port,
702 const char *function)
705 pr_debug("%s - port == NULL\n", function);
709 pr_debug("%s - port->serial == NULL\n", function);
716 /* Inline functions to check the sanity of a pointer that is passed to us */
717 static int mos7840_serial_paranoia_check(struct usb_serial *serial,
718 const char *function)
721 pr_debug("%s - serial == NULL\n", function);
725 pr_debug("%s - serial->type == NULL!\n", function);
732 static struct usb_serial *mos7840_get_usb_serial(struct usb_serial_port *port,
733 const char *function)
735 /* if no port was specified, or it fails a paranoia check */
737 mos7840_port_paranoia_check(port, function) ||
738 mos7840_serial_paranoia_check(port->serial, function)) {
739 /* then say that we don't have a valid usb_serial thing,
740 * which will end up genrating -ENODEV return values */
747 /*****************************************************************************
748 * mos7840_bulk_in_callback
749 * this is the callback function for when we have received data on the
751 *****************************************************************************/
753 static void mos7840_bulk_in_callback(struct urb *urb)
757 struct usb_serial *serial;
758 struct usb_serial_port *port;
759 struct moschip_port *mos7840_port;
760 int status = urb->status;
762 mos7840_port = urb->context;
767 dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
768 mos7840_port->read_urb_busy = false;
772 port = mos7840_port->port;
773 if (mos7840_port_paranoia_check(port, __func__)) {
774 mos7840_port->read_urb_busy = false;
778 serial = mos7840_get_usb_serial(port, __func__);
780 mos7840_port->read_urb_busy = false;
784 data = urb->transfer_buffer;
785 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
787 if (urb->actual_length) {
788 struct tty_port *tport = &mos7840_port->port->port;
789 tty_insert_flip_string(tport, data, urb->actual_length);
790 tty_flip_buffer_push(tport);
791 port->icount.rx += urb->actual_length;
792 dev_dbg(&port->dev, "icount.rx is %d:\n", port->icount.rx);
795 if (!mos7840_port->read_urb) {
796 dev_dbg(&port->dev, "%s", "URB KILLED !!!\n");
797 mos7840_port->read_urb_busy = false;
801 if (mos7840_port->has_led)
802 mos7840_led_activity(port);
804 mos7840_port->read_urb_busy = true;
805 retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
808 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
809 mos7840_port->read_urb_busy = false;
813 /*****************************************************************************
814 * mos7840_bulk_out_data_callback
815 * this is the callback function for when we have finished sending
816 * serial data on the bulk out endpoint.
817 *****************************************************************************/
819 static void mos7840_bulk_out_data_callback(struct urb *urb)
821 struct moschip_port *mos7840_port;
822 struct usb_serial_port *port;
823 int status = urb->status;
826 mos7840_port = urb->context;
827 port = mos7840_port->port;
828 spin_lock(&mos7840_port->pool_lock);
829 for (i = 0; i < NUM_URBS; i++) {
830 if (urb == mos7840_port->write_urb_pool[i]) {
831 mos7840_port->busy[i] = 0;
835 spin_unlock(&mos7840_port->pool_lock);
838 dev_dbg(&port->dev, "nonzero write bulk status received:%d\n", status);
842 if (mos7840_port_paranoia_check(port, __func__))
845 if (mos7840_port->open)
846 tty_port_tty_wakeup(&port->port);
850 /************************************************************************/
851 /* 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 */
852 /************************************************************************/
854 /*****************************************************************************
856 * this function is called by the tty driver when a port is opened
857 * If successful, we return 0
858 * Otherwise we return a negative error number.
859 *****************************************************************************/
861 static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
865 struct usb_serial *serial;
869 struct moschip_port *mos7840_port;
870 struct moschip_port *port0;
872 if (mos7840_port_paranoia_check(port, __func__))
875 serial = port->serial;
877 if (mos7840_serial_paranoia_check(serial, __func__))
880 mos7840_port = mos7840_get_port_private(port);
881 port0 = mos7840_get_port_private(serial->port[0]);
883 if (mos7840_port == NULL || port0 == NULL)
886 usb_clear_halt(serial->dev, port->write_urb->pipe);
887 usb_clear_halt(serial->dev, port->read_urb->pipe);
890 /* Initialising the write urb pool */
891 for (j = 0; j < NUM_URBS; ++j) {
892 urb = usb_alloc_urb(0, GFP_KERNEL);
893 mos7840_port->write_urb_pool[j] = urb;
897 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
899 if (!urb->transfer_buffer) {
901 mos7840_port->write_urb_pool[j] = NULL;
906 /*****************************************************************************
907 * Initialize MCS7840 -- Write Init values to corresponding Registers
915 * 0x08 : SP1/2 Control Reg
916 *****************************************************************************/
918 /* NEED to check the following Block */
921 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
923 dev_dbg(&port->dev, "Reading Spreg failed\n");
927 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
929 dev_dbg(&port->dev, "writing Spreg failed\n");
934 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
936 dev_dbg(&port->dev, "writing Spreg failed\n");
939 /* End of block to be checked */
942 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
945 dev_dbg(&port->dev, "Reading Controlreg failed\n");
948 Data |= 0x08; /* Driver done bit */
949 Data |= 0x20; /* rx_disable */
950 status = mos7840_set_reg_sync(port,
951 mos7840_port->ControlRegOffset, Data);
953 dev_dbg(&port->dev, "writing Controlreg failed\n");
956 /* do register settings here */
957 /* Set all regs to the device default values. */
958 /***********************************
959 * First Disable all interrupts.
960 ***********************************/
962 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
964 dev_dbg(&port->dev, "disabling interrupts failed\n");
967 /* Set FIFO_CONTROL_REGISTER to the default value */
969 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
971 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER failed\n");
976 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
978 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER failed\n");
983 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
984 mos7840_port->shadowLCR = Data;
987 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
988 mos7840_port->shadowMCR = Data;
991 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
992 mos7840_port->shadowLCR = Data;
994 Data |= SERIAL_LCR_DLAB; /* data latch enable in LCR 0x80 */
995 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
998 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1001 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1004 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
1006 Data = Data & ~SERIAL_LCR_DLAB;
1007 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1008 mos7840_port->shadowLCR = Data;
1010 /* clearing Bulkin and Bulkout Fifo */
1012 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
1015 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
1017 Data = Data & ~0x0c;
1018 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
1019 /* Finally enable all interrupts */
1021 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1023 /* clearing rx_disable */
1025 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
1027 Data = Data & ~0x20;
1028 status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
1033 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
1036 status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
1039 /* Check to see if we've set up our endpoint info yet *
1040 * (can't set it up in mos7840_startup as the structures *
1041 * were not set up at that time.) */
1042 if (port0->open_ports == 1) {
1043 /* FIXME: Buffer never NULL, so URB is not submitted. */
1044 if (serial->port[0]->interrupt_in_buffer == NULL) {
1045 /* set up interrupt urb */
1046 usb_fill_int_urb(serial->port[0]->interrupt_in_urb,
1048 usb_rcvintpipe(serial->dev,
1049 serial->port[0]->interrupt_in_endpointAddress),
1050 serial->port[0]->interrupt_in_buffer,
1051 serial->port[0]->interrupt_in_urb->
1052 transfer_buffer_length,
1053 mos7840_interrupt_callback,
1055 serial->port[0]->interrupt_in_urb->interval);
1057 /* start interrupt read for mos7840 */
1059 usb_submit_urb(serial->port[0]->interrupt_in_urb,
1062 dev_err(&port->dev, "%s - Error %d submitting "
1063 "interrupt urb\n", __func__, response);
1070 /* see if we've set up our endpoint info yet *
1071 * (can't set it up in mos7840_startup as the *
1072 * structures were not set up at that time.) */
1074 dev_dbg(&port->dev, "port number is %d\n", port->port_number);
1075 dev_dbg(&port->dev, "minor number is %d\n", port->minor);
1076 dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
1077 dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
1078 dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
1079 dev_dbg(&port->dev, "port's number in the device is %d\n", mos7840_port->port_num);
1080 mos7840_port->read_urb = port->read_urb;
1082 /* set up our bulk in urb */
1083 if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
1084 usb_fill_bulk_urb(mos7840_port->read_urb,
1086 usb_rcvbulkpipe(serial->dev,
1087 (port->bulk_in_endpointAddress) + 2),
1088 port->bulk_in_buffer,
1089 mos7840_port->read_urb->transfer_buffer_length,
1090 mos7840_bulk_in_callback, mos7840_port);
1092 usb_fill_bulk_urb(mos7840_port->read_urb,
1094 usb_rcvbulkpipe(serial->dev,
1095 port->bulk_in_endpointAddress),
1096 port->bulk_in_buffer,
1097 mos7840_port->read_urb->transfer_buffer_length,
1098 mos7840_bulk_in_callback, mos7840_port);
1101 dev_dbg(&port->dev, "%s: bulkin endpoint is %d\n", __func__, port->bulk_in_endpointAddress);
1102 mos7840_port->read_urb_busy = true;
1103 response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1105 dev_err(&port->dev, "%s - Error %d submitting control urb\n",
1106 __func__, response);
1107 mos7840_port->read_urb_busy = false;
1110 /* initialize our port settings */
1111 /* Must set to enable ints! */
1112 mos7840_port->shadowMCR = MCR_MASTER_IE;
1113 /* send a open port command */
1114 mos7840_port->open = 1;
1115 /* mos7840_change_port_settings(mos7840_port,old_termios); */
1119 for (j = 0; j < NUM_URBS; ++j) {
1120 urb = mos7840_port->write_urb_pool[j];
1123 kfree(urb->transfer_buffer);
1129 /*****************************************************************************
1130 * mos7840_chars_in_buffer
1131 * this function is called by the tty driver when it wants to know how many
1132 * bytes of data we currently have outstanding in the port (data that has
1133 * been written, but hasn't made it out the port yet)
1134 * If successful, we return the number of bytes left to be written in the
1136 * Otherwise we return zero.
1137 *****************************************************************************/
1139 static int mos7840_chars_in_buffer(struct tty_struct *tty)
1141 struct usb_serial_port *port = tty->driver_data;
1144 unsigned long flags;
1145 struct moschip_port *mos7840_port;
1147 if (mos7840_port_paranoia_check(port, __func__))
1150 mos7840_port = mos7840_get_port_private(port);
1151 if (mos7840_port == NULL)
1154 spin_lock_irqsave(&mos7840_port->pool_lock, flags);
1155 for (i = 0; i < NUM_URBS; ++i) {
1156 if (mos7840_port->busy[i]) {
1157 struct urb *urb = mos7840_port->write_urb_pool[i];
1158 chars += urb->transfer_buffer_length;
1161 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
1162 dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
1167 /*****************************************************************************
1169 * this function is called by the tty driver when a port is closed
1170 *****************************************************************************/
1172 static void mos7840_close(struct usb_serial_port *port)
1174 struct usb_serial *serial;
1175 struct moschip_port *mos7840_port;
1176 struct moschip_port *port0;
1180 if (mos7840_port_paranoia_check(port, __func__))
1183 serial = mos7840_get_usb_serial(port, __func__);
1187 mos7840_port = mos7840_get_port_private(port);
1188 port0 = mos7840_get_port_private(serial->port[0]);
1190 if (mos7840_port == NULL || port0 == NULL)
1193 for (j = 0; j < NUM_URBS; ++j)
1194 usb_kill_urb(mos7840_port->write_urb_pool[j]);
1196 /* Freeing Write URBs */
1197 for (j = 0; j < NUM_URBS; ++j) {
1198 if (mos7840_port->write_urb_pool[j]) {
1199 kfree(mos7840_port->write_urb_pool[j]->transfer_buffer);
1200 usb_free_urb(mos7840_port->write_urb_pool[j]);
1204 usb_kill_urb(mos7840_port->read_urb);
1205 mos7840_port->read_urb_busy = false;
1207 port0->open_ports--;
1208 dev_dbg(&port->dev, "%s in close%d\n", __func__, port0->open_ports);
1209 if (port0->open_ports == 0) {
1210 if (serial->port[0]->interrupt_in_urb) {
1211 dev_dbg(&port->dev, "Shutdown interrupt_in_urb\n");
1212 usb_kill_urb(serial->port[0]->interrupt_in_urb);
1217 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1220 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1222 mos7840_port->open = 0;
1225 /*****************************************************************************
1227 * this function sends a break to the port
1228 *****************************************************************************/
1229 static void mos7840_break(struct tty_struct *tty, int break_state)
1231 struct usb_serial_port *port = tty->driver_data;
1233 struct usb_serial *serial;
1234 struct moschip_port *mos7840_port;
1236 if (mos7840_port_paranoia_check(port, __func__))
1239 serial = mos7840_get_usb_serial(port, __func__);
1243 mos7840_port = mos7840_get_port_private(port);
1245 if (mos7840_port == NULL)
1248 if (break_state == -1)
1249 data = mos7840_port->shadowLCR | LCR_SET_BREAK;
1251 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
1253 /* FIXME: no locking on shadowLCR anywhere in driver */
1254 mos7840_port->shadowLCR = data;
1255 dev_dbg(&port->dev, "%s mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
1256 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
1257 mos7840_port->shadowLCR);
1260 /*****************************************************************************
1261 * mos7840_write_room
1262 * this function is called by the tty driver when it wants to know how many
1263 * bytes of data we can accept for a specific port.
1264 * If successful, we return the amount of room that we have for this port
1265 * Otherwise we return a negative error number.
1266 *****************************************************************************/
1268 static int mos7840_write_room(struct tty_struct *tty)
1270 struct usb_serial_port *port = tty->driver_data;
1273 unsigned long flags;
1274 struct moschip_port *mos7840_port;
1276 if (mos7840_port_paranoia_check(port, __func__))
1279 mos7840_port = mos7840_get_port_private(port);
1280 if (mos7840_port == NULL)
1283 spin_lock_irqsave(&mos7840_port->pool_lock, flags);
1284 for (i = 0; i < NUM_URBS; ++i) {
1285 if (!mos7840_port->busy[i])
1286 room += URB_TRANSFER_BUFFER_SIZE;
1288 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
1290 room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1;
1291 dev_dbg(&mos7840_port->port->dev, "%s - returns %d\n", __func__, room);
1296 /*****************************************************************************
1298 * this function is called by the tty driver when data should be written to
1300 * If successful, we return the number of bytes written, otherwise we
1301 * return a negative error number.
1302 *****************************************************************************/
1304 static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
1305 const unsigned char *data, int count)
1311 unsigned long flags;
1313 struct moschip_port *mos7840_port;
1314 struct usb_serial *serial;
1317 const unsigned char *current_position = data;
1318 unsigned char *data1;
1320 if (mos7840_port_paranoia_check(port, __func__))
1323 serial = port->serial;
1324 if (mos7840_serial_paranoia_check(serial, __func__))
1327 mos7840_port = mos7840_get_port_private(port);
1328 if (mos7840_port == NULL)
1331 /* try to find a free urb in the list */
1334 spin_lock_irqsave(&mos7840_port->pool_lock, flags);
1335 for (i = 0; i < NUM_URBS; ++i) {
1336 if (!mos7840_port->busy[i]) {
1337 mos7840_port->busy[i] = 1;
1338 urb = mos7840_port->write_urb_pool[i];
1339 dev_dbg(&port->dev, "URB:%d\n", i);
1343 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
1346 dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
1350 if (urb->transfer_buffer == NULL) {
1351 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
1353 if (!urb->transfer_buffer) {
1354 bytes_sent = -ENOMEM;
1358 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1360 memcpy(urb->transfer_buffer, current_position, transfer_size);
1362 /* fill urb with data and submit */
1363 if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
1364 usb_fill_bulk_urb(urb,
1366 usb_sndbulkpipe(serial->dev,
1367 (port->bulk_out_endpointAddress) + 2),
1368 urb->transfer_buffer,
1370 mos7840_bulk_out_data_callback, mos7840_port);
1372 usb_fill_bulk_urb(urb,
1374 usb_sndbulkpipe(serial->dev,
1375 port->bulk_out_endpointAddress),
1376 urb->transfer_buffer,
1378 mos7840_bulk_out_data_callback, mos7840_port);
1381 data1 = urb->transfer_buffer;
1382 dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress);
1384 if (mos7840_port->has_led)
1385 mos7840_led_activity(port);
1387 /* send it down the pipe */
1388 status = usb_submit_urb(urb, GFP_ATOMIC);
1391 mos7840_port->busy[i] = 0;
1392 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
1393 "with status = %d\n", __func__, status);
1394 bytes_sent = status;
1397 bytes_sent = transfer_size;
1398 port->icount.tx += transfer_size;
1399 dev_dbg(&port->dev, "icount.tx is %d:\n", port->icount.tx);
1405 /*****************************************************************************
1407 * this function is called by the tty driver when it wants to stop the data
1408 * being read from the port.
1409 *****************************************************************************/
1411 static void mos7840_throttle(struct tty_struct *tty)
1413 struct usb_serial_port *port = tty->driver_data;
1414 struct moschip_port *mos7840_port;
1417 if (mos7840_port_paranoia_check(port, __func__))
1420 mos7840_port = mos7840_get_port_private(port);
1422 if (mos7840_port == NULL)
1425 if (!mos7840_port->open) {
1426 dev_dbg(&port->dev, "%s", "port not opened\n");
1430 /* if we are implementing XON/XOFF, send the stop character */
1432 unsigned char stop_char = STOP_CHAR(tty);
1433 status = mos7840_write(tty, port, &stop_char, 1);
1437 /* if we are implementing RTS/CTS, toggle that line */
1438 if (C_CRTSCTS(tty)) {
1439 mos7840_port->shadowMCR &= ~MCR_RTS;
1440 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1441 mos7840_port->shadowMCR);
1447 /*****************************************************************************
1448 * mos7840_unthrottle
1449 * this function is called by the tty driver when it wants to resume
1450 * the data being read from the port (called after mos7840_throttle is
1452 *****************************************************************************/
1453 static void mos7840_unthrottle(struct tty_struct *tty)
1455 struct usb_serial_port *port = tty->driver_data;
1457 struct moschip_port *mos7840_port = mos7840_get_port_private(port);
1459 if (mos7840_port_paranoia_check(port, __func__))
1462 if (mos7840_port == NULL)
1465 if (!mos7840_port->open) {
1466 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1470 /* if we are implementing XON/XOFF, send the start character */
1472 unsigned char start_char = START_CHAR(tty);
1473 status = mos7840_write(tty, port, &start_char, 1);
1478 /* if we are implementing RTS/CTS, toggle that line */
1479 if (C_CRTSCTS(tty)) {
1480 mos7840_port->shadowMCR |= MCR_RTS;
1481 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1482 mos7840_port->shadowMCR);
1488 static int mos7840_tiocmget(struct tty_struct *tty)
1490 struct usb_serial_port *port = tty->driver_data;
1491 struct moschip_port *mos7840_port;
1492 unsigned int result;
1496 mos7840_port = mos7840_get_port_private(port);
1498 if (mos7840_port == NULL)
1501 status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
1504 status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
1507 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
1508 | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
1509 | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
1510 | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)
1511 | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)
1512 | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
1513 | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
1515 dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
1520 static int mos7840_tiocmset(struct tty_struct *tty,
1521 unsigned int set, unsigned int clear)
1523 struct usb_serial_port *port = tty->driver_data;
1524 struct moschip_port *mos7840_port;
1528 mos7840_port = mos7840_get_port_private(port);
1530 if (mos7840_port == NULL)
1533 /* FIXME: What locks the port registers ? */
1534 mcr = mos7840_port->shadowMCR;
1535 if (clear & TIOCM_RTS)
1537 if (clear & TIOCM_DTR)
1539 if (clear & TIOCM_LOOP)
1540 mcr &= ~MCR_LOOPBACK;
1542 if (set & TIOCM_RTS)
1544 if (set & TIOCM_DTR)
1546 if (set & TIOCM_LOOP)
1547 mcr |= MCR_LOOPBACK;
1549 mos7840_port->shadowMCR = mcr;
1551 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
1553 dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n");
1560 /*****************************************************************************
1561 * mos7840_calc_baud_rate_divisor
1562 * this function calculates the proper baud rate divisor for the specified
1564 *****************************************************************************/
1565 static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
1566 int baudRate, int *divisor,
1569 dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate);
1571 if (baudRate <= 115200) {
1572 *divisor = 115200 / baudRate;
1575 if ((baudRate > 115200) && (baudRate <= 230400)) {
1576 *divisor = 230400 / baudRate;
1577 *clk_sel_val = 0x10;
1578 } else if ((baudRate > 230400) && (baudRate <= 403200)) {
1579 *divisor = 403200 / baudRate;
1580 *clk_sel_val = 0x20;
1581 } else if ((baudRate > 403200) && (baudRate <= 460800)) {
1582 *divisor = 460800 / baudRate;
1583 *clk_sel_val = 0x30;
1584 } else if ((baudRate > 460800) && (baudRate <= 806400)) {
1585 *divisor = 806400 / baudRate;
1586 *clk_sel_val = 0x40;
1587 } else if ((baudRate > 806400) && (baudRate <= 921600)) {
1588 *divisor = 921600 / baudRate;
1589 *clk_sel_val = 0x50;
1590 } else if ((baudRate > 921600) && (baudRate <= 1572864)) {
1591 *divisor = 1572864 / baudRate;
1592 *clk_sel_val = 0x60;
1593 } else if ((baudRate > 1572864) && (baudRate <= 3145728)) {
1594 *divisor = 3145728 / baudRate;
1595 *clk_sel_val = 0x70;
1600 /*****************************************************************************
1601 * mos7840_send_cmd_write_baud_rate
1602 * this function sends the proper command to change the baud rate of the
1604 *****************************************************************************/
1606 static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
1612 unsigned char number;
1614 struct usb_serial_port *port;
1616 if (mos7840_port == NULL)
1619 port = mos7840_port->port;
1620 if (mos7840_port_paranoia_check(port, __func__))
1623 if (mos7840_serial_paranoia_check(port->serial, __func__))
1626 number = mos7840_port->port->port_number;
1628 dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudRate);
1629 /* reset clk_uart_sel in spregOffset */
1630 if (baudRate > 115200) {
1631 #ifdef HW_flow_control
1632 /* NOTE: need to see the pther register to modify */
1633 /* setting h/w flow control bit to 1 */
1635 mos7840_port->shadowMCR = Data;
1636 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1639 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1645 #ifdef HW_flow_control
1646 /* setting h/w flow control bit to 0 */
1648 mos7840_port->shadowMCR = Data;
1649 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1652 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1659 if (1) { /* baudRate <= 115200) */
1662 status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor,
1664 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
1667 dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n");
1670 Data = (Data & 0x8f) | clk_sel_val;
1671 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
1674 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1677 /* Calculate the Divisor */
1680 dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1683 /* Enable access to divisor latch */
1684 Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB;
1685 mos7840_port->shadowLCR = Data;
1686 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1688 /* Write the divisor */
1689 Data = (unsigned char)(divisor & 0xff);
1690 dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data);
1691 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1693 Data = (unsigned char)((divisor & 0xff00) >> 8);
1694 dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data);
1695 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1697 /* Disable access to divisor latch */
1698 Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB;
1699 mos7840_port->shadowLCR = Data;
1700 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1706 /*****************************************************************************
1707 * mos7840_change_port_settings
1708 * This routine is called to set the UART on the device to match
1709 * the specified new settings.
1710 *****************************************************************************/
1712 static void mos7840_change_port_settings(struct tty_struct *tty,
1713 struct moschip_port *mos7840_port, struct ktermios *old_termios)
1723 struct usb_serial_port *port;
1724 struct usb_serial *serial;
1726 if (mos7840_port == NULL)
1729 port = mos7840_port->port;
1731 if (mos7840_port_paranoia_check(port, __func__))
1734 if (mos7840_serial_paranoia_check(port->serial, __func__))
1737 serial = port->serial;
1739 if (!mos7840_port->open) {
1740 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1746 lParity = LCR_PAR_NONE;
1748 cflag = tty->termios.c_cflag;
1749 iflag = tty->termios.c_iflag;
1751 /* Change the number of bits */
1752 switch (cflag & CSIZE) {
1771 /* Change the Parity bit */
1772 if (cflag & PARENB) {
1773 if (cflag & PARODD) {
1774 lParity = LCR_PAR_ODD;
1775 dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1777 lParity = LCR_PAR_EVEN;
1778 dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1782 dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1786 lParity = lParity | 0x20;
1788 /* Change the Stop bit */
1789 if (cflag & CSTOPB) {
1791 dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1794 dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1797 /* Update the LCR with the correct value */
1798 mos7840_port->shadowLCR &=
1799 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1800 mos7840_port->shadowLCR |= (lData | lParity | lStop);
1802 dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__,
1803 mos7840_port->shadowLCR);
1804 /* Disable Interrupts */
1806 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1809 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1812 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1814 /* Send the updated LCR value to the mos7840 */
1815 Data = mos7840_port->shadowLCR;
1817 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1820 mos7840_port->shadowMCR = Data;
1821 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1823 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1825 /* set up the MCR register and send it to the mos7840 */
1827 mos7840_port->shadowMCR = MCR_MASTER_IE;
1829 mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS);
1831 if (cflag & CRTSCTS)
1832 mos7840_port->shadowMCR |= (MCR_XON_ANY);
1834 mos7840_port->shadowMCR &= ~(MCR_XON_ANY);
1836 Data = mos7840_port->shadowMCR;
1837 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1839 /* Determine divisor based on baud rate */
1840 baud = tty_get_baud_rate(tty);
1843 /* pick a default, any default... */
1844 dev_dbg(&port->dev, "%s", "Picked default baud...\n");
1848 dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1849 status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
1851 /* Enable Interrupts */
1853 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1855 if (!mos7840_port->read_urb_busy) {
1856 mos7840_port->read_urb_busy = true;
1857 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1859 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1861 mos7840_port->read_urb_busy = false;
1864 dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__,
1865 mos7840_port->shadowLCR);
1868 /*****************************************************************************
1869 * mos7840_set_termios
1870 * this function is called by the tty driver when it wants to change
1871 * the termios structure
1872 *****************************************************************************/
1874 static void mos7840_set_termios(struct tty_struct *tty,
1875 struct usb_serial_port *port,
1876 struct ktermios *old_termios)
1879 struct usb_serial *serial;
1880 struct moschip_port *mos7840_port;
1882 if (mos7840_port_paranoia_check(port, __func__))
1885 serial = port->serial;
1887 if (mos7840_serial_paranoia_check(serial, __func__))
1890 mos7840_port = mos7840_get_port_private(port);
1892 if (mos7840_port == NULL)
1895 if (!mos7840_port->open) {
1896 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1900 /* change the port settings to the new ones specified */
1902 mos7840_change_port_settings(tty, mos7840_port, old_termios);
1904 if (!mos7840_port->read_urb) {
1905 dev_dbg(&port->dev, "%s", "URB KILLED !!!!!\n");
1909 if (!mos7840_port->read_urb_busy) {
1910 mos7840_port->read_urb_busy = true;
1911 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1913 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1915 mos7840_port->read_urb_busy = false;
1920 /*****************************************************************************
1921 * mos7840_get_lsr_info - get line status register info
1923 * Purpose: Let user call ioctl() to get info when the UART physically
1924 * is emptied. On bus types like RS485, the transmitter must
1925 * release the bus after transmitting. This must be done when
1926 * the transmit shift register is empty, not be done when the
1927 * transmit holding register is empty. This functionality
1928 * allows an RS485 driver to be written in user space.
1929 *****************************************************************************/
1931 static int mos7840_get_lsr_info(struct tty_struct *tty,
1932 unsigned int __user *value)
1935 unsigned int result = 0;
1937 count = mos7840_chars_in_buffer(tty);
1939 result = TIOCSER_TEMT;
1941 if (copy_to_user(value, &result, sizeof(int)))
1946 /*****************************************************************************
1947 * mos7840_get_serial_info
1948 * function to get information about serial port
1949 *****************************************************************************/
1951 static int mos7840_get_serial_info(struct moschip_port *mos7840_port,
1952 struct serial_struct __user *retinfo)
1954 struct serial_struct tmp;
1956 if (mos7840_port == NULL)
1959 memset(&tmp, 0, sizeof(tmp));
1961 tmp.type = PORT_16550A;
1962 tmp.line = mos7840_port->port->minor;
1963 tmp.port = mos7840_port->port->port_number;
1965 tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE;
1966 tmp.baud_base = 9600;
1967 tmp.close_delay = 5 * HZ;
1968 tmp.closing_wait = 30 * HZ;
1970 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1975 /*****************************************************************************
1977 * this function handles any ioctl calls to the driver
1978 *****************************************************************************/
1980 static int mos7840_ioctl(struct tty_struct *tty,
1981 unsigned int cmd, unsigned long arg)
1983 struct usb_serial_port *port = tty->driver_data;
1984 void __user *argp = (void __user *)arg;
1985 struct moschip_port *mos7840_port;
1987 if (mos7840_port_paranoia_check(port, __func__))
1990 mos7840_port = mos7840_get_port_private(port);
1992 if (mos7840_port == NULL)
1996 /* return number of bytes available */
1999 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
2000 return mos7840_get_lsr_info(tty, argp);
2003 dev_dbg(&port->dev, "%s TIOCGSERIAL\n", __func__);
2004 return mos7840_get_serial_info(mos7840_port, argp);
2007 dev_dbg(&port->dev, "%s TIOCSSERIAL\n", __func__);
2012 return -ENOIOCTLCMD;
2015 static int mos7810_check(struct usb_serial *serial)
2017 int i, pass_count = 0;
2019 __u16 data = 0, mcr_data = 0;
2020 __u16 test_pattern = 0x55AA;
2023 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
2025 return 0; /* failed to identify 7810 */
2027 /* Store MCR setting */
2028 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2029 MCS_RDREQ, MCS_RD_RTYPE, 0x0300, MODEM_CONTROL_REGISTER,
2030 buf, VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
2031 if (res == VENDOR_READ_LENGTH)
2034 for (i = 0; i < 16; i++) {
2035 /* Send the 1-bit test pattern out to MCS7810 test pin */
2036 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2037 MCS_WRREQ, MCS_WR_RTYPE,
2038 (0x0300 | (((test_pattern >> i) & 0x0001) << 1)),
2039 MODEM_CONTROL_REGISTER, NULL, 0, MOS_WDR_TIMEOUT);
2041 /* Read the test pattern back */
2042 res = usb_control_msg(serial->dev,
2043 usb_rcvctrlpipe(serial->dev, 0), MCS_RDREQ,
2044 MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
2045 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
2046 if (res == VENDOR_READ_LENGTH)
2049 /* If this is a MCS7810 device, both test patterns must match */
2050 if (((test_pattern >> i) ^ (~data >> 1)) & 0x0001)
2056 /* Restore MCR setting */
2057 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), MCS_WRREQ,
2058 MCS_WR_RTYPE, 0x0300 | mcr_data, MODEM_CONTROL_REGISTER, NULL,
2059 0, MOS_WDR_TIMEOUT);
2063 if (pass_count == 16)
2069 static int mos7840_probe(struct usb_serial *serial,
2070 const struct usb_device_id *id)
2072 u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
2073 u16 vid = le16_to_cpu(serial->dev->descriptor.idVendor);
2077 if (product == MOSCHIP_DEVICE_ID_7810 ||
2078 product == MOSCHIP_DEVICE_ID_7820) {
2079 device_type = product;
2083 if (vid == USB_VENDOR_ID_MOXA && product == MOXA_DEVICE_ID_2210) {
2084 device_type = MOSCHIP_DEVICE_ID_7820;
2088 buf = kzalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
2092 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2093 MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
2094 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
2096 /* For a MCS7840 device GPIO0 must be set to 1 */
2098 device_type = MOSCHIP_DEVICE_ID_7840;
2099 else if (mos7810_check(serial))
2100 device_type = MOSCHIP_DEVICE_ID_7810;
2102 device_type = MOSCHIP_DEVICE_ID_7820;
2106 usb_set_serial_data(serial, (void *)(unsigned long)device_type);
2111 static int mos7840_calc_num_ports(struct usb_serial *serial,
2112 struct usb_serial_endpoints *epds)
2114 int device_type = (unsigned long)usb_get_serial_data(serial);
2117 num_ports = (device_type >> 4) & 0x000F;
2120 * num_ports is currently never zero as device_type is one of
2121 * MOSCHIP_DEVICE_ID_78{1,2,4}0.
2126 if (epds->num_bulk_in < num_ports || epds->num_bulk_out < num_ports) {
2127 dev_err(&serial->interface->dev, "missing endpoints\n");
2134 static int mos7840_port_probe(struct usb_serial_port *port)
2136 struct usb_serial *serial = port->serial;
2137 int device_type = (unsigned long)usb_get_serial_data(serial);
2138 struct moschip_port *mos7840_port;
2143 /* we set up the pointers to the endpoints in the mos7840_open *
2144 * function, as the structures aren't created yet. */
2146 pnum = port->port_number;
2148 dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum);
2149 mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
2153 /* Initialize all port interrupt end point to port 0 int
2154 * endpoint. Our device has only one interrupt end point
2155 * common to all port */
2157 mos7840_port->port = port;
2158 mos7840_set_port_private(port, mos7840_port);
2159 spin_lock_init(&mos7840_port->pool_lock);
2161 /* minor is not initialised until later by
2162 * usb-serial.c:get_free_serial() and cannot therefore be used
2163 * to index device instances */
2164 mos7840_port->port_num = pnum + 1;
2165 dev_dbg(&port->dev, "port->minor = %d\n", port->minor);
2166 dev_dbg(&port->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num);
2168 if (mos7840_port->port_num == 1) {
2169 mos7840_port->SpRegOffset = 0x0;
2170 mos7840_port->ControlRegOffset = 0x1;
2171 mos7840_port->DcrRegOffset = 0x4;
2172 } else if ((mos7840_port->port_num == 2) && (serial->num_ports == 4)) {
2173 mos7840_port->SpRegOffset = 0x8;
2174 mos7840_port->ControlRegOffset = 0x9;
2175 mos7840_port->DcrRegOffset = 0x16;
2176 } else if ((mos7840_port->port_num == 2) && (serial->num_ports == 2)) {
2177 mos7840_port->SpRegOffset = 0xa;
2178 mos7840_port->ControlRegOffset = 0xb;
2179 mos7840_port->DcrRegOffset = 0x19;
2180 } else if ((mos7840_port->port_num == 3) && (serial->num_ports == 4)) {
2181 mos7840_port->SpRegOffset = 0xa;
2182 mos7840_port->ControlRegOffset = 0xb;
2183 mos7840_port->DcrRegOffset = 0x19;
2184 } else if ((mos7840_port->port_num == 4) && (serial->num_ports == 4)) {
2185 mos7840_port->SpRegOffset = 0xc;
2186 mos7840_port->ControlRegOffset = 0xd;
2187 mos7840_port->DcrRegOffset = 0x1c;
2189 mos7840_dump_serial_port(port, mos7840_port);
2190 mos7840_set_port_private(port, mos7840_port);
2192 /* enable rx_disable bit in control register */
2193 status = mos7840_get_reg_sync(port,
2194 mos7840_port->ControlRegOffset, &Data);
2196 dev_dbg(&port->dev, "Reading ControlReg failed status-0x%x\n", status);
2199 dev_dbg(&port->dev, "ControlReg Reading success val is %x, status%d\n", Data, status);
2200 Data |= 0x08; /* setting driver done bit */
2201 Data |= 0x04; /* sp1_bit to have cts change reflect in
2204 /* Data |= 0x20; //rx_disable bit */
2205 status = mos7840_set_reg_sync(port,
2206 mos7840_port->ControlRegOffset, Data);
2208 dev_dbg(&port->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status);
2211 dev_dbg(&port->dev, "ControlReg Writing success(rx_disable) status%d\n", status);
2213 /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
2216 status = mos7840_set_reg_sync(port,
2217 (__u16) (mos7840_port->DcrRegOffset + 0), Data);
2219 dev_dbg(&port->dev, "Writing DCR0 failed status-0x%x\n", status);
2222 dev_dbg(&port->dev, "DCR0 Writing success status%d\n", status);
2225 status = mos7840_set_reg_sync(port,
2226 (__u16) (mos7840_port->DcrRegOffset + 1), Data);
2228 dev_dbg(&port->dev, "Writing DCR1 failed status-0x%x\n", status);
2231 dev_dbg(&port->dev, "DCR1 Writing success status%d\n", status);
2234 status = mos7840_set_reg_sync(port,
2235 (__u16) (mos7840_port->DcrRegOffset + 2), Data);
2237 dev_dbg(&port->dev, "Writing DCR2 failed status-0x%x\n", status);
2240 dev_dbg(&port->dev, "DCR2 Writing success status%d\n", status);
2242 /* write values in clkstart0x0 and clkmulti 0x20 */
2244 status = mos7840_set_reg_sync(port, CLK_START_VALUE_REGISTER, Data);
2246 dev_dbg(&port->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status);
2249 dev_dbg(&port->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status);
2252 status = mos7840_set_reg_sync(port, CLK_MULTI_REGISTER, Data);
2254 dev_dbg(&port->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status);
2257 dev_dbg(&port->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status);
2259 /* write value 0x0 to scratchpad register */
2261 status = mos7840_set_uart_reg(port, SCRATCH_PAD_REGISTER, Data);
2263 dev_dbg(&port->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status);
2266 dev_dbg(&port->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status);
2268 /* Zero Length flag register */
2269 if ((mos7840_port->port_num != 1) && (serial->num_ports == 2)) {
2271 status = mos7840_set_reg_sync(port,
2273 ((__u16)mos7840_port->port_num)), Data);
2274 dev_dbg(&port->dev, "ZLIP offset %x\n",
2275 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num)));
2277 dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 2, status);
2280 dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 2, status);
2283 status = mos7840_set_reg_sync(port,
2285 ((__u16)mos7840_port->port_num) - 0x1), Data);
2286 dev_dbg(&port->dev, "ZLIP offset %x\n",
2287 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1));
2289 dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 1, status);
2292 dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 1, status);
2295 mos7840_port->control_urb = usb_alloc_urb(0, GFP_KERNEL);
2296 mos7840_port->ctrl_buf = kmalloc(16, GFP_KERNEL);
2297 mos7840_port->dr = kmalloc(sizeof(struct usb_ctrlrequest),
2299 if (!mos7840_port->control_urb || !mos7840_port->ctrl_buf ||
2300 !mos7840_port->dr) {
2305 mos7840_port->has_led = false;
2307 /* Initialize LED timers */
2308 if (device_type == MOSCHIP_DEVICE_ID_7810) {
2309 mos7840_port->has_led = true;
2311 mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL);
2312 mos7840_port->led_dr = kmalloc(sizeof(*mos7840_port->led_dr),
2314 if (!mos7840_port->led_urb || !mos7840_port->led_dr) {
2319 setup_timer(&mos7840_port->led_timer1, mos7840_led_off,
2320 (unsigned long)mos7840_port);
2321 mos7840_port->led_timer1.expires =
2322 jiffies + msecs_to_jiffies(LED_ON_MS);
2323 setup_timer(&mos7840_port->led_timer2, mos7840_led_flag_off,
2324 (unsigned long)mos7840_port);
2325 mos7840_port->led_timer2.expires =
2326 jiffies + msecs_to_jiffies(LED_OFF_MS);
2329 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
2332 if (pnum == serial->num_ports - 1) {
2333 /* Zero Length flag enable */
2335 status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data);
2337 dev_dbg(&port->dev, "Writing ZLP_REG5 failed status-0x%x\n", status);
2340 dev_dbg(&port->dev, "ZLP_REG5 Writing success status%d\n", status);
2344 kfree(mos7840_port->led_dr);
2345 usb_free_urb(mos7840_port->led_urb);
2346 kfree(mos7840_port->dr);
2347 kfree(mos7840_port->ctrl_buf);
2348 usb_free_urb(mos7840_port->control_urb);
2349 kfree(mos7840_port);
2354 static int mos7840_port_remove(struct usb_serial_port *port)
2356 struct moschip_port *mos7840_port;
2358 mos7840_port = mos7840_get_port_private(port);
2360 if (mos7840_port->has_led) {
2362 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
2364 del_timer_sync(&mos7840_port->led_timer1);
2365 del_timer_sync(&mos7840_port->led_timer2);
2367 usb_kill_urb(mos7840_port->led_urb);
2368 usb_free_urb(mos7840_port->led_urb);
2369 kfree(mos7840_port->led_dr);
2371 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);
2380 static struct usb_serial_driver moschip7840_4port_device = {
2382 .owner = THIS_MODULE,
2385 .description = DRIVER_DESC,
2386 .id_table = id_table,
2387 .num_interrupt_in = 1,
2388 .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,
2396 .probe = mos7840_probe,
2397 .ioctl = mos7840_ioctl,
2398 .set_termios = mos7840_set_termios,
2399 .break_ctl = mos7840_break,
2400 .tiocmget = mos7840_tiocmget,
2401 .tiocmset = mos7840_tiocmset,
2402 .tiocmiwait = usb_serial_generic_tiocmiwait,
2403 .get_icount = usb_serial_generic_get_icount,
2404 .port_probe = mos7840_port_probe,
2405 .port_remove = mos7840_port_remove,
2406 .read_bulk_callback = mos7840_bulk_in_callback,
2407 .read_int_callback = mos7840_interrupt_callback,
2410 static struct usb_serial_driver * const serial_drivers[] = {
2411 &moschip7840_4port_device, NULL
2414 module_usb_serial_driver(serial_drivers, id_table);
2416 MODULE_DESCRIPTION(DRIVER_DESC);
2417 MODULE_LICENSE("GPL");