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/init.h>
28 #include <linux/slab.h>
29 #include <linux/tty.h>
30 #include <linux/tty_driver.h>
31 #include <linux/tty_flip.h>
32 #include <linux/module.h>
33 #include <linux/serial.h>
34 #include <linux/usb.h>
35 #include <linux/usb/serial.h>
36 #include <asm/uaccess.h>
41 #define DRIVER_VERSION "1.3.1"
42 #define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver"
45 * 16C50 UART register defines
48 #define LCR_BITS_5 0x00 /* 5 bits/char */
49 #define LCR_BITS_6 0x01 /* 6 bits/char */
50 #define LCR_BITS_7 0x02 /* 7 bits/char */
51 #define LCR_BITS_8 0x03 /* 8 bits/char */
52 #define LCR_BITS_MASK 0x03 /* Mask for bits/char field */
54 #define LCR_STOP_1 0x00 /* 1 stop bit */
55 #define LCR_STOP_1_5 0x04 /* 1.5 stop bits (if 5 bits/char) */
56 #define LCR_STOP_2 0x04 /* 2 stop bits (if 6-8 bits/char) */
57 #define LCR_STOP_MASK 0x04 /* Mask for stop bits field */
59 #define LCR_PAR_NONE 0x00 /* No parity */
60 #define LCR_PAR_ODD 0x08 /* Odd parity */
61 #define LCR_PAR_EVEN 0x18 /* Even parity */
62 #define LCR_PAR_MARK 0x28 /* Force parity bit to 1 */
63 #define LCR_PAR_SPACE 0x38 /* Force parity bit to 0 */
64 #define LCR_PAR_MASK 0x38 /* Mask for parity field */
66 #define LCR_SET_BREAK 0x40 /* Set Break condition */
67 #define LCR_DL_ENABLE 0x80 /* Enable access to divisor latch */
69 #define MCR_DTR 0x01 /* Assert DTR */
70 #define MCR_RTS 0x02 /* Assert RTS */
71 #define MCR_OUT1 0x04 /* Loopback only: Sets state of RI */
72 #define MCR_MASTER_IE 0x08 /* Enable interrupt outputs */
73 #define MCR_LOOPBACK 0x10 /* Set internal (digital) loopback mode */
74 #define MCR_XON_ANY 0x20 /* Enable any char to exit XOFF mode */
76 #define MOS7840_MSR_CTS 0x10 /* Current state of CTS */
77 #define MOS7840_MSR_DSR 0x20 /* Current state of DSR */
78 #define MOS7840_MSR_RI 0x40 /* Current state of RI */
79 #define MOS7840_MSR_CD 0x80 /* Current state of CD */
82 * Defines used for sending commands to port
85 #define WAIT_FOR_EVER (HZ * 0 ) /* timeout urb is wait for ever */
86 #define MOS_WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */
88 #define MOS_PORT1 0x0200
89 #define MOS_PORT2 0x0300
90 #define MOS_VENREG 0x0000
91 #define MOS_MAX_PORT 0x02
92 #define MOS_WRITE 0x0E
96 #define MCS_RD_RTYPE 0xC0
97 #define MCS_WR_RTYPE 0x40
98 #define MCS_RDREQ 0x0D
99 #define MCS_WRREQ 0x0E
100 #define MCS_CTRL_TIMEOUT 500
101 #define VENDOR_READ_LENGTH (0x01)
103 #define MAX_NAME_LEN 64
105 #define ZLP_REG1 0x3A //Zero_Flag_Reg1 58
106 #define ZLP_REG5 0x3E //Zero_Flag_Reg5 62
108 /* For higher baud Rates use TIOCEXBAUD */
109 #define TIOCEXBAUD 0x5462
111 /* vendor id and device id defines */
113 #define USB_VENDOR_ID_MOSCHIP 0x9710
114 #define MOSCHIP_DEVICE_ID_7840 0x7840
115 #define MOSCHIP_DEVICE_ID_7820 0x7820
117 /* Interrupt Rotinue Defines */
119 #define SERIAL_IIR_RLS 0x06
120 #define SERIAL_IIR_MS 0x00
123 * Emulation of the bit mask on the LINE STATUS REGISTER.
125 #define SERIAL_LSR_DR 0x0001
126 #define SERIAL_LSR_OE 0x0002
127 #define SERIAL_LSR_PE 0x0004
128 #define SERIAL_LSR_FE 0x0008
129 #define SERIAL_LSR_BI 0x0010
131 #define MOS_MSR_DELTA_CTS 0x10
132 #define MOS_MSR_DELTA_DSR 0x20
133 #define MOS_MSR_DELTA_RI 0x40
134 #define MOS_MSR_DELTA_CD 0x80
136 // Serial Port register Address
137 #define INTERRUPT_ENABLE_REGISTER ((__u16)(0x01))
138 #define FIFO_CONTROL_REGISTER ((__u16)(0x02))
139 #define LINE_CONTROL_REGISTER ((__u16)(0x03))
140 #define MODEM_CONTROL_REGISTER ((__u16)(0x04))
141 #define LINE_STATUS_REGISTER ((__u16)(0x05))
142 #define MODEM_STATUS_REGISTER ((__u16)(0x06))
143 #define SCRATCH_PAD_REGISTER ((__u16)(0x07))
144 #define DIVISOR_LATCH_LSB ((__u16)(0x00))
145 #define DIVISOR_LATCH_MSB ((__u16)(0x01))
147 #define CLK_MULTI_REGISTER ((__u16)(0x02))
148 #define CLK_START_VALUE_REGISTER ((__u16)(0x03))
150 #define SERIAL_LCR_DLAB ((__u16)(0x0080))
153 * URB POOL related defines
155 #define NUM_URBS 16 /* URB Count */
156 #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */
159 static struct usb_device_id moschip_port_id_table
[] = {
160 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP
, MOSCHIP_DEVICE_ID_7840
)},
161 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP
, MOSCHIP_DEVICE_ID_7820
)},
162 {} /* terminating entry */
165 static __devinitdata
struct usb_device_id moschip_id_table_combined
[] = {
166 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP
, MOSCHIP_DEVICE_ID_7840
)},
167 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP
, MOSCHIP_DEVICE_ID_7820
)},
168 {} /* terminating entry */
171 MODULE_DEVICE_TABLE(usb
, moschip_id_table_combined
);
173 /* This structure holds all of the local port information */
175 struct moschip_port
{
176 int port_num
; /*Actual port number in the device(1,2,etc) */
177 struct urb
*write_urb
; /* write URB for this port */
178 struct urb
*read_urb
; /* read URB for this port */
179 __u8 shadowLCR
; /* last LCR value received */
180 __u8 shadowMCR
; /* last MCR value received */
182 wait_queue_head_t wait_chase
; /* for handling sleeping while waiting for chase to finish */
183 wait_queue_head_t delta_msr_wait
; /* for handling sleeping while waiting for msr change to happen */
185 struct async_icount icount
;
186 struct usb_serial_port
*port
; /* loop back to the owner of this object */
190 __u8 ControlRegOffset
;
192 //for processing control URBS in interrupt context
193 struct urb
*control_urb
;
197 struct urb
*write_urb_pool
[NUM_URBS
];
202 static int mos7840_num_ports
; //this says the number of ports in the device
203 static int mos7840_num_open_ports
;
207 * mos7840_set_reg_sync
208 * To set the Control register by calling usb_fill_control_urb function
209 * by passing usb_sndctrlpipe function as parameter.
212 static int mos7840_set_reg_sync(struct usb_serial_port
*port
, __u16 reg
,
215 struct usb_device
*dev
= port
->serial
->dev
;
217 dbg("mos7840_set_reg_sync offset is %x, value %x\n", reg
, val
);
219 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), MCS_WRREQ
,
220 MCS_WR_RTYPE
, val
, reg
, NULL
, 0,
225 * mos7840_get_reg_sync
226 * To set the Uart register by calling usb_fill_control_urb function by
227 * passing usb_rcvctrlpipe function as parameter.
230 static int mos7840_get_reg_sync(struct usb_serial_port
*port
, __u16 reg
,
233 struct usb_device
*dev
= port
->serial
->dev
;
236 ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), MCS_RDREQ
,
237 MCS_RD_RTYPE
, 0, reg
, val
, VENDOR_READ_LENGTH
,
239 dbg("mos7840_get_reg_sync offset is %x, return val %x\n", reg
, *val
);
240 *val
= (*val
) & 0x00ff;
245 * mos7840_set_uart_reg
246 * To set the Uart register by calling usb_fill_control_urb function by
247 * passing usb_sndctrlpipe function as parameter.
250 static int mos7840_set_uart_reg(struct usb_serial_port
*port
, __u16 reg
,
254 struct usb_device
*dev
= port
->serial
->dev
;
256 // For the UART control registers, the application number need to be Or'ed
257 if (mos7840_num_ports
== 4) {
259 (((__u16
) port
->number
- (__u16
) (port
->serial
->minor
)) +
261 dbg("mos7840_set_uart_reg application number is %x\n", val
);
263 if (((__u16
) port
->number
- (__u16
) (port
->serial
->minor
)) == 0) {
265 (((__u16
) port
->number
-
266 (__u16
) (port
->serial
->minor
)) + 1) << 8;
267 dbg("mos7840_set_uart_reg application number is %x\n",
271 (((__u16
) port
->number
-
272 (__u16
) (port
->serial
->minor
)) + 2) << 8;
273 dbg("mos7840_set_uart_reg application number is %x\n",
277 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), MCS_WRREQ
,
278 MCS_WR_RTYPE
, val
, reg
, NULL
, 0,
284 * mos7840_get_uart_reg
285 * To set the Control register by calling usb_fill_control_urb function
286 * by passing usb_rcvctrlpipe function as parameter.
288 static int mos7840_get_uart_reg(struct usb_serial_port
*port
, __u16 reg
,
291 struct usb_device
*dev
= port
->serial
->dev
;
295 //dbg("application number is %4x \n",(((__u16)port->number - (__u16)(port->serial->minor))+1)<<8);
296 /*Wval is same as application number */
297 if (mos7840_num_ports
== 4) {
299 (((__u16
) port
->number
- (__u16
) (port
->serial
->minor
)) +
301 dbg("mos7840_get_uart_reg application number is %x\n", Wval
);
303 if (((__u16
) port
->number
- (__u16
) (port
->serial
->minor
)) == 0) {
305 (((__u16
) port
->number
-
306 (__u16
) (port
->serial
->minor
)) + 1) << 8;
307 dbg("mos7840_get_uart_reg application number is %x\n",
311 (((__u16
) port
->number
-
312 (__u16
) (port
->serial
->minor
)) + 2) << 8;
313 dbg("mos7840_get_uart_reg application number is %x\n",
317 ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), MCS_RDREQ
,
318 MCS_RD_RTYPE
, Wval
, reg
, val
, VENDOR_READ_LENGTH
,
320 *val
= (*val
) & 0x00ff;
324 static void mos7840_dump_serial_port(struct moschip_port
*mos7840_port
)
327 dbg("***************************************\n");
328 dbg("SpRegOffset is %2x\n", mos7840_port
->SpRegOffset
);
329 dbg("ControlRegOffset is %2x \n", mos7840_port
->ControlRegOffset
);
330 dbg("DCRRegOffset is %2x \n", mos7840_port
->DcrRegOffset
);
331 dbg("***************************************\n");
335 /************************************************************************/
336 /************************************************************************/
337 /* I N T E R F A C E F U N C T I O N S */
338 /* I N T E R F A C E F U N C T I O N S */
339 /************************************************************************/
340 /************************************************************************/
342 static inline void mos7840_set_port_private(struct usb_serial_port
*port
,
343 struct moschip_port
*data
)
345 usb_set_serial_port_data(port
, (void *)data
);
348 static inline struct moschip_port
*mos7840_get_port_private(struct
352 return (struct moschip_port
*)usb_get_serial_port_data(port
);
355 static int mos7840_handle_new_msr(struct moschip_port
*port
, __u8 new_msr
)
357 struct moschip_port
*mos7840_port
;
358 struct async_icount
*icount
;
360 icount
= &mos7840_port
->icount
;
362 (MOS_MSR_DELTA_CTS
| MOS_MSR_DELTA_DSR
| MOS_MSR_DELTA_RI
|
364 icount
= &mos7840_port
->icount
;
366 /* update input line counters */
367 if (new_msr
& MOS_MSR_DELTA_CTS
) {
370 if (new_msr
& MOS_MSR_DELTA_DSR
) {
373 if (new_msr
& MOS_MSR_DELTA_CD
) {
376 if (new_msr
& MOS_MSR_DELTA_RI
) {
384 static int mos7840_handle_new_lsr(struct moschip_port
*port
, __u8 new_lsr
)
386 struct async_icount
*icount
;
388 dbg("%s - %02x", __FUNCTION__
, new_lsr
);
390 if (new_lsr
& SERIAL_LSR_BI
) {
392 // Parity and Framing errors only count if they
393 // occur exclusive of a break being
396 new_lsr
&= (__u8
) (SERIAL_LSR_OE
| SERIAL_LSR_BI
);
399 /* update input line counters */
400 icount
= &port
->icount
;
401 if (new_lsr
& SERIAL_LSR_BI
) {
404 if (new_lsr
& SERIAL_LSR_OE
) {
407 if (new_lsr
& SERIAL_LSR_PE
) {
410 if (new_lsr
& SERIAL_LSR_FE
) {
417 /************************************************************************/
418 /************************************************************************/
419 /* U S B C A L L B A C K F U N C T I O N S */
420 /* U S B C A L L B A C K F U N C T I O N S */
421 /************************************************************************/
422 /************************************************************************/
424 static void mos7840_control_callback(struct urb
*urb
)
427 struct moschip_port
*mos7840_port
;
431 dbg("%s", "Invalid Pointer !!!!:\n");
435 switch (urb
->status
) {
442 /* this urb is terminated, clean up */
443 dbg("%s - urb shutting down with status: %d", __FUNCTION__
,
447 dbg("%s - nonzero urb status received: %d", __FUNCTION__
,
452 mos7840_port
= (struct moschip_port
*)urb
->context
;
454 dbg("%s urb buffer size is %d\n", __FUNCTION__
, urb
->actual_length
);
455 dbg("%s mos7840_port->MsrLsr is %d port %d\n", __FUNCTION__
,
456 mos7840_port
->MsrLsr
, mos7840_port
->port_num
);
457 data
= urb
->transfer_buffer
;
458 regval
= (__u8
) data
[0];
459 dbg("%s data is %x\n", __FUNCTION__
, regval
);
460 if (mos7840_port
->MsrLsr
== 0)
461 mos7840_handle_new_msr(mos7840_port
, regval
);
462 else if (mos7840_port
->MsrLsr
== 1)
463 mos7840_handle_new_lsr(mos7840_port
, regval
);
469 static int mos7840_get_reg(struct moschip_port
*mcs
, __u16 Wval
, __u16 reg
,
472 struct usb_device
*dev
= mcs
->port
->serial
->dev
;
473 struct usb_ctrlrequest
*dr
= NULL
;
474 unsigned char *buffer
= NULL
;
476 buffer
= (__u8
*) mcs
->ctrl_buf
;
478 // dr=(struct usb_ctrlrequest *)(buffer);
479 dr
= (void *)(buffer
+ 2);
480 dr
->bRequestType
= MCS_RD_RTYPE
;
481 dr
->bRequest
= MCS_RDREQ
;
482 dr
->wValue
= cpu_to_le16(Wval
); //0;
483 dr
->wIndex
= cpu_to_le16(reg
);
484 dr
->wLength
= cpu_to_le16(2);
486 usb_fill_control_urb(mcs
->control_urb
, dev
, usb_rcvctrlpipe(dev
, 0),
487 (unsigned char *)dr
, buffer
, 2,
488 mos7840_control_callback
, mcs
);
489 mcs
->control_urb
->transfer_buffer_length
= 2;
490 ret
= usb_submit_urb(mcs
->control_urb
, GFP_ATOMIC
);
494 /*****************************************************************************
495 * mos7840_interrupt_callback
496 * this is the callback function for when we have received data on the
497 * interrupt endpoint.
498 *****************************************************************************/
500 static void mos7840_interrupt_callback(struct urb
*urb
)
504 struct moschip_port
*mos7840_port
;
505 struct usb_serial
*serial
;
512 dbg("%s", " : Entering\n");
514 dbg("%s", "Invalid Pointer !!!!:\n");
518 switch (urb
->status
) {
525 /* this urb is terminated, clean up */
526 dbg("%s - urb shutting down with status: %d", __FUNCTION__
,
530 dbg("%s - nonzero urb status received: %d", __FUNCTION__
,
535 length
= urb
->actual_length
;
536 data
= urb
->transfer_buffer
;
538 serial
= (struct usb_serial
*)urb
->context
;
540 /* Moschip get 5 bytes
541 * Byte 1 IIR Port 1 (port.number is 0)
542 * Byte 2 IIR Port 2 (port.number is 1)
543 * Byte 3 IIR Port 3 (port.number is 2)
544 * Byte 4 IIR Port 4 (port.number is 3)
545 * Byte 5 FIFO status for both */
547 if (length
&& length
> 5) {
548 dbg("%s \n", "Wrong data !!!");
552 sp
[0] = (__u8
) data
[0];
553 sp
[1] = (__u8
) data
[1];
554 sp
[2] = (__u8
) data
[2];
555 sp
[3] = (__u8
) data
[3];
558 for (i
= 0; i
< serial
->num_ports
; i
++) {
559 mos7840_port
= mos7840_get_port_private(serial
->port
[i
]);
561 (((__u16
) serial
->port
[i
]->number
-
562 (__u16
) (serial
->minor
)) + 1) << 8;
563 if (mos7840_port
->open
) {
565 dbg("SP%d No Interrupt !!!\n", i
);
567 switch (sp
[i
] & 0x0f) {
569 dbg("Serial Port %d: Receiver status error or ", i
);
570 dbg("address bit detected in 9-bit mode\n");
571 mos7840_port
->MsrLsr
= 1;
572 mos7840_get_reg(mos7840_port
, wval
,
573 LINE_STATUS_REGISTER
,
577 dbg("Serial Port %d: Modem status change\n", i
);
578 mos7840_port
->MsrLsr
= 0;
579 mos7840_get_reg(mos7840_port
, wval
,
580 MODEM_STATUS_REGISTER
,
588 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
590 dev_err(&urb
->dev
->dev
,
591 "%s - Error %d submitting interrupt urb\n",
592 __FUNCTION__
, result
);
599 static int mos7840_port_paranoia_check(struct usb_serial_port
*port
,
600 const char *function
)
603 dbg("%s - port == NULL", function
);
607 dbg("%s - port->serial == NULL", function
);
614 /* Inline functions to check the sanity of a pointer that is passed to us */
615 static int mos7840_serial_paranoia_check(struct usb_serial
*serial
,
616 const char *function
)
619 dbg("%s - serial == NULL", function
);
623 dbg("%s - serial->type == NULL!", function
);
630 static struct usb_serial
*mos7840_get_usb_serial(struct usb_serial_port
*port
,
631 const char *function
)
633 /* if no port was specified, or it fails a paranoia check */
635 mos7840_port_paranoia_check(port
, function
) ||
636 mos7840_serial_paranoia_check(port
->serial
, function
)) {
637 /* then say that we don't have a valid usb_serial thing, which will * end up genrating -ENODEV return values */
644 /*****************************************************************************
645 * mos7840_bulk_in_callback
646 * this is the callback function for when we have received data on the
648 *****************************************************************************/
650 static void mos7840_bulk_in_callback(struct urb
*urb
)
654 struct usb_serial
*serial
;
655 struct usb_serial_port
*port
;
656 struct moschip_port
*mos7840_port
;
657 struct tty_struct
*tty
;
660 dbg("%s", "Invalid Pointer !!!!:\n");
665 dbg("nonzero read bulk status received: %d", urb
->status
);
669 mos7840_port
= (struct moschip_port
*)urb
->context
;
671 dbg("%s", "NULL mos7840_port pointer \n");
675 port
= (struct usb_serial_port
*)mos7840_port
->port
;
676 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
677 dbg("%s", "Port Paranoia failed \n");
681 serial
= mos7840_get_usb_serial(port
, __FUNCTION__
);
683 dbg("%s\n", "Bad serial pointer ");
687 dbg("%s\n", "Entering... \n");
689 data
= urb
->transfer_buffer
;
691 dbg("%s", "Entering ........... \n");
693 if (urb
->actual_length
) {
694 tty
= mos7840_port
->port
->tty
;
696 tty_buffer_request_room(tty
, urb
->actual_length
);
697 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
699 tty_flip_buffer_push(tty
);
701 mos7840_port
->icount
.rx
+= urb
->actual_length
;
702 dbg("mos7840_port->icount.rx is %d:\n",
703 mos7840_port
->icount
.rx
);
706 if (!mos7840_port
->read_urb
) {
707 dbg("%s", "URB KILLED !!!\n");
711 if (mos7840_port
->read_urb
->status
!= -EINPROGRESS
) {
712 mos7840_port
->read_urb
->dev
= serial
->dev
;
714 status
= usb_submit_urb(mos7840_port
->read_urb
, GFP_ATOMIC
);
717 dbg(" usb_submit_urb(read bulk) failed, status = %d",
723 /*****************************************************************************
724 * mos7840_bulk_out_data_callback
725 * this is the callback function for when we have finished sending serial data
726 * on the bulk out endpoint.
727 *****************************************************************************/
729 static void mos7840_bulk_out_data_callback(struct urb
*urb
)
731 struct moschip_port
*mos7840_port
;
732 struct tty_struct
*tty
;
734 dbg("%s", "Invalid Pointer !!!!:\n");
739 dbg("nonzero write bulk status received:%d\n", urb
->status
);
743 mos7840_port
= (struct moschip_port
*)urb
->context
;
745 dbg("%s", "NULL mos7840_port pointer \n");
749 if (mos7840_port_paranoia_check(mos7840_port
->port
, __FUNCTION__
)) {
750 dbg("%s", "Port Paranoia failed \n");
754 dbg("%s \n", "Entering .........");
756 tty
= mos7840_port
->port
->tty
;
758 if (tty
&& mos7840_port
->open
) {
759 /* let the tty driver wakeup if it has a special *
760 * write_wakeup function */
762 if ((tty
->flags
& (1 << TTY_DO_WRITE_WAKEUP
))
763 && tty
->ldisc
.write_wakeup
) {
764 (tty
->ldisc
.write_wakeup
) (tty
);
767 /* tell the tty driver that something has changed */
768 wake_up_interruptible(&tty
->write_wait
);
773 /************************************************************************/
774 /* 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 */
775 /************************************************************************/
776 #ifdef MCSSerialProbe
777 static int mos7840_serial_probe(struct usb_serial
*serial
,
778 const struct usb_device_id
*id
)
781 /*need to implement the mode_reg reading and updating\
782 structures usb_serial_ device_type\
783 (i.e num_ports, num_bulkin,bulkout etc) */
784 /* Also we can update the changes attach */
789 /*****************************************************************************
791 * this function is called by the tty driver when a port is opened
792 * If successful, we return 0
793 * Otherwise we return a negative error number.
794 *****************************************************************************/
796 static int mos7840_open(struct usb_serial_port
*port
, struct file
*filp
)
800 struct usb_serial
*serial
;
804 struct moschip_port
*mos7840_port
;
806 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
807 dbg("%s", "Port Paranoia failed \n");
811 mos7840_num_open_ports
++;
812 serial
= port
->serial
;
814 if (mos7840_serial_paranoia_check(serial
, __FUNCTION__
)) {
815 dbg("%s", "Serial Paranoia failed \n");
819 mos7840_port
= mos7840_get_port_private(port
);
821 if (mos7840_port
== NULL
)
824 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
825 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
827 /* Initialising the write urb pool */
828 for (j
= 0; j
< NUM_URBS
; ++j
) {
829 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
830 mos7840_port
->write_urb_pool
[j
] = urb
;
833 err("No more urbs???");
837 urb
->transfer_buffer
= NULL
;
838 urb
->transfer_buffer
=
839 kmalloc(URB_TRANSFER_BUFFER_SIZE
, GFP_KERNEL
);
840 if (!urb
->transfer_buffer
) {
841 err("%s-out of memory for urb buffers.", __FUNCTION__
);
846 /*****************************************************************************
847 * Initialize MCS7840 -- Write Init values to corresponding Registers
855 * 0x08 : SP1/2 Control Reg
856 *****************************************************************************/
858 //NEED to check the following Block
862 status
= mos7840_get_reg_sync(port
, mos7840_port
->SpRegOffset
, &Data
);
864 dbg("Reading Spreg failed\n");
868 status
= mos7840_set_reg_sync(port
, mos7840_port
->SpRegOffset
, Data
);
870 dbg("writing Spreg failed\n");
875 status
= mos7840_set_reg_sync(port
, mos7840_port
->SpRegOffset
, Data
);
877 dbg("writing Spreg failed\n");
880 //End of block to be checked
885 mos7840_get_reg_sync(port
, mos7840_port
->ControlRegOffset
, &Data
);
887 dbg("Reading Controlreg failed\n");
890 Data
|= 0x08; //Driver done bit
891 Data
|= 0x20; //rx_disable
894 mos7840_set_reg_sync(port
, mos7840_port
->ControlRegOffset
, Data
);
896 dbg("writing Controlreg failed\n");
899 //do register settings here
900 // Set all regs to the device default values.
901 ////////////////////////////////////
902 // First Disable all interrupts.
903 ////////////////////////////////////
907 status
= mos7840_set_uart_reg(port
, INTERRUPT_ENABLE_REGISTER
, Data
);
909 dbg("disableing interrupts failed\n");
912 // Set FIFO_CONTROL_REGISTER to the default value
915 status
= mos7840_set_uart_reg(port
, FIFO_CONTROL_REGISTER
, Data
);
917 dbg("Writing FIFO_CONTROL_REGISTER failed\n");
923 status
= mos7840_set_uart_reg(port
, FIFO_CONTROL_REGISTER
, Data
);
925 dbg("Writing FIFO_CONTROL_REGISTER failed\n");
931 status
= mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
932 mos7840_port
->shadowLCR
= Data
;
936 status
= mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
937 mos7840_port
->shadowMCR
= Data
;
941 status
= mos7840_get_uart_reg(port
, LINE_CONTROL_REGISTER
, &Data
);
942 mos7840_port
->shadowLCR
= Data
;
944 Data
|= SERIAL_LCR_DLAB
; //data latch enable in LCR 0x80
946 status
= mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
950 status
= mos7840_set_uart_reg(port
, DIVISOR_LATCH_LSB
, Data
);
954 status
= mos7840_set_uart_reg(port
, DIVISOR_LATCH_MSB
, Data
);
958 status
= mos7840_get_uart_reg(port
, LINE_CONTROL_REGISTER
, &Data
);
960 Data
= Data
& ~SERIAL_LCR_DLAB
;
962 status
= mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
963 mos7840_port
->shadowLCR
= Data
;
965 //clearing Bulkin and Bulkout Fifo
968 status
= mos7840_get_reg_sync(port
, mos7840_port
->SpRegOffset
, &Data
);
972 status
= mos7840_set_reg_sync(port
, mos7840_port
->SpRegOffset
, Data
);
976 status
= mos7840_set_reg_sync(port
, mos7840_port
->SpRegOffset
, Data
);
977 //Finally enable all interrupts
981 status
= mos7840_set_uart_reg(port
, INTERRUPT_ENABLE_REGISTER
, Data
);
983 //clearing rx_disable
987 mos7840_get_reg_sync(port
, mos7840_port
->ControlRegOffset
, &Data
);
991 mos7840_set_reg_sync(port
, mos7840_port
->ControlRegOffset
, Data
);
997 mos7840_get_reg_sync(port
, mos7840_port
->ControlRegOffset
, &Data
);
1001 mos7840_set_reg_sync(port
, mos7840_port
->ControlRegOffset
, Data
);
1003 /* force low_latency on so that our tty_push actually forces *
1004 * the data through,otherwise it is scheduled, and with *
1005 * high data rates (like with OHCI) data can get lost. */
1008 port
->tty
->low_latency
= 1;
1009 /* Check to see if we've set up our endpoint info yet *
1010 * (can't set it up in mos7840_startup as the structures *
1011 * were not set up at that time.) */
1012 if (mos7840_num_open_ports
== 1) {
1013 if (serial
->port
[0]->interrupt_in_buffer
== NULL
) {
1015 /* set up interrupt urb */
1017 usb_fill_int_urb(serial
->port
[0]->interrupt_in_urb
,
1019 usb_rcvintpipe(serial
->dev
,
1021 interrupt_in_endpointAddress
),
1022 serial
->port
[0]->interrupt_in_buffer
,
1023 serial
->port
[0]->interrupt_in_urb
->
1024 transfer_buffer_length
,
1025 mos7840_interrupt_callback
,
1027 serial
->port
[0]->interrupt_in_urb
->
1030 /* start interrupt read for mos7840 *
1031 * will continue as long as mos7840 is connected */
1034 usb_submit_urb(serial
->port
[0]->interrupt_in_urb
,
1037 err("%s - Error %d submitting interrupt urb",
1038 __FUNCTION__
, response
);
1045 /* see if we've set up our endpoint info yet *
1046 * (can't set it up in mos7840_startup as the *
1047 * structures were not set up at that time.) */
1049 dbg("port number is %d \n", port
->number
);
1050 dbg("serial number is %d \n", port
->serial
->minor
);
1051 dbg("Bulkin endpoint is %d \n", port
->bulk_in_endpointAddress
);
1052 dbg("BulkOut endpoint is %d \n", port
->bulk_out_endpointAddress
);
1053 dbg("Interrupt endpoint is %d \n", port
->interrupt_in_endpointAddress
);
1054 dbg("port's number in the device is %d\n", mos7840_port
->port_num
);
1055 mos7840_port
->read_urb
= port
->read_urb
;
1057 /* set up our bulk in urb */
1059 usb_fill_bulk_urb(mos7840_port
->read_urb
,
1061 usb_rcvbulkpipe(serial
->dev
,
1062 port
->bulk_in_endpointAddress
),
1063 port
->bulk_in_buffer
,
1064 mos7840_port
->read_urb
->transfer_buffer_length
,
1065 mos7840_bulk_in_callback
, mos7840_port
);
1067 dbg("mos7840_open: bulkin endpoint is %d\n",
1068 port
->bulk_in_endpointAddress
);
1069 response
= usb_submit_urb(mos7840_port
->read_urb
, GFP_KERNEL
);
1071 err("%s - Error %d submitting control urb", __FUNCTION__
,
1075 /* initialize our wait queues */
1076 init_waitqueue_head(&mos7840_port
->wait_chase
);
1077 init_waitqueue_head(&mos7840_port
->delta_msr_wait
);
1079 /* initialize our icount structure */
1080 memset(&(mos7840_port
->icount
), 0x00, sizeof(mos7840_port
->icount
));
1082 /* initialize our port settings */
1083 mos7840_port
->shadowMCR
= MCR_MASTER_IE
; /* Must set to enable ints! */
1084 /* send a open port command */
1085 mos7840_port
->open
= 1;
1086 //mos7840_change_port_settings(mos7840_port,old_termios);
1087 mos7840_port
->icount
.tx
= 0;
1088 mos7840_port
->icount
.rx
= 0;
1090 dbg("\n\nusb_serial serial:%p mos7840_port:%p\n usb_serial_port port:%p\n\n", serial
, mos7840_port
, port
);
1096 /*****************************************************************************
1097 * mos7840_chars_in_buffer
1098 * this function is called by the tty driver when it wants to know how many
1099 * bytes of data we currently have outstanding in the port (data that has
1100 * been written, but hasn't made it out the port yet)
1101 * If successful, we return the number of bytes left to be written in the
1103 * Otherwise we return a negative error number.
1104 *****************************************************************************/
1106 static int mos7840_chars_in_buffer(struct usb_serial_port
*port
)
1110 struct moschip_port
*mos7840_port
;
1112 dbg("%s \n", " mos7840_chars_in_buffer:entering ...........");
1114 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1115 dbg("%s", "Invalid port \n");
1119 mos7840_port
= mos7840_get_port_private(port
);
1120 if (mos7840_port
== NULL
) {
1121 dbg("%s \n", "mos7840_break:leaving ...........");
1125 for (i
= 0; i
< NUM_URBS
; ++i
) {
1126 if (mos7840_port
->write_urb_pool
[i
]->status
== -EINPROGRESS
) {
1127 chars
+= URB_TRANSFER_BUFFER_SIZE
;
1130 dbg("%s - returns %d", __FUNCTION__
, chars
);
1135 /************************************************************************
1137 * mos7840_block_until_tx_empty
1139 * This function will block the close until one of the following:
1141 * 2. The mos7840 has stopped
1142 * 3. A timout of 3 seconds without activity has expired
1144 ************************************************************************/
1145 static void mos7840_block_until_tx_empty(struct moschip_port
*mos7840_port
)
1147 int timeout
= HZ
/ 10;
1153 count
= mos7840_chars_in_buffer(mos7840_port
->port
);
1155 /* Check for Buffer status */
1160 /* Block the thread for a while */
1161 interruptible_sleep_on_timeout(&mos7840_port
->wait_chase
,
1164 /* No activity.. count down section */
1167 dbg("%s - TIMEOUT", __FUNCTION__
);
1170 /* Reset timout value back to seconds */
1176 /*****************************************************************************
1178 * this function is called by the tty driver when a port is closed
1179 *****************************************************************************/
1181 static void mos7840_close(struct usb_serial_port
*port
, struct file
*filp
)
1183 struct usb_serial
*serial
;
1184 struct moschip_port
*mos7840_port
;
1188 dbg("%s\n", "mos7840_close:entering...");
1190 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1191 dbg("%s", "Port Paranoia failed \n");
1195 serial
= mos7840_get_usb_serial(port
, __FUNCTION__
);
1197 dbg("%s", "Serial Paranoia failed \n");
1201 mos7840_port
= mos7840_get_port_private(port
);
1203 if (mos7840_port
== NULL
) {
1207 for (j
= 0; j
< NUM_URBS
; ++j
)
1208 usb_kill_urb(mos7840_port
->write_urb_pool
[j
]);
1210 /* Freeing Write URBs */
1211 for (j
= 0; j
< NUM_URBS
; ++j
) {
1212 if (mos7840_port
->write_urb_pool
[j
]) {
1213 if (mos7840_port
->write_urb_pool
[j
]->transfer_buffer
)
1214 kfree(mos7840_port
->write_urb_pool
[j
]->
1217 usb_free_urb(mos7840_port
->write_urb_pool
[j
]);
1222 /* flush and block until tx is empty */
1223 mos7840_block_until_tx_empty(mos7840_port
);
1226 /* While closing port, shutdown all bulk read, write *
1227 * and interrupt read if they exists */
1230 if (mos7840_port
->write_urb
) {
1231 dbg("%s", "Shutdown bulk write\n");
1232 usb_kill_urb(mos7840_port
->write_urb
);
1235 if (mos7840_port
->read_urb
) {
1236 dbg("%s", "Shutdown bulk read\n");
1237 usb_kill_urb(mos7840_port
->read_urb
);
1239 if ((&mos7840_port
->control_urb
)) {
1240 dbg("%s", "Shutdown control read\n");
1241 // usb_kill_urb (mos7840_port->control_urb);
1245 // if(mos7840_port->ctrl_buf != NULL)
1246 // kfree(mos7840_port->ctrl_buf);
1247 mos7840_num_open_ports
--;
1248 dbg("mos7840_num_open_ports in close%d:in port%d\n",
1249 mos7840_num_open_ports
, port
->number
);
1250 if (mos7840_num_open_ports
== 0) {
1251 if (serial
->port
[0]->interrupt_in_urb
) {
1252 dbg("%s", "Shutdown interrupt_in_urb\n");
1256 if (mos7840_port
->write_urb
) {
1257 /* if this urb had a transfer buffer already (old tx) free it */
1259 if (mos7840_port
->write_urb
->transfer_buffer
!= NULL
) {
1260 kfree(mos7840_port
->write_urb
->transfer_buffer
);
1262 usb_free_urb(mos7840_port
->write_urb
);
1266 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
1269 mos7840_set_uart_reg(port
, INTERRUPT_ENABLE_REGISTER
, Data
);
1271 mos7840_port
->open
= 0;
1273 dbg("%s \n", "Leaving ............");
1276 /************************************************************************
1278 * mos7840_block_until_chase_response
1280 * This function will block the close until one of the following:
1281 * 1. Response to our Chase comes from mos7840
1282 * 2. A timout of 10 seconds without activity has expired
1283 * (1K of mos7840 data @ 2400 baud ==> 4 sec to empty)
1285 ************************************************************************/
1287 static void mos7840_block_until_chase_response(struct moschip_port
1290 int timeout
= 1 * HZ
;
1295 count
= mos7840_chars_in_buffer(mos7840_port
->port
);
1297 /* Check for Buffer status */
1302 /* Block the thread for a while */
1303 interruptible_sleep_on_timeout(&mos7840_port
->wait_chase
,
1305 /* No activity.. count down section */
1308 dbg("%s - TIMEOUT", __FUNCTION__
);
1311 /* Reset timout value back to seconds */
1318 /*****************************************************************************
1320 * this function sends a break to the port
1321 *****************************************************************************/
1322 static void mos7840_break(struct usb_serial_port
*port
, int break_state
)
1325 struct usb_serial
*serial
;
1326 struct moschip_port
*mos7840_port
;
1328 dbg("%s \n", "Entering ...........");
1329 dbg("mos7840_break: Start\n");
1331 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1332 dbg("%s", "Port Paranoia failed \n");
1336 serial
= mos7840_get_usb_serial(port
, __FUNCTION__
);
1338 dbg("%s", "Serial Paranoia failed \n");
1342 mos7840_port
= mos7840_get_port_private(port
);
1344 if (mos7840_port
== NULL
) {
1350 /* flush and block until tx is empty */
1351 mos7840_block_until_chase_response(mos7840_port
);
1354 if (break_state
== -1) {
1355 data
= mos7840_port
->shadowLCR
| LCR_SET_BREAK
;
1357 data
= mos7840_port
->shadowLCR
& ~LCR_SET_BREAK
;
1360 mos7840_port
->shadowLCR
= data
;
1361 dbg("mcs7840_break mos7840_port->shadowLCR is %x\n",
1362 mos7840_port
->shadowLCR
);
1363 mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
,
1364 mos7840_port
->shadowLCR
);
1369 /*****************************************************************************
1370 * mos7840_write_room
1371 * this function is called by the tty driver when it wants to know how many
1372 * bytes of data we can accept for a specific port.
1373 * If successful, we return the amount of room that we have for this port
1374 * Otherwise we return a negative error number.
1375 *****************************************************************************/
1377 static int mos7840_write_room(struct usb_serial_port
*port
)
1381 struct moschip_port
*mos7840_port
;
1383 dbg("%s \n", " mos7840_write_room:entering ...........");
1385 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1386 dbg("%s", "Invalid port \n");
1387 dbg("%s \n", " mos7840_write_room:leaving ...........");
1391 mos7840_port
= mos7840_get_port_private(port
);
1392 if (mos7840_port
== NULL
) {
1393 dbg("%s \n", "mos7840_break:leaving ...........");
1397 for (i
= 0; i
< NUM_URBS
; ++i
) {
1398 if (mos7840_port
->write_urb_pool
[i
]->status
!= -EINPROGRESS
) {
1399 room
+= URB_TRANSFER_BUFFER_SIZE
;
1403 dbg("%s - returns %d", __FUNCTION__
, room
);
1408 /*****************************************************************************
1410 * this function is called by the tty driver when data should be written to
1412 * If successful, we return the number of bytes written, otherwise we
1413 * return a negative error number.
1414 *****************************************************************************/
1416 static int mos7840_write(struct usb_serial_port
*port
,
1417 const unsigned char *data
, int count
)
1424 struct moschip_port
*mos7840_port
;
1425 struct usb_serial
*serial
;
1428 const unsigned char *current_position
= data
;
1429 unsigned char *data1
;
1430 dbg("%s \n", "entering ...........");
1431 //dbg("mos7840_write: mos7840_port->shadowLCR is %x\n",mos7840_port->shadowLCR);
1436 status
= mos7840_get_uart_reg(port
, LINE_CONTROL_REGISTER
, &Data
);
1437 mos7840_port
->shadowLCR
= Data
;
1438 dbg("mos7840_write: LINE_CONTROL_REGISTER is %x\n", Data
);
1439 dbg("mos7840_write: mos7840_port->shadowLCR is %x\n",
1440 mos7840_port
->shadowLCR
);
1443 //status = mos7840_set_uart_reg(port,LINE_CONTROL_REGISTER,Data);
1444 //mos7840_port->shadowLCR=Data;//Need to add later
1446 Data
|= SERIAL_LCR_DLAB
; //data latch enable in LCR 0x80
1448 status
= mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
1451 //status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data);
1454 status
= mos7840_get_uart_reg(port
, DIVISOR_LATCH_LSB
, &Data
);
1455 dbg("mos7840_write:DLL value is %x\n", Data
);
1459 status
= mos7840_get_uart_reg(port
, DIVISOR_LATCH_MSB
, &Data
);
1460 dbg("mos7840_write:DLM value is %x\n", Data
);
1462 Data
= Data
& ~SERIAL_LCR_DLAB
;
1463 dbg("mos7840_write: mos7840_port->shadowLCR is %x\n",
1464 mos7840_port
->shadowLCR
);
1466 status
= mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
1469 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1470 dbg("%s", "Port Paranoia failed \n");
1474 serial
= port
->serial
;
1475 if (mos7840_serial_paranoia_check(serial
, __FUNCTION__
)) {
1476 dbg("%s", "Serial Paranoia failed \n");
1480 mos7840_port
= mos7840_get_port_private(port
);
1481 if (mos7840_port
== NULL
) {
1482 dbg("%s", "mos7840_port is NULL\n");
1486 /* try to find a free urb in the list */
1489 for (i
= 0; i
< NUM_URBS
; ++i
) {
1490 if (mos7840_port
->write_urb_pool
[i
]->status
!= -EINPROGRESS
) {
1491 urb
= mos7840_port
->write_urb_pool
[i
];
1498 dbg("%s - no more free urbs", __FUNCTION__
);
1502 if (urb
->transfer_buffer
== NULL
) {
1503 urb
->transfer_buffer
=
1504 kmalloc(URB_TRANSFER_BUFFER_SIZE
, GFP_KERNEL
);
1506 if (urb
->transfer_buffer
== NULL
) {
1507 err("%s no more kernel memory...", __FUNCTION__
);
1511 transfer_size
= min(count
, URB_TRANSFER_BUFFER_SIZE
);
1513 memcpy(urb
->transfer_buffer
, current_position
, transfer_size
);
1515 /* fill urb with data and submit */
1516 usb_fill_bulk_urb(urb
,
1518 usb_sndbulkpipe(serial
->dev
,
1519 port
->bulk_out_endpointAddress
),
1520 urb
->transfer_buffer
,
1522 mos7840_bulk_out_data_callback
, mos7840_port
);
1524 data1
= urb
->transfer_buffer
;
1525 dbg("\nbulkout endpoint is %d", port
->bulk_out_endpointAddress
);
1527 /* send it down the pipe */
1528 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
1531 err("%s - usb_submit_urb(write bulk) failed with status = %d",
1532 __FUNCTION__
, status
);
1533 bytes_sent
= status
;
1536 bytes_sent
= transfer_size
;
1537 mos7840_port
->icount
.tx
+= transfer_size
;
1538 dbg("mos7840_port->icount.tx is %d:\n", mos7840_port
->icount
.tx
);
1545 /*****************************************************************************
1547 * this function is called by the tty driver when it wants to stop the data
1548 * being read from the port.
1549 *****************************************************************************/
1551 static void mos7840_throttle(struct usb_serial_port
*port
)
1553 struct moschip_port
*mos7840_port
;
1554 struct tty_struct
*tty
;
1557 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1558 dbg("%s", "Invalid port \n");
1562 dbg("- port %d\n", port
->number
);
1564 mos7840_port
= mos7840_get_port_private(port
);
1566 if (mos7840_port
== NULL
)
1569 if (!mos7840_port
->open
) {
1570 dbg("%s\n", "port not opened");
1574 dbg("%s", "Entering .......... \n");
1578 dbg("%s - no tty available", __FUNCTION__
);
1582 /* if we are implementing XON/XOFF, send the stop character */
1584 unsigned char stop_char
= STOP_CHAR(tty
);
1585 status
= mos7840_write(port
, &stop_char
, 1);
1591 /* if we are implementing RTS/CTS, toggle that line */
1592 if (tty
->termios
->c_cflag
& CRTSCTS
) {
1593 mos7840_port
->shadowMCR
&= ~MCR_RTS
;
1596 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
,
1597 mos7840_port
->shadowMCR
);
1607 /*****************************************************************************
1608 * mos7840_unthrottle
1609 * this function is called by the tty driver when it wants to resume the data
1610 * being read from the port (called after SerialThrottle is called)
1611 *****************************************************************************/
1612 static void mos7840_unthrottle(struct usb_serial_port
*port
)
1614 struct tty_struct
*tty
;
1616 struct moschip_port
*mos7840_port
= mos7840_get_port_private(port
);
1618 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1619 dbg("%s", "Invalid port \n");
1623 if (mos7840_port
== NULL
)
1626 if (!mos7840_port
->open
) {
1627 dbg("%s - port not opened", __FUNCTION__
);
1631 dbg("%s", "Entering .......... \n");
1635 dbg("%s - no tty available", __FUNCTION__
);
1639 /* if we are implementing XON/XOFF, send the start character */
1641 unsigned char start_char
= START_CHAR(tty
);
1642 status
= mos7840_write(port
, &start_char
, 1);
1648 /* if we are implementing RTS/CTS, toggle that line */
1649 if (tty
->termios
->c_cflag
& CRTSCTS
) {
1650 mos7840_port
->shadowMCR
|= MCR_RTS
;
1653 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
,
1654 mos7840_port
->shadowMCR
);
1663 static int mos7840_tiocmget(struct usb_serial_port
*port
, struct file
*file
)
1665 struct moschip_port
*mos7840_port
;
1666 unsigned int result
;
1670 mos7840_port
= mos7840_get_port_private(port
);
1672 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1674 if (mos7840_port
== NULL
)
1677 status
= mos7840_get_uart_reg(port
, MODEM_STATUS_REGISTER
, &msr
);
1678 status
= mos7840_get_uart_reg(port
, MODEM_CONTROL_REGISTER
, &mcr
);
1679 result
= ((mcr
& MCR_DTR
) ? TIOCM_DTR
: 0)
1680 | ((mcr
& MCR_RTS
) ? TIOCM_RTS
: 0)
1681 | ((mcr
& MCR_LOOPBACK
) ? TIOCM_LOOP
: 0)
1682 | ((msr
& MOS7840_MSR_CTS
) ? TIOCM_CTS
: 0)
1683 | ((msr
& MOS7840_MSR_CD
) ? TIOCM_CAR
: 0)
1684 | ((msr
& MOS7840_MSR_RI
) ? TIOCM_RI
: 0)
1685 | ((msr
& MOS7840_MSR_DSR
) ? TIOCM_DSR
: 0);
1687 dbg("%s - 0x%04X", __FUNCTION__
, result
);
1692 static int mos7840_tiocmset(struct usb_serial_port
*port
, struct file
*file
,
1693 unsigned int set
, unsigned int clear
)
1695 struct moschip_port
*mos7840_port
;
1697 unsigned int status
;
1699 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1701 mos7840_port
= mos7840_get_port_private(port
);
1703 if (mos7840_port
== NULL
)
1706 mcr
= mos7840_port
->shadowMCR
;
1707 if (clear
& TIOCM_RTS
)
1709 if (clear
& TIOCM_DTR
)
1711 if (clear
& TIOCM_LOOP
)
1712 mcr
&= ~MCR_LOOPBACK
;
1714 if (set
& TIOCM_RTS
)
1716 if (set
& TIOCM_DTR
)
1718 if (set
& TIOCM_LOOP
)
1719 mcr
|= MCR_LOOPBACK
;
1721 mos7840_port
->shadowMCR
= mcr
;
1724 status
= mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, mcr
);
1726 dbg("setting MODEM_CONTROL_REGISTER Failed\n");
1733 /*****************************************************************************
1734 * mos7840_calc_baud_rate_divisor
1735 * this function calculates the proper baud rate divisor for the specified
1737 *****************************************************************************/
1738 static int mos7840_calc_baud_rate_divisor(int baudRate
, int *divisor
,
1739 __u16
* clk_sel_val
)
1742 dbg("%s - %d", __FUNCTION__
, baudRate
);
1744 if (baudRate
<= 115200) {
1745 *divisor
= 115200 / baudRate
;
1748 if ((baudRate
> 115200) && (baudRate
<= 230400)) {
1749 *divisor
= 230400 / baudRate
;
1750 *clk_sel_val
= 0x10;
1751 } else if ((baudRate
> 230400) && (baudRate
<= 403200)) {
1752 *divisor
= 403200 / baudRate
;
1753 *clk_sel_val
= 0x20;
1754 } else if ((baudRate
> 403200) && (baudRate
<= 460800)) {
1755 *divisor
= 460800 / baudRate
;
1756 *clk_sel_val
= 0x30;
1757 } else if ((baudRate
> 460800) && (baudRate
<= 806400)) {
1758 *divisor
= 806400 / baudRate
;
1759 *clk_sel_val
= 0x40;
1760 } else if ((baudRate
> 806400) && (baudRate
<= 921600)) {
1761 *divisor
= 921600 / baudRate
;
1762 *clk_sel_val
= 0x50;
1763 } else if ((baudRate
> 921600) && (baudRate
<= 1572864)) {
1764 *divisor
= 1572864 / baudRate
;
1765 *clk_sel_val
= 0x60;
1766 } else if ((baudRate
> 1572864) && (baudRate
<= 3145728)) {
1767 *divisor
= 3145728 / baudRate
;
1768 *clk_sel_val
= 0x70;
1774 for (i
= 0; i
< ARRAY_SIZE(mos7840_divisor_table
); i
++) {
1775 if (mos7840_divisor_table
[i
].BaudRate
== baudrate
) {
1776 *divisor
= mos7840_divisor_table
[i
].Divisor
;
1781 /* After trying for all the standard baud rates *
1782 * Try calculating the divisor for this baud rate */
1784 if (baudrate
> 75 && baudrate
< 230400) {
1785 /* get the divisor */
1786 custom
= (__u16
) (230400L / baudrate
);
1788 /* Check for round off */
1789 round1
= (__u16
) (2304000L / baudrate
);
1790 round
= (__u16
) (round1
- (custom
* 10));
1796 dbg(" Baud %d = %d\n", baudrate
, custom
);
1800 dbg("%s\n", " Baud calculation Failed...");
1805 /*****************************************************************************
1806 * mos7840_send_cmd_write_baud_rate
1807 * this function sends the proper command to change the baud rate of the
1809 *****************************************************************************/
1811 static int mos7840_send_cmd_write_baud_rate(struct moschip_port
*mos7840_port
,
1817 unsigned char number
;
1819 struct usb_serial_port
*port
;
1821 if (mos7840_port
== NULL
)
1824 port
= (struct usb_serial_port
*)mos7840_port
->port
;
1825 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1826 dbg("%s", "Invalid port \n");
1830 if (mos7840_serial_paranoia_check(port
->serial
, __FUNCTION__
)) {
1831 dbg("%s", "Invalid Serial \n");
1835 dbg("%s", "Entering .......... \n");
1837 number
= mos7840_port
->port
->number
- mos7840_port
->port
->serial
->minor
;
1839 dbg("%s - port = %d, baud = %d", __FUNCTION__
,
1840 mos7840_port
->port
->number
, baudRate
);
1841 //reset clk_uart_sel in spregOffset
1842 if (baudRate
> 115200) {
1843 #ifdef HW_flow_control
1844 //NOTE: need to see the pther register to modify
1845 //setting h/w flow control bit to 1;
1848 mos7840_port
->shadowMCR
= Data
;
1850 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
1852 dbg("Writing spreg failed in set_serial_baud\n");
1858 #ifdef HW_flow_control
1859 //setting h/w flow control bit to 0;
1862 mos7840_port
->shadowMCR
= Data
;
1864 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
1866 dbg("Writing spreg failed in set_serial_baud\n");
1873 if (1) //baudRate <= 115200)
1879 mos7840_calc_baud_rate_divisor(baudRate
, &divisor
,
1882 mos7840_get_reg_sync(port
, mos7840_port
->SpRegOffset
,
1885 dbg("reading spreg failed in set_serial_baud\n");
1888 Data
= (Data
& 0x8f) | clk_sel_val
;
1891 mos7840_set_reg_sync(port
, mos7840_port
->SpRegOffset
, Data
);
1893 dbg("Writing spreg failed in set_serial_baud\n");
1896 /* Calculate the Divisor */
1899 err("%s - bad baud rate", __FUNCTION__
);
1900 dbg("%s\n", "bad baud rate");
1903 /* Enable access to divisor latch */
1904 Data
= mos7840_port
->shadowLCR
| SERIAL_LCR_DLAB
;
1905 mos7840_port
->shadowLCR
= Data
;
1906 mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
1908 /* Write the divisor */
1909 Data
= (unsigned char)(divisor
& 0xff);
1910 dbg("set_serial_baud Value to write DLL is %x\n", Data
);
1911 mos7840_set_uart_reg(port
, DIVISOR_LATCH_LSB
, Data
);
1913 Data
= (unsigned char)((divisor
& 0xff00) >> 8);
1914 dbg("set_serial_baud Value to write DLM is %x\n", Data
);
1915 mos7840_set_uart_reg(port
, DIVISOR_LATCH_MSB
, Data
);
1917 /* Disable access to divisor latch */
1918 Data
= mos7840_port
->shadowLCR
& ~SERIAL_LCR_DLAB
;
1919 mos7840_port
->shadowLCR
= Data
;
1920 mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
1927 /*****************************************************************************
1928 * mos7840_change_port_settings
1929 * This routine is called to set the UART on the device to match
1930 * the specified new settings.
1931 *****************************************************************************/
1933 static void mos7840_change_port_settings(struct moschip_port
*mos7840_port
,
1934 struct termios
*old_termios
)
1936 struct tty_struct
*tty
;
1945 struct usb_serial_port
*port
;
1946 struct usb_serial
*serial
;
1948 if (mos7840_port
== NULL
)
1951 port
= (struct usb_serial_port
*)mos7840_port
->port
;
1953 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
1954 dbg("%s", "Invalid port \n");
1958 if (mos7840_serial_paranoia_check(port
->serial
, __FUNCTION__
)) {
1959 dbg("%s", "Invalid Serial \n");
1963 serial
= port
->serial
;
1965 dbg("%s - port %d", __FUNCTION__
, mos7840_port
->port
->number
);
1967 if (!mos7840_port
->open
) {
1968 dbg("%s - port not opened", __FUNCTION__
);
1972 tty
= mos7840_port
->port
->tty
;
1974 if ((!tty
) || (!tty
->termios
)) {
1975 dbg("%s - no tty structures", __FUNCTION__
);
1979 dbg("%s", "Entering .......... \n");
1983 lParity
= LCR_PAR_NONE
;
1985 cflag
= tty
->termios
->c_cflag
;
1986 iflag
= tty
->termios
->c_iflag
;
1988 /* Change the number of bits */
1989 if (cflag
& CSIZE
) {
1990 switch (cflag
& CSIZE
) {
2008 /* Change the Parity bit */
2009 if (cflag
& PARENB
) {
2010 if (cflag
& PARODD
) {
2011 lParity
= LCR_PAR_ODD
;
2012 dbg("%s - parity = odd", __FUNCTION__
);
2014 lParity
= LCR_PAR_EVEN
;
2015 dbg("%s - parity = even", __FUNCTION__
);
2019 dbg("%s - parity = none", __FUNCTION__
);
2022 if (cflag
& CMSPAR
) {
2023 lParity
= lParity
| 0x20;
2026 /* Change the Stop bit */
2027 if (cflag
& CSTOPB
) {
2029 dbg("%s - stop bits = 2", __FUNCTION__
);
2032 dbg("%s - stop bits = 1", __FUNCTION__
);
2035 /* Update the LCR with the correct value */
2036 mos7840_port
->shadowLCR
&=
2037 ~(LCR_BITS_MASK
| LCR_STOP_MASK
| LCR_PAR_MASK
);
2038 mos7840_port
->shadowLCR
|= (lData
| lParity
| lStop
);
2040 dbg("mos7840_change_port_settings mos7840_port->shadowLCR is %x\n",
2041 mos7840_port
->shadowLCR
);
2042 /* Disable Interrupts */
2044 mos7840_set_uart_reg(port
, INTERRUPT_ENABLE_REGISTER
, Data
);
2047 mos7840_set_uart_reg(port
, FIFO_CONTROL_REGISTER
, Data
);
2050 mos7840_set_uart_reg(port
, FIFO_CONTROL_REGISTER
, Data
);
2052 /* Send the updated LCR value to the mos7840 */
2053 Data
= mos7840_port
->shadowLCR
;
2055 mos7840_set_uart_reg(port
, LINE_CONTROL_REGISTER
, Data
);
2058 mos7840_port
->shadowMCR
= Data
;
2059 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
2061 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
2063 /* set up the MCR register and send it to the mos7840 */
2065 mos7840_port
->shadowMCR
= MCR_MASTER_IE
;
2066 if (cflag
& CBAUD
) {
2067 mos7840_port
->shadowMCR
|= (MCR_DTR
| MCR_RTS
);
2070 if (cflag
& CRTSCTS
) {
2071 mos7840_port
->shadowMCR
|= (MCR_XON_ANY
);
2074 mos7840_port
->shadowMCR
&= ~(MCR_XON_ANY
);
2077 Data
= mos7840_port
->shadowMCR
;
2078 mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
2080 /* Determine divisor based on baud rate */
2081 baud
= tty_get_baud_rate(tty
);
2084 /* pick a default, any default... */
2085 dbg("%s\n", "Picked default baud...");
2089 dbg("%s - baud rate = %d", __FUNCTION__
, baud
);
2090 status
= mos7840_send_cmd_write_baud_rate(mos7840_port
, baud
);
2092 /* Enable Interrupts */
2094 mos7840_set_uart_reg(port
, INTERRUPT_ENABLE_REGISTER
, Data
);
2096 if (mos7840_port
->read_urb
->status
!= -EINPROGRESS
) {
2097 mos7840_port
->read_urb
->dev
= serial
->dev
;
2099 status
= usb_submit_urb(mos7840_port
->read_urb
, GFP_ATOMIC
);
2102 dbg(" usb_submit_urb(read bulk) failed, status = %d",
2106 wake_up(&mos7840_port
->delta_msr_wait
);
2107 mos7840_port
->delta_msr_cond
= 1;
2108 dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x\n",
2109 mos7840_port
->shadowLCR
);
2114 /*****************************************************************************
2115 * mos7840_set_termios
2116 * this function is called by the tty driver when it wants to change
2117 * the termios structure
2118 *****************************************************************************/
2120 static void mos7840_set_termios(struct usb_serial_port
*port
,
2121 struct termios
*old_termios
)
2125 struct usb_serial
*serial
;
2126 struct moschip_port
*mos7840_port
;
2127 struct tty_struct
*tty
;
2128 dbg("mos7840_set_termios: START\n");
2129 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
2130 dbg("%s", "Invalid port \n");
2134 serial
= port
->serial
;
2136 if (mos7840_serial_paranoia_check(serial
, __FUNCTION__
)) {
2137 dbg("%s", "Invalid Serial \n");
2141 mos7840_port
= mos7840_get_port_private(port
);
2143 if (mos7840_port
== NULL
)
2148 if (!port
->tty
|| !port
->tty
->termios
) {
2149 dbg("%s - no tty or termios", __FUNCTION__
);
2153 if (!mos7840_port
->open
) {
2154 dbg("%s - port not opened", __FUNCTION__
);
2158 dbg("%s\n", "setting termios - ");
2160 cflag
= tty
->termios
->c_cflag
;
2163 dbg("%s %s\n", __FUNCTION__
, "cflag is NULL");
2167 /* check that they really want us to change something */
2169 if ((cflag
== old_termios
->c_cflag
) &&
2170 (RELEVANT_IFLAG(tty
->termios
->c_iflag
) ==
2171 RELEVANT_IFLAG(old_termios
->c_iflag
))) {
2172 dbg("%s\n", "Nothing to change");
2177 dbg("%s - clfag %08x iflag %08x", __FUNCTION__
,
2178 tty
->termios
->c_cflag
, RELEVANT_IFLAG(tty
->termios
->c_iflag
));
2181 dbg("%s - old clfag %08x old iflag %08x", __FUNCTION__
,
2182 old_termios
->c_cflag
, RELEVANT_IFLAG(old_termios
->c_iflag
));
2185 dbg("%s - port %d", __FUNCTION__
, port
->number
);
2187 /* change the port settings to the new ones specified */
2189 mos7840_change_port_settings(mos7840_port
, old_termios
);
2191 if (!mos7840_port
->read_urb
) {
2192 dbg("%s", "URB KILLED !!!!!\n");
2196 if (mos7840_port
->read_urb
->status
!= -EINPROGRESS
) {
2197 mos7840_port
->read_urb
->dev
= serial
->dev
;
2198 status
= usb_submit_urb(mos7840_port
->read_urb
, GFP_ATOMIC
);
2200 dbg(" usb_submit_urb(read bulk) failed, status = %d",
2207 /*****************************************************************************
2208 * mos7840_get_lsr_info - get line status register info
2210 * Purpose: Let user call ioctl() to get info when the UART physically
2211 * is emptied. On bus types like RS485, the transmitter must
2212 * release the bus after transmitting. This must be done when
2213 * the transmit shift register is empty, not be done when the
2214 * transmit holding register is empty. This functionality
2215 * allows an RS485 driver to be written in user space.
2216 *****************************************************************************/
2218 static int mos7840_get_lsr_info(struct moschip_port
*mos7840_port
,
2219 unsigned int __user
*value
)
2222 unsigned int result
= 0;
2224 count
= mos7840_chars_in_buffer(mos7840_port
->port
);
2226 dbg("%s -- Empty", __FUNCTION__
);
2227 result
= TIOCSER_TEMT
;
2230 if (copy_to_user(value
, &result
, sizeof(int)))
2235 /*****************************************************************************
2236 * mos7840_get_bytes_avail - get number of bytes available
2238 * Purpose: Let user call ioctl to get the count of number of bytes available.
2239 *****************************************************************************/
2241 static int mos7840_get_bytes_avail(struct moschip_port
*mos7840_port
,
2242 unsigned int __user
*value
)
2244 unsigned int result
= 0;
2245 struct tty_struct
*tty
= mos7840_port
->port
->tty
;
2248 return -ENOIOCTLCMD
;
2250 result
= tty
->read_cnt
;
2252 dbg("%s(%d) = %d", __FUNCTION__
, mos7840_port
->port
->number
, result
);
2253 if (copy_to_user(value
, &result
, sizeof(int)))
2256 return -ENOIOCTLCMD
;
2259 /*****************************************************************************
2260 * mos7840_set_modem_info
2261 * function to set modem info
2262 *****************************************************************************/
2264 static int mos7840_set_modem_info(struct moschip_port
*mos7840_port
,
2265 unsigned int cmd
, unsigned int __user
*value
)
2271 struct usb_serial_port
*port
;
2273 if (mos7840_port
== NULL
)
2276 port
= (struct usb_serial_port
*)mos7840_port
->port
;
2277 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
2278 dbg("%s", "Invalid port \n");
2282 mcr
= mos7840_port
->shadowMCR
;
2284 if (copy_from_user(&arg
, value
, sizeof(int)))
2289 if (arg
& TIOCM_RTS
)
2291 if (arg
& TIOCM_DTR
)
2293 if (arg
& TIOCM_LOOP
)
2294 mcr
|= MCR_LOOPBACK
;
2298 if (arg
& TIOCM_RTS
)
2300 if (arg
& TIOCM_DTR
)
2302 if (arg
& TIOCM_LOOP
)
2303 mcr
&= ~MCR_LOOPBACK
;
2307 /* turn off the RTS and DTR and LOOPBACK
2308 * and then only turn on what was asked to */
2309 mcr
&= ~(MCR_RTS
| MCR_DTR
| MCR_LOOPBACK
);
2310 mcr
|= ((arg
& TIOCM_RTS
) ? MCR_RTS
: 0);
2311 mcr
|= ((arg
& TIOCM_DTR
) ? MCR_DTR
: 0);
2312 mcr
|= ((arg
& TIOCM_LOOP
) ? MCR_LOOPBACK
: 0);
2316 mos7840_port
->shadowMCR
= mcr
;
2318 Data
= mos7840_port
->shadowMCR
;
2320 status
= mos7840_set_uart_reg(port
, MODEM_CONTROL_REGISTER
, Data
);
2322 dbg("setting MODEM_CONTROL_REGISTER Failed\n");
2329 /*****************************************************************************
2330 * mos7840_get_modem_info
2331 * function to get modem info
2332 *****************************************************************************/
2334 static int mos7840_get_modem_info(struct moschip_port
*mos7840_port
,
2335 unsigned int __user
*value
)
2337 unsigned int result
= 0;
2339 unsigned int mcr
= mos7840_port
->shadowMCR
;
2342 mos7840_get_uart_reg(mos7840_port
->port
, MODEM_STATUS_REGISTER
,
2344 result
= ((mcr
& MCR_DTR
) ? TIOCM_DTR
: 0) /* 0x002 */
2345 |((mcr
& MCR_RTS
) ? TIOCM_RTS
: 0) /* 0x004 */
2346 |((msr
& MOS7840_MSR_CTS
) ? TIOCM_CTS
: 0) /* 0x020 */
2347 |((msr
& MOS7840_MSR_CD
) ? TIOCM_CAR
: 0) /* 0x040 */
2348 |((msr
& MOS7840_MSR_RI
) ? TIOCM_RI
: 0) /* 0x080 */
2349 |((msr
& MOS7840_MSR_DSR
) ? TIOCM_DSR
: 0); /* 0x100 */
2351 dbg("%s -- %x", __FUNCTION__
, result
);
2353 if (copy_to_user(value
, &result
, sizeof(int)))
2358 /*****************************************************************************
2359 * mos7840_get_serial_info
2360 * function to get information about serial port
2361 *****************************************************************************/
2363 static int mos7840_get_serial_info(struct moschip_port
*mos7840_port
,
2364 struct serial_struct __user
*retinfo
)
2366 struct serial_struct tmp
;
2368 if (mos7840_port
== NULL
)
2374 memset(&tmp
, 0, sizeof(tmp
));
2376 tmp
.type
= PORT_16550A
;
2377 tmp
.line
= mos7840_port
->port
->serial
->minor
;
2378 tmp
.port
= mos7840_port
->port
->number
;
2380 tmp
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
2381 tmp
.xmit_fifo_size
= NUM_URBS
* URB_TRANSFER_BUFFER_SIZE
;
2382 tmp
.baud_base
= 9600;
2383 tmp
.close_delay
= 5 * HZ
;
2384 tmp
.closing_wait
= 30 * HZ
;
2386 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
2391 /*****************************************************************************
2393 * this function handles any ioctl calls to the driver
2394 *****************************************************************************/
2396 static int mos7840_ioctl(struct usb_serial_port
*port
, struct file
*file
,
2397 unsigned int cmd
, unsigned long arg
)
2399 void __user
*argp
= (void __user
*)arg
;
2400 struct moschip_port
*mos7840_port
;
2401 struct tty_struct
*tty
;
2403 struct async_icount cnow
;
2404 struct async_icount cprev
;
2405 struct serial_icounter_struct icount
;
2408 struct tty_ldisc
*ld
;
2410 if (mos7840_port_paranoia_check(port
, __FUNCTION__
)) {
2411 dbg("%s", "Invalid port \n");
2415 mos7840_port
= mos7840_get_port_private(port
);
2417 if (mos7840_port
== NULL
)
2420 tty
= mos7840_port
->port
->tty
;
2422 dbg("%s - port %d, cmd = 0x%x", __FUNCTION__
, port
->number
, cmd
);
2425 /* return number of bytes available */
2428 dbg("%s (%d) TIOCINQ", __FUNCTION__
, port
->number
);
2429 return mos7840_get_bytes_avail(mos7840_port
, argp
);
2432 dbg("%s (%d) TIOCOUTQ", __FUNCTION__
, port
->number
);
2433 return put_user(tty
->driver
->chars_in_buffer
?
2434 tty
->driver
->chars_in_buffer(tty
) : 0,
2438 retval
= tty_check_change(tty
);
2442 ld
= tty_ldisc_ref(tty
);
2445 if (ld
&& ld
->flush_buffer
)
2446 ld
->flush_buffer(tty
);
2449 if (ld
&& ld
->flush_buffer
)
2450 ld
->flush_buffer(tty
);
2453 if (tty
->driver
->flush_buffer
)
2454 tty
->driver
->flush_buffer(tty
);
2457 tty_ldisc_deref(ld
);
2460 tty_ldisc_deref(ld
);
2464 if (kernel_termios_to_user_termios
2465 ((struct termios __user
*)argp
, tty
->termios
))
2470 dbg("%s (%d) TIOCSERGETLSR", __FUNCTION__
, port
->number
);
2471 return mos7840_get_lsr_info(mos7840_port
, argp
);
2477 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __FUNCTION__
,
2480 mos7840_set_modem_info(mos7840_port
, cmd
, argp
);
2484 dbg("%s (%d) TIOCMGET", __FUNCTION__
, port
->number
);
2485 return mos7840_get_modem_info(mos7840_port
, argp
);
2488 dbg("%s (%d) TIOCGSERIAL", __FUNCTION__
, port
->number
);
2489 return mos7840_get_serial_info(mos7840_port
, argp
);
2492 dbg("%s (%d) TIOCSSERIAL", __FUNCTION__
, port
->number
);
2496 dbg("%s (%d) TIOCMIWAIT", __FUNCTION__
, port
->number
);
2497 cprev
= mos7840_port
->icount
;
2499 //interruptible_sleep_on(&mos7840_port->delta_msr_wait);
2500 mos7840_port
->delta_msr_cond
= 0;
2501 wait_event_interruptible(mos7840_port
->delta_msr_wait
,
2503 delta_msr_cond
== 1));
2505 /* see if a signal did it */
2506 if (signal_pending(current
))
2507 return -ERESTARTSYS
;
2508 cnow
= mos7840_port
->icount
;
2509 if (cnow
.rng
== cprev
.rng
&& cnow
.dsr
== cprev
.dsr
&&
2510 cnow
.dcd
== cprev
.dcd
&& cnow
.cts
== cprev
.cts
)
2511 return -EIO
; /* no change => error */
2512 if (((arg
& TIOCM_RNG
) && (cnow
.rng
!= cprev
.rng
)) ||
2513 ((arg
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
.dsr
)) ||
2514 ((arg
& TIOCM_CD
) && (cnow
.dcd
!= cprev
.dcd
)) ||
2515 ((arg
& TIOCM_CTS
) && (cnow
.cts
!= cprev
.cts
))) {
2524 cnow
= mos7840_port
->icount
;
2525 icount
.cts
= cnow
.cts
;
2526 icount
.dsr
= cnow
.dsr
;
2527 icount
.rng
= cnow
.rng
;
2528 icount
.dcd
= cnow
.dcd
;
2529 icount
.rx
= cnow
.rx
;
2530 icount
.tx
= cnow
.tx
;
2531 icount
.frame
= cnow
.frame
;
2532 icount
.overrun
= cnow
.overrun
;
2533 icount
.parity
= cnow
.parity
;
2534 icount
.brk
= cnow
.brk
;
2535 icount
.buf_overrun
= cnow
.buf_overrun
;
2537 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __FUNCTION__
,
2538 port
->number
, icount
.rx
, icount
.tx
);
2539 if (copy_to_user(argp
, &icount
, sizeof(icount
)))
2549 return -ENOIOCTLCMD
;
2552 static int mos7840_calc_num_ports(struct usb_serial
*serial
)
2555 dbg("numberofendpoints: %d \n",
2556 (int)serial
->interface
->cur_altsetting
->desc
.bNumEndpoints
);
2557 dbg("numberofendpoints: %d \n",
2558 (int)serial
->interface
->altsetting
->desc
.bNumEndpoints
);
2559 if (serial
->interface
->cur_altsetting
->desc
.bNumEndpoints
== 5) {
2560 mos7840_num_ports
= 2;
2561 serial
->type
->num_ports
= 2;
2562 } else if (serial
->interface
->cur_altsetting
->desc
.bNumEndpoints
== 9) {
2563 mos7840_num_ports
= 4;
2564 serial
->type
->num_bulk_in
= 4;
2565 serial
->type
->num_bulk_out
= 4;
2566 serial
->type
->num_ports
= 4;
2569 return mos7840_num_ports
;
2572 /****************************************************************************
2574 ****************************************************************************/
2576 static int mos7840_startup(struct usb_serial
*serial
)
2578 struct moschip_port
*mos7840_port
;
2579 struct usb_device
*dev
;
2583 dbg("%s \n", " mos7840_startup :entering..........");
2586 dbg("%s\n", "Invalid Handler");
2592 dbg("%s\n", "Entering...");
2594 /* we set up the pointers to the endpoints in the mos7840_open *
2595 * function, as the structures aren't created yet. */
2597 /* set up port private structures */
2598 for (i
= 0; i
< serial
->num_ports
; ++i
) {
2599 mos7840_port
= kzalloc(sizeof(struct moschip_port
), GFP_KERNEL
);
2600 if (mos7840_port
== NULL
) {
2601 err("%s - Out of memory", __FUNCTION__
);
2605 /* Initialize all port interrupt end point to port 0 int endpoint *
2606 * Our device has only one interrupt end point comman to all port */
2608 mos7840_port
->port
= serial
->port
[i
];
2609 mos7840_set_port_private(serial
->port
[i
], mos7840_port
);
2611 mos7840_port
->port_num
= ((serial
->port
[i
]->number
-
2612 (serial
->port
[i
]->serial
->minor
)) +
2615 if (mos7840_port
->port_num
== 1) {
2616 mos7840_port
->SpRegOffset
= 0x0;
2617 mos7840_port
->ControlRegOffset
= 0x1;
2618 mos7840_port
->DcrRegOffset
= 0x4;
2619 } else if ((mos7840_port
->port_num
== 2)
2620 && (mos7840_num_ports
== 4)) {
2621 mos7840_port
->SpRegOffset
= 0x8;
2622 mos7840_port
->ControlRegOffset
= 0x9;
2623 mos7840_port
->DcrRegOffset
= 0x16;
2624 } else if ((mos7840_port
->port_num
== 2)
2625 && (mos7840_num_ports
== 2)) {
2626 mos7840_port
->SpRegOffset
= 0xa;
2627 mos7840_port
->ControlRegOffset
= 0xb;
2628 mos7840_port
->DcrRegOffset
= 0x19;
2629 } else if ((mos7840_port
->port_num
== 3)
2630 && (mos7840_num_ports
== 4)) {
2631 mos7840_port
->SpRegOffset
= 0xa;
2632 mos7840_port
->ControlRegOffset
= 0xb;
2633 mos7840_port
->DcrRegOffset
= 0x19;
2634 } else if ((mos7840_port
->port_num
== 4)
2635 && (mos7840_num_ports
== 4)) {
2636 mos7840_port
->SpRegOffset
= 0xc;
2637 mos7840_port
->ControlRegOffset
= 0xd;
2638 mos7840_port
->DcrRegOffset
= 0x1c;
2640 mos7840_dump_serial_port(mos7840_port
);
2642 mos7840_set_port_private(serial
->port
[i
], mos7840_port
);
2644 //enable rx_disable bit in control register
2647 mos7840_get_reg_sync(serial
->port
[i
],
2648 mos7840_port
->ControlRegOffset
, &Data
);
2650 dbg("Reading ControlReg failed status-0x%x\n", status
);
2653 dbg("ControlReg Reading success val is %x, status%d\n",
2655 Data
|= 0x08; //setting driver done bit
2656 Data
|= 0x04; //sp1_bit to have cts change reflect in modem status reg
2658 //Data |= 0x20; //rx_disable bit
2661 mos7840_set_reg_sync(serial
->port
[i
],
2662 mos7840_port
->ControlRegOffset
, Data
);
2664 dbg("Writing ControlReg failed(rx_disable) status-0x%x\n", status
);
2667 dbg("ControlReg Writing success(rx_disable) status%d\n",
2670 //Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2 and 0x24 in DCR3
2674 mos7840_set_reg_sync(serial
->port
[i
],
2675 (__u16
) (mos7840_port
->DcrRegOffset
+
2678 dbg("Writing DCR0 failed status-0x%x\n", status
);
2681 dbg("DCR0 Writing success status%d\n", status
);
2686 mos7840_set_reg_sync(serial
->port
[i
],
2687 (__u16
) (mos7840_port
->DcrRegOffset
+
2690 dbg("Writing DCR1 failed status-0x%x\n", status
);
2693 dbg("DCR1 Writing success status%d\n", status
);
2698 mos7840_set_reg_sync(serial
->port
[i
],
2699 (__u16
) (mos7840_port
->DcrRegOffset
+
2702 dbg("Writing DCR2 failed status-0x%x\n", status
);
2705 dbg("DCR2 Writing success status%d\n", status
);
2707 // write values in clkstart0x0 and clkmulti 0x20
2711 mos7840_set_reg_sync(serial
->port
[i
],
2712 CLK_START_VALUE_REGISTER
, Data
);
2714 dbg("Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status
);
2717 dbg("CLK_START_VALUE_REGISTER Writing success status%d\n", status
);
2722 mos7840_set_reg_sync(serial
->port
[i
], CLK_MULTI_REGISTER
,
2725 dbg("Writing CLK_MULTI_REGISTER failed status-0x%x\n",
2729 dbg("CLK_MULTI_REGISTER Writing success status%d\n",
2732 //write value 0x0 to scratchpad register
2736 mos7840_set_uart_reg(serial
->port
[i
], SCRATCH_PAD_REGISTER
,
2739 dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x\n",
2743 dbg("SCRATCH_PAD_REGISTER Writing success status%d\n",
2746 //Zero Length flag register
2747 if ((mos7840_port
->port_num
!= 1)
2748 && (mos7840_num_ports
== 2)) {
2752 status
= mos7840_set_reg_sync(serial
->port
[i
],
2758 dbg("ZLIP offset%x\n",
2760 ((__u16
) mos7840_port
->port_num
)));
2762 dbg("Writing ZLP_REG%d failed status-0x%x\n",
2766 dbg("ZLP_REG%d Writing success status%d\n",
2771 status
= mos7840_set_reg_sync(serial
->port
[i
],
2777 dbg("ZLIP offset%x\n",
2779 ((__u16
) mos7840_port
->port_num
) - 0x1));
2781 dbg("Writing ZLP_REG%d failed status-0x%x\n",
2785 dbg("ZLP_REG%d Writing success status%d\n",
2789 mos7840_port
->control_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
2790 mos7840_port
->ctrl_buf
= kmalloc(16, GFP_KERNEL
);
2794 //Zero Length flag enable
2797 status
= mos7840_set_reg_sync(serial
->port
[0], ZLP_REG5
, Data
);
2799 dbg("Writing ZLP_REG5 failed status-0x%x\n", status
);
2802 dbg("ZLP_REG5 Writing success status%d\n", status
);
2804 /* setting configuration feature to one */
2805 usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
2806 (__u8
) 0x03, 0x00, 0x01, 0x00, NULL
, 0x00, 5 * HZ
);
2810 /****************************************************************************
2812 * This function is called whenever the device is removed from the usb bus.
2813 ****************************************************************************/
2815 static void mos7840_shutdown(struct usb_serial
*serial
)
2818 struct moschip_port
*mos7840_port
;
2819 dbg("%s \n", " shutdown :entering..........");
2822 dbg("%s", "Invalid Handler \n");
2826 /* check for the ports to be closed,close the ports and disconnect */
2828 /* free private structure allocated for serial port *
2829 * stop reads and writes on all ports */
2831 for (i
= 0; i
< serial
->num_ports
; ++i
) {
2832 mos7840_port
= mos7840_get_port_private(serial
->port
[i
]);
2833 kfree(mos7840_port
->ctrl_buf
);
2834 usb_kill_urb(mos7840_port
->control_urb
);
2835 kfree(mos7840_port
);
2836 mos7840_set_port_private(serial
->port
[i
], NULL
);
2839 dbg("%s\n", "Thank u :: ");
2843 static struct usb_serial_driver moschip7840_4port_device
= {
2845 .owner
= THIS_MODULE
,
2848 .description
= DRIVER_DESC
,
2849 .id_table
= moschip_port_id_table
,
2850 .num_interrupt_in
= 1, //NUM_DONT_CARE,//1,
2856 .open
= mos7840_open
,
2857 .close
= mos7840_close
,
2858 .write
= mos7840_write
,
2859 .write_room
= mos7840_write_room
,
2860 .chars_in_buffer
= mos7840_chars_in_buffer
,
2861 .throttle
= mos7840_throttle
,
2862 .unthrottle
= mos7840_unthrottle
,
2863 .calc_num_ports
= mos7840_calc_num_ports
,
2864 #ifdef MCSSerialProbe
2865 .probe
= mos7840_serial_probe
,
2867 .ioctl
= mos7840_ioctl
,
2868 .set_termios
= mos7840_set_termios
,
2869 .break_ctl
= mos7840_break
,
2870 .tiocmget
= mos7840_tiocmget
,
2871 .tiocmset
= mos7840_tiocmset
,
2872 .attach
= mos7840_startup
,
2873 .shutdown
= mos7840_shutdown
,
2874 .read_bulk_callback
= mos7840_bulk_in_callback
,
2875 .read_int_callback
= mos7840_interrupt_callback
,
2878 static struct usb_driver io_driver
= {
2880 .probe
= usb_serial_probe
,
2881 .disconnect
= usb_serial_disconnect
,
2882 .id_table
= moschip_id_table_combined
,
2885 /****************************************************************************
2887 * This is called by the module subsystem, or on startup to initialize us
2888 ****************************************************************************/
2889 static int __init
moschip7840_init(void)
2893 dbg("%s \n", " mos7840_init :entering..........");
2895 /* Register with the usb serial */
2896 retval
= usb_serial_register(&moschip7840_4port_device
);
2899 goto failed_port_device_register
;
2901 dbg("%s\n", "Entring...");
2902 info(DRIVER_DESC
" " DRIVER_VERSION
);
2904 /* Register with the usb */
2905 retval
= usb_register(&io_driver
);
2908 goto failed_usb_register
;
2911 dbg("%s\n", "Leaving...");
2915 failed_usb_register
:
2916 usb_serial_deregister(&moschip7840_4port_device
);
2918 failed_port_device_register
:
2923 /****************************************************************************
2925 * Called when the driver is about to be unloaded.
2926 ****************************************************************************/
2927 static void __exit
moschip7840_exit(void)
2930 dbg("%s \n", " mos7840_exit :entering..........");
2932 usb_deregister(&io_driver
);
2934 usb_serial_deregister(&moschip7840_4port_device
);
2936 dbg("%s\n", "Entring...");
2939 module_init(moschip7840_init
);
2940 module_exit(moschip7840_exit
);
2942 /* Module information */
2943 MODULE_DESCRIPTION(DRIVER_DESC
);
2944 MODULE_LICENSE("GPL");
2946 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
2947 MODULE_PARM_DESC(debug
, "Debug enabled or not");