Skip to content

K
kernel_linux

OpenHarmony / kernel_linux
上一次同步 4 年多

通知 15
Star 8
Fork 2
K
kernel_linux
You need to sign in or sign up before continuing.
提交 a9ea2266 编写于 作者: G Greg Kroah-Hartman
浏览文件
操作

Staging: serqt_usb: Lindent the code 

Run Lindent on the code to give us someplace to work from
Signed-off-by: NGreg Kroah-Hartman <gregkh@suse.de>
上级 5ca0121f
隐藏空白更改
内联 并排
Showing with 1945 addition and 2081 deletion
drivers/staging/serqt_usb/serqt_usb.c
浏览文件 @ a9ea2266
...@@ -20,34 +20,31 @@ ...@@ -20,34 +20,31 @@
//#define DEBUG_ON //#define DEBUG_ON
//#undef dbg //#undef dbg
#ifdef DEBUG_ON #ifdef DEBUG_ON
#define mydbg(const...) printk(const) #define mydbg(const...) printk(const)
#else #else
#define mydbg(const...) #define mydbg(const...)
#endif #endif
/* parity check flag */ /* parity check flag */
#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK)) #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
#define SERIAL_TTY_MAJOR 0 /* Nice legal number now */ #define SERIAL_TTY_MAJOR 0 /* Nice legal number now */
#define SERIAL_TTY_MINORS 255 /* loads of devices :) */ #define SERIAL_TTY_MINORS 255 /* loads of devices :) */
#define MAX_NUM_PORTS 8 /* The maximum number of ports one device can grab at once */ #define MAX_NUM_PORTS 8 /* The maximum number of ports one device can grab at once */
#define PREFUFF_LEVEL_CONSERVATIVE 128 #define PREFUFF_LEVEL_CONSERVATIVE 128
#define ATC_DISABLED 0x00 #define ATC_DISABLED 0x00
#define RR_BITS 0x03 //for clearing clock bits #define RR_BITS 0x03 //for clearing clock bits
#define DUPMODE_BITS 0xc0 #define DUPMODE_BITS 0xc0
#define RS232_MODE 0x00 #define RS232_MODE 0x00
#define RTSCTS_TO_CONNECTOR 0x40 #define RTSCTS_TO_CONNECTOR 0x40
#define CLKS_X4 0x02 /// #define CLKS_X4 0x02 ///
#define LOOPMODE_BITS 0x41 //LOOP1 = b6, LOOP0 = b0 (PORT B) #define LOOPMODE_BITS 0x41 //LOOP1 = b6, LOOP0 = b0 (PORT B)
#define ALL_LOOPBACK 0x01 #define ALL_LOOPBACK 0x01
#define MODEM_CTRL 0x40 #define MODEM_CTRL 0x40
#define THISCHAR data[i] #define THISCHAR data[i]
#define NEXTCHAR data[i + 1] #define NEXTCHAR data[i + 1]
#define THIRDCHAR data[i + 2] #define THIRDCHAR data[i + 2]
...@@ -58,7 +55,6 @@ ...@@ -58,7 +55,6 @@
#define FULLPWRBIT 0x00000080 #define FULLPWRBIT 0x00000080
#define NEXT_BOARD_POWER_BIT 0x00000004 #define NEXT_BOARD_POWER_BIT 0x00000004
#define SERIAL_LSR_OE 0x02 #define SERIAL_LSR_OE 0x02
#define SERIAL_LSR_PE 0x04 #define SERIAL_LSR_PE 0x04
#define SERIAL_LSR_FE 0x08 #define SERIAL_LSR_FE 0x08
...@@ -76,7 +72,6 @@ ...@@ -76,7 +72,6 @@
#define LINE_STATUS_REGISTER 0x05 #define LINE_STATUS_REGISTER 0x05
#define MODEM_STATUS_REGISTER 0x06 #define MODEM_STATUS_REGISTER 0x06
#define SERIAL_MCR_DTR 0x01 #define SERIAL_MCR_DTR 0x01
#define SERIAL_MCR_RTS 0x02 #define SERIAL_MCR_RTS 0x02
#define SERIAL_MCR_LOOP 0x10 #define SERIAL_MCR_LOOP 0x10
...@@ -100,7 +95,6 @@ ...@@ -100,7 +95,6 @@
#define MAX_BAUD_RATE 460800 #define MAX_BAUD_RATE 460800
#define MAX_BAUD_REMAINDER 4608 #define MAX_BAUD_REMAINDER 4608
#define QT_SET_GET_DEVICE 0xc2 #define QT_SET_GET_DEVICE 0xc2
#define QT_OPEN_CLOSE_CHANNEL 0xca #define QT_OPEN_CLOSE_CHANNEL 0xca
#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
...@@ -119,8 +113,7 @@ ...@@ -119,8 +113,7 @@
#define SERIALQT_GET_THIS_UNIT _IOR(SERIALQT_PCI_IOC_MAGIC, 3, void *) #define SERIALQT_GET_THIS_UNIT _IOR(SERIALQT_PCI_IOC_MAGIC, 3, void *)
#define SERIALQT_READ_QOPR _IOR(SERIALQT_PCI_IOC_MAGIC, 4, int) #define SERIALQT_READ_QOPR _IOR(SERIALQT_PCI_IOC_MAGIC, 4, int)
#define SERIALQT_READ_QMCR _IOR(SERIALQT_PCI_IOC_MAGIC, 5, int) #define SERIALQT_READ_QMCR _IOR(SERIALQT_PCI_IOC_MAGIC, 5, int)
#define SERIALQT_IS422_EXTENDED _IOR(SERIALQT_PCI_IOC_MAGIC, 6, int) //returns successful if 422 extended #define SERIALQT_IS422_EXTENDED _IOR(SERIALQT_PCI_IOC_MAGIC, 6, int) //returns successful if 422 extended
#define USBD_TRANSFER_DIRECTION_IN 0xc0 #define USBD_TRANSFER_DIRECTION_IN 0xc0
#define USBD_TRANSFER_DIRECTION_OUT 0x40 #define USBD_TRANSFER_DIRECTION_OUT 0x40
...@@ -129,7 +122,7 @@ ...@@ -129,7 +122,7 @@
#define ATC_RTS_ENABLED 0x02 #define ATC_RTS_ENABLED 0x02
#define ATC_DTR_ENABLED 0x01 #define ATC_DTR_ENABLED 0x01
#define RR_BITS 0x03 //for clearing clock bits #define RR_BITS 0x03 //for clearing clock bits
#define DUPMODE_BITS 0xc0 #define DUPMODE_BITS 0xc0
#define FULL_DUPLEX 0x00 #define FULL_DUPLEX 0x00
...@@ -147,75 +140,71 @@ ...@@ -147,75 +140,71 @@
#define QMCR_ALL_LOOPBACK 0x10 #define QMCR_ALL_LOOPBACK 0x10
#define QMCR_MODEM_CONTROL 0X00 #define QMCR_MODEM_CONTROL 0X00
#define SERIALQT_IOC_MAXNR 6 #define SERIALQT_IOC_MAXNR 6
struct usb_serial_port { struct usb_serial_port {
struct usb_serial *serial; /* pointer back to the owner of this port */ struct usb_serial *serial; /* pointer back to the owner of this port */
struct tty_struct * tty; /* the coresponding tty for this port */ struct tty_struct *tty; /* the coresponding tty for this port */
unsigned char number; unsigned char number;
char active; /* someone has this device open */ char active; /* someone has this device open */
unsigned char * interrupt_in_buffer; unsigned char *interrupt_in_buffer;
struct urb * interrupt_in_urb; struct urb *interrupt_in_urb;
__u8 interrupt_in_endpointAddress; __u8 interrupt_in_endpointAddress;
unsigned char * bulk_in_buffer; unsigned char *bulk_in_buffer;
unsigned char * xfer_to_tty_buffer; unsigned char *xfer_to_tty_buffer;
struct urb * read_urb; struct urb *read_urb;
__u8 bulk_in_endpointAddress; __u8 bulk_in_endpointAddress;
unsigned char * bulk_out_buffer; unsigned char *bulk_out_buffer;
int bulk_out_size; int bulk_out_size;
struct urb * write_urb; struct urb *write_urb;
__u8 bulk_out_endpointAddress; __u8 bulk_out_endpointAddress;
wait_queue_head_t write_wait; wait_queue_head_t write_wait;
wait_queue_head_t wait; wait_queue_head_t wait;
struct work_struct work; struct work_struct work;
int open_count; /* number of times this port has been opened */ int open_count; /* number of times this port has been opened */
struct semaphore sem; /* locks this structure */ struct semaphore sem; /* locks this structure */
__u8 shadowLCR; /* last LCR value received */ __u8 shadowLCR; /* last LCR value received */
__u8 shadowMCR; /* last MCR value received */ __u8 shadowMCR; /* last MCR value received */
__u8 shadowMSR; /* last MSR value received */ __u8 shadowMSR; /* last MSR value received */
__u8 shadowLSR; /* last LSR value received */ __u8 shadowLSR; /* last LSR value received */
int RxHolding; int RxHolding;
char closePending; char closePending;
int ReadBulkStopped; int ReadBulkStopped;
void * private; /* data private to the specific port */ void *private; /* data private to the specific port */
}; };
struct identity { struct identity {
int index; int index;
int n_identity; int n_identity;
}; };
struct usb_serial { struct usb_serial {
struct usb_device * dev; struct usb_device *dev;
struct usb_interface * interface; /* the interface for this device */ struct usb_interface *interface; /* the interface for this device */
struct tty_driver * tty_driver; /* the tty_driver for this device */ struct tty_driver *tty_driver; /* the tty_driver for this device */
unsigned char minor; /* the starting minor number for this device */ unsigned char minor; /* the starting minor number for this device */
unsigned char num_ports; /* the number of ports this device has */ unsigned char num_ports; /* the number of ports this device has */
char num_interrupt_in; /* number of interrupt in endpoints we have */ char num_interrupt_in; /* number of interrupt in endpoints we have */
char num_bulk_in; /* number of bulk in endpoints we have */ char num_bulk_in; /* number of bulk in endpoints we have */
char num_bulk_out; /* number of bulk out endpoints we have */ char num_bulk_out; /* number of bulk out endpoints we have */
unsigned char num_OpenCount; /* the number of ports this device has */ unsigned char num_OpenCount; /* the number of ports this device has */
__u16 vendor; /* vendor id of this device */
__u16 vendor; /* vendor id of this device */ __u16 product; /* product id of this device */
__u16 product; /* product id of this device */ struct usb_serial_port port[MAX_NUM_PORTS];
struct usb_serial_port port[MAX_NUM_PORTS];
void *private; /* data private to the specific driver */
void * private; /* data private to the specific driver */
}; };
static inline int port_paranoia_check(struct usb_serial_port *port,
const char *function)
static inline int port_paranoia_check (struct usb_serial_port *port, const char *function)
{ {
if (!port) { if (!port) {
dbg("%s - port == NULL", function); dbg("%s - port == NULL", function);
...@@ -233,9 +222,9 @@ static inline int port_paranoia_check (struct usb_serial_port *port, const char ...@@ -233,9 +222,9 @@ static inline int port_paranoia_check (struct usb_serial_port *port, const char
return 0; return 0;
} }
/* Inline functions to check the sanity of a pointer that is passed to us */ /* Inline functions to check the sanity of a pointer that is passed to us */
static inline int serial_paranoia_check (struct usb_serial *serial, const char *function) static inline int serial_paranoia_check(struct usb_serial *serial,
const char *function)
{ {
if (!serial) { if (!serial) {
dbg("%s - serial == NULL\n", function); dbg("%s - serial == NULL\n", function);
...@@ -245,13 +234,13 @@ static inline int serial_paranoia_check (struct usb_serial *serial, const char * ...@@ -245,13 +234,13 @@ static inline int serial_paranoia_check (struct usb_serial *serial, const char *
return 0; return 0;
} }
static inline struct usb_serial *get_usb_serial(struct usb_serial_port *port,
static inline struct usb_serial* get_usb_serial (struct usb_serial_port *port, const char *function) const char *function)
{ {
/* if no port was specified, or it fails a paranoia check */ /* if no port was specified, or it fails a paranoia check */
if (!port || if (!port ||
port_paranoia_check (port, function) || port_paranoia_check(port, function) ||
serial_paranoia_check (port->serial, function)) { serial_paranoia_check(port->serial, function)) {
/* then say that we dont have a valid usb_serial thing, which will /* then say that we dont have a valid usb_serial thing, which will
* end up genrating -ENODEV return values */ * end up genrating -ENODEV return values */
return NULL; return NULL;
...@@ -260,90 +249,99 @@ static inline struct usb_serial* get_usb_serial (struct usb_serial_port *port, c ...@@ -260,90 +249,99 @@ static inline struct usb_serial* get_usb_serial (struct usb_serial_port *port, c
return port->serial; return port->serial;
} }
struct qt_get_device_data {
struct qt_get_device_data
{
__u8 porta; __u8 porta;
__u8 portb; __u8 portb;
__u8 portc; __u8 portc;
}; };
struct qt_open_channel_data struct qt_open_channel_data {
{
__u8 line_status; __u8 line_status;
__u8 modem_status; __u8 modem_status;
}; };
static void ProcessLineStatus(struct usb_serial_port *port, unsigned char line_status); static void ProcessLineStatus(struct usb_serial_port *port,
static void ProcessModemStatus(struct usb_serial_port *port, unsigned char modem_status); unsigned char line_status);
static void ProcessModemStatus(struct usb_serial_port *port,
unsigned char modem_status);
static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data); static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data);
static struct usb_serial *get_free_serial (int num_ports, int *minor); static struct usb_serial *get_free_serial(int num_ports, int *minor);
static int serqt_probe(struct usb_interface *interface, static int serqt_probe(struct usb_interface *interface,
const struct usb_device_id *id); const struct usb_device_id *id);
static void serqt_usb_disconnect(struct usb_interface *interface); static void serqt_usb_disconnect(struct usb_interface *interface);
static int box_set_device(struct usb_serial *serial, struct qt_get_device_data *pDeviceData); static int box_set_device(struct usb_serial *serial,
static int box_get_device(struct usb_serial *serial, struct qt_get_device_data *pDeviceData); struct qt_get_device_data *pDeviceData);
static int serial_open (struct tty_struct *tty, struct file * filp); static int box_get_device(struct usb_serial *serial,
static void serial_close(struct tty_struct *tty, struct file * filp); struct qt_get_device_data *pDeviceData);
static int serial_write_room (struct tty_struct *tty); static int serial_open(struct tty_struct *tty, struct file *filp);
static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg); static void serial_close(struct tty_struct *tty, struct file *filp);
static void serial_set_termios (struct tty_struct *tty, struct ktermios * old); static int serial_write_room(struct tty_struct *tty);
static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count); static int serial_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg);
static void serial_throttle (struct tty_struct * tty); static void serial_set_termios(struct tty_struct *tty, struct ktermios *old);
static void serial_unthrottle (struct tty_struct * tty); static int serial_write(struct tty_struct *tty, const unsigned char *buf,
static int serial_break (struct tty_struct *tty, int break_state); int count);
static int serial_chars_in_buffer (struct tty_struct *tty);
static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data); static void serial_throttle(struct tty_struct *tty);
static void serial_unthrottle(struct tty_struct *tty);
static int qt_open (struct usb_serial_port *port, struct file *filp); static int serial_break(struct tty_struct *tty, int break_state);
static int serial_chars_in_buffer(struct tty_struct *tty);
static int serial_read_proc(char *page, char **start, off_t off, int count,
int *eof, void *data);
static int qt_open(struct usb_serial_port *port, struct file *filp);
static int BoxSetPrebufferLevel(struct usb_serial *serial); static int BoxSetPrebufferLevel(struct usb_serial *serial);
static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode); static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode);
static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number, unsigned short default_divisor, unsigned char default_LCR ); static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
unsigned short default_divisor,
unsigned char default_LCR);
static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number, __u16 OpenClose, struct qt_open_channel_data *pDeviceData);
static void qt_close (struct usb_serial_port *port, struct file * filp); static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,unsigned short Register_Num, __u8 *pValue); __u16 OpenClose,
static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number, unsigned short Register_Num, unsigned short Value ); struct qt_open_channel_data *pDeviceData);
static void qt_close(struct usb_serial_port *port, struct file *filp);
static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
unsigned short Register_Num, __u8 * pValue);
static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
unsigned short Register_Num, unsigned short Value);
static void qt_write_bulk_callback(struct urb *urb); static void qt_write_bulk_callback(struct urb *urb);
static int qt_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count); static int qt_write(struct usb_serial_port *port, int from_user,
const unsigned char *buf, int count);
static void port_softint(struct work_struct *work); static void port_softint(struct work_struct *work);
static int qt_write_room (struct usb_serial_port *port); static int qt_write_room(struct usb_serial_port *port);
static int qt_chars_in_buffer (struct usb_serial_port *port); static int qt_chars_in_buffer(struct usb_serial_port *port);
static int qt_ioctl(struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg); static int qt_ioctl(struct usb_serial_port *port, struct file *file,
static void qt_set_termios(struct usb_serial_port *port, struct ktermios *old_termios); unsigned int cmd, unsigned long arg);
static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int UartNumber, int bSet); static void qt_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios);
static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int UartNumber,
int bSet);
static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber); static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber);
static int EmulateWriteQMCR_Reg(int index, unsigned uc_value); static int EmulateWriteQMCR_Reg(int index, unsigned uc_value);
static int EmulateReadQMCR_Reg(int index, unsigned *uc_value); static int EmulateReadQMCR_Reg(int index, unsigned *uc_value);
static struct usb_serial *find_the_box(unsigned int index); static struct usb_serial *find_the_box(unsigned int index);
int ioctl_serial_usb (struct inode *innod, struct file *filp, unsigned int cmd, unsigned long arg); int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
unsigned long arg);
static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 Uart,
static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 Uart, unsigned char stop_char, unsigned char start_char); unsigned char stop_char, unsigned char start_char);
static void qt_read_bulk_callback(struct urb *urb); static void qt_read_bulk_callback(struct urb *urb);
static void port_sofrint(void *private); static void port_sofrint(void *private);
static void return_serial(struct usb_serial *serial); static void return_serial(struct usb_serial *serial);
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
static int serial_tiocmset (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear); unsigned int set, unsigned int clear);
static int serial_tiocmget(struct tty_struct *tty, struct file *file); static int serial_tiocmget(struct tty_struct *tty, struct file *file);
static int qt_tiocmset(struct usb_serial_port *port, struct file *file,
unsigned int value);
static int qt_tiocmget(struct usb_serial_port *port, struct file *file);
static int qt_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int value);
static int qt_tiocmget(struct usb_serial_port *port, struct file * file);
/* Version Information */ /* Version Information */
#define DRIVER_VERSION "v2.14" #define DRIVER_VERSION "v2.14"
...@@ -370,34 +368,39 @@ static int qt_tiocmget(struct usb_serial_port *port, struct file * file); ...@@ -370,34 +368,39 @@ static int qt_tiocmget(struct usb_serial_port *port, struct file * file);
#define DEVICE_ID_QUATECH_RS422_16_PORT_C 0xC0B2 //HSU200C #define DEVICE_ID_QUATECH_RS422_16_PORT_C 0xC0B2 //HSU200C
#define DEVICE_ID_QUATECH_RS422_16_PORT_D 0xC0B3 //HSU200D #define DEVICE_ID_QUATECH_RS422_16_PORT_D 0xC0B3 //HSU200D
/* table of Quatech devices */ /* table of Quatech devices */
static struct usb_device_id serqt_table [] = { static struct usb_device_id serqt_table[] = {
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_SINGLE_PORT)}, {USB_DEVICE
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_SINGLE_PORT)}, (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_SINGLE_PORT)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_DUAL_PORT)}, {USB_DEVICE
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_DUAL_PORT)}, (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_SINGLE_PORT)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_FOUR_PORT)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_DUAL_PORT)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_FOUR_PORT)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_DUAL_PORT)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_FOUR_PORT)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_FOUR_PORT)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A)}, {USB_DEVICE
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B)}, (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_A)}, {USB_DEVICE
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_B)}, (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_C)}, {USB_DEVICE
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_D)}, (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_A)}, {USB_DEVICE
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_B)}, (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_C)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_A)},
{ USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_D)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_B)},
{} /* Terminating entry */ {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_C)},
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_D)},
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_A)},
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_B)},
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_C)},
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_D)},
{} /* Terminating entry */
}; };
MODULE_DEVICE_TABLE(usb, serqt_table); MODULE_DEVICE_TABLE(usb, serqt_table);
static int major_number; static int major_number;
static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */ static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
/* table of Quatech 422devices */ /* table of Quatech 422devices */
static unsigned int serqt_422_table[] = { static unsigned int serqt_422_table[] = {
...@@ -410,66 +413,64 @@ static unsigned int serqt_422_table[] = { ...@@ -410,66 +413,64 @@ static unsigned int serqt_422_table[] = {
DEVICE_ID_QUATECH_RS422_16_PORT_B, DEVICE_ID_QUATECH_RS422_16_PORT_B,
DEVICE_ID_QUATECH_RS422_16_PORT_C, DEVICE_ID_QUATECH_RS422_16_PORT_C,
DEVICE_ID_QUATECH_RS422_16_PORT_D, DEVICE_ID_QUATECH_RS422_16_PORT_D,
0 /* terminate with zero */ 0 /* terminate with zero */
}; };
/* usb specific object needed to register this driver with the usb subsystem */ /* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver serqt_usb_driver = { static struct usb_driver serqt_usb_driver = {
.name = "quatech-usb-serial", .name = "quatech-usb-serial",
.probe = serqt_probe, .probe = serqt_probe,
.disconnect = serqt_usb_disconnect, .disconnect = serqt_usb_disconnect,
.id_table = serqt_table, .id_table = serqt_table,
}; };
static struct ktermios *serial_termios[SERIAL_TTY_MINORS]; static struct ktermios *serial_termios[SERIAL_TTY_MINORS];
static struct ktermios *serial_termios_locked[SERIAL_TTY_MINORS]; static struct ktermios *serial_termios_locked[SERIAL_TTY_MINORS];
static const struct tty_operations serial_ops = { static const struct tty_operations serial_ops = {
.open = serial_open, .open = serial_open,
.close = serial_close, .close = serial_close,
.write = serial_write, .write = serial_write,
.write_room = serial_write_room, .write_room = serial_write_room,
.ioctl = serial_ioctl, .ioctl = serial_ioctl,
.set_termios = serial_set_termios, .set_termios = serial_set_termios,
.throttle = serial_throttle, .throttle = serial_throttle,
.unthrottle = serial_unthrottle, .unthrottle = serial_unthrottle,
.break_ctl = serial_break, .break_ctl = serial_break,
.chars_in_buffer = serial_chars_in_buffer, .chars_in_buffer = serial_chars_in_buffer,
.read_proc = serial_read_proc, .read_proc = serial_read_proc,
.tiocmset = serial_tiocmset, .tiocmset = serial_tiocmset,
.tiocmget = serial_tiocmget, .tiocmget = serial_tiocmget,
}; };
static struct tty_driver serial_tty_driver = { static struct tty_driver serial_tty_driver = {
.magic = TTY_DRIVER_MAGIC, .magic = TTY_DRIVER_MAGIC,
.driver_name = "Quatech usb-serial", .driver_name = "Quatech usb-serial",
.name = "ttyQT_USB", .name = "ttyQT_USB",
.major = SERIAL_TTY_MAJOR, .major = SERIAL_TTY_MAJOR,
.minor_start = 0, .minor_start = 0,
.num = SERIAL_TTY_MINORS, .num = SERIAL_TTY_MINORS,
.type = TTY_DRIVER_TYPE_SERIAL, .type = TTY_DRIVER_TYPE_SERIAL,
.subtype = SERIAL_TYPE_NORMAL, .subtype = SERIAL_TYPE_NORMAL,
.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV, .flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV,
.termios = serial_termios, .termios = serial_termios,
.termios_locked = serial_termios_locked, .termios_locked = serial_termios_locked,
.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL, .init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL,
.init_termios.c_iflag = ICRNL | IXON, .init_termios.c_iflag = ICRNL | IXON,
.init_termios.c_oflag = OPOST, .init_termios.c_oflag = OPOST,
.init_termios.c_lflag= ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN, .init_termios.c_lflag =
ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN,
}; };
//fops for parent device //fops for parent device
static struct file_operations serialqt_usb_fops = { static struct file_operations serialqt_usb_fops = {
.ioctl = ioctl_serial_usb, .ioctl = ioctl_serial_usb,
}; };
/** /**
* serqt_probe * serqt_probe
* *
...@@ -478,341 +479,299 @@ static struct file_operations serialqt_usb_fops = { ...@@ -478,341 +479,299 @@ static struct file_operations serialqt_usb_fops = {
* *
*/ */
static int serqt_probe(struct usb_interface *interface, static int serqt_probe(struct usb_interface *interface,
const struct usb_device_id *id) const struct usb_device_id *id)
{ {
struct usb_device *dev = interface_to_usbdev(interface); struct usb_device *dev = interface_to_usbdev(interface);
struct usb_serial *serial = NULL; struct usb_serial *serial = NULL;
struct usb_serial_port *port; struct usb_serial_port *port;
struct usb_endpoint_descriptor *endpoint; struct usb_endpoint_descriptor *endpoint;
struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS]; struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS]; struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS]; struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
int minor; int minor;
int buffer_size; int buffer_size;
int i; int i;
struct usb_host_interface *iface_desc; struct usb_host_interface *iface_desc;
int num_interrupt_in = 0; int num_interrupt_in = 0;
int num_bulk_in = 0; int num_bulk_in = 0;
int num_bulk_out = 0; int num_bulk_out = 0;
int num_ports; int num_ports;
struct qt_get_device_data DeviceData; struct qt_get_device_data DeviceData;
int status; int status;
mydbg("In %s\n", __FUNCTION__); mydbg("In %s\n", __FUNCTION__);
/* let's find the endpoints needed */ /* let's find the endpoints needed */
/* check out the endpoints */ /* check out the endpoints */
iface_desc = interface->cur_altsetting;; iface_desc = interface->cur_altsetting;;
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
{ endpoint = &iface_desc->endpoint[i].desc;
endpoint = &iface_desc->endpoint[i].desc;
if ((endpoint->bEndpointAddress & 0x80) &&
if ((endpoint->bEndpointAddress & 0x80) && ((endpoint->bmAttributes & 3) == 0x02)) {
((endpoint->bmAttributes & 3) == 0x02)) /* we found a bulk in endpoint */
{ mydbg("found bulk in");
/* we found a bulk in endpoint */ bulk_in_endpoint[num_bulk_in] = endpoint;
mydbg("found bulk in"); ++num_bulk_in;
bulk_in_endpoint[num_bulk_in] = endpoint; }
++num_bulk_in;
} if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
((endpoint->bmAttributes & 3) == 0x02)) {
if (((endpoint->bEndpointAddress & 0x80) == 0x00) && /* we found a bulk out endpoint */
((endpoint->bmAttributes & 3) == 0x02)) mydbg("found bulk out\n");
{ bulk_out_endpoint[num_bulk_out] = endpoint;
/* we found a bulk out endpoint */ ++num_bulk_out;
mydbg("found bulk out\n"); }
bulk_out_endpoint[num_bulk_out] = endpoint;
++num_bulk_out; if ((endpoint->bEndpointAddress & 0x80) &&
} ((endpoint->bmAttributes & 3) == 0x03)) {
/* we found a interrupt in endpoint */
if ((endpoint->bEndpointAddress & 0x80) && mydbg("found interrupt in\n");
((endpoint->bmAttributes & 3) == 0x03)) interrupt_in_endpoint[num_interrupt_in] = endpoint;
{ ++num_interrupt_in;
/* we found a interrupt in endpoint */ }
mydbg("found interrupt in\n"); }
interrupt_in_endpoint[num_interrupt_in] = endpoint;
++num_interrupt_in; /* found all that we need */
} dev_info(&interface->dev, "Quatech converter detected\n");
} num_ports = num_bulk_out;
if (num_ports == 0) {
/* found all that we need */ err("Quatech device with no bulk out, not allowed.");
dev_info(&interface->dev, "Quatech converter detected\n"); return -ENODEV;
num_ports = num_bulk_out;
if (num_ports == 0) }
{
err("Quatech device with no bulk out, not allowed."); serial = get_free_serial(num_ports, &minor);
return -ENODEV; if (serial == NULL) {
err("No more free serial devices");
} return -ENODEV;
}
serial = get_free_serial (num_ports, &minor);
if (serial == NULL) serial->dev = dev;
{ serial->interface = interface;
err("No more free serial devices"); serial->minor = minor;
return -ENODEV; serial->num_ports = num_ports;
} serial->num_bulk_in = num_bulk_in;
serial->num_bulk_out = num_bulk_out;
serial->dev = dev; serial->num_interrupt_in = num_interrupt_in;
serial->interface = interface; serial->vendor = dev->descriptor.idVendor;
serial->minor = minor; serial->product = dev->descriptor.idProduct;
serial->num_ports = num_ports;
serial->num_bulk_in = num_bulk_in; /* set up the endpoint information */
serial->num_bulk_out = num_bulk_out; for (i = 0; i < num_bulk_in; ++i) {
serial->num_interrupt_in = num_interrupt_in; endpoint = bulk_in_endpoint[i];
serial->vendor = dev->descriptor.idVendor; port = &serial->port[i];
serial->product = dev->descriptor.idProduct; port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!port->read_urb) {
err("No free urbs available");
/* set up the endpoint information */ goto probe_error;
for (i = 0; i < num_bulk_in; ++i) }
{ buffer_size = endpoint->wMaxPacketSize;
endpoint = bulk_in_endpoint[i]; port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
port = &serial->port[i]; port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
port->read_urb = usb_alloc_urb (0, GFP_KERNEL); port->xfer_to_tty_buffer = kmalloc(buffer_size, GFP_KERNEL);
if (!port->read_urb) if (!port->bulk_in_buffer) {
{ err("Couldn't allocate bulk_in_buffer");
err("No free urbs available"); goto probe_error;
goto probe_error; }
} usb_fill_bulk_urb(port->read_urb, dev,
buffer_size = endpoint->wMaxPacketSize; usb_rcvbulkpipe(dev,
port->bulk_in_endpointAddress = endpoint->bEndpointAddress; endpoint->bEndpointAddress),
port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL); port->bulk_in_buffer, buffer_size,
port->xfer_to_tty_buffer = kmalloc (buffer_size, GFP_KERNEL); qt_read_bulk_callback, port);
if (!port->bulk_in_buffer) }
{
err("Couldn't allocate bulk_in_buffer"); for (i = 0; i < num_bulk_out; ++i) {
goto probe_error; endpoint = bulk_out_endpoint[i];
} port = &serial->port[i];
usb_fill_bulk_urb (port->read_urb, dev, port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
usb_rcvbulkpipe (dev, if (!port->write_urb) {
endpoint->bEndpointAddress), err("No free urbs available");
port->bulk_in_buffer, buffer_size, goto probe_error;
qt_read_bulk_callback, }
port); buffer_size = endpoint->wMaxPacketSize;
} port->bulk_out_size = buffer_size;
port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
for (i = 0; i < num_bulk_out; ++i) port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
{ if (!port->bulk_out_buffer) {
endpoint = bulk_out_endpoint[i]; err("Couldn't allocate bulk_out_buffer");
port = &serial->port[i]; goto probe_error;
port->write_urb = usb_alloc_urb (0, GFP_KERNEL); }
if (!port->write_urb) usb_fill_bulk_urb(port->write_urb, dev,
{ usb_sndbulkpipe(dev,
err("No free urbs available"); endpoint->bEndpointAddress),
goto probe_error; port->bulk_out_buffer, buffer_size,
} qt_write_bulk_callback, port);
buffer_size = endpoint->wMaxPacketSize;
port->bulk_out_size = buffer_size; }
port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL); //For us numb of bulkin or out = number of ports
if (!port->bulk_out_buffer)
{ mydbg("%s - setting up %d port structures for this device\n",
err("Couldn't allocate bulk_out_buffer"); __FUNCTION__, num_bulk_in);
goto probe_error; for (i = 0; i < num_bulk_in; ++i) {
} port = &serial->port[i];
usb_fill_bulk_urb (port->write_urb, dev, port->number = i + serial->minor;
usb_sndbulkpipe (dev, port->serial = serial;
endpoint->bEndpointAddress),
port->bulk_out_buffer, buffer_size, INIT_WORK(&port->work, port_softint);
qt_write_bulk_callback,
port); init_MUTEX(&port->sem);
}
} status = box_get_device(serial, &DeviceData);
if (status < 0) {
//For us numb of bulkin or out = number of ports mydbg(__FILE__ "box_get_device failed");
goto probe_error;
mydbg("%s - setting up %d port structures for this device\n", __FUNCTION__, num_bulk_in); }
for (i = 0; i < num_bulk_in; ++i)
{ mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
port = &serial->port[i];
port->number = i + serial->minor; DeviceData.portb &= ~FULLPWRBIT;
port->serial = serial; mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
INIT_WORK(&port->work, port_softint); status = box_set_device(serial, &DeviceData);
if (status < 0) {
init_MUTEX (&port->sem); mydbg(__FILE__ "box_set_device failed\n");
goto probe_error;
}
} /* initialize the devfs nodes for this device and let the user know what ports we are bound to */
status = box_get_device(serial, &DeviceData); for (i = 0; i < serial->num_ports; ++i) {
if (status < 0) dev_info(&interface->dev,
{ "Converter now attached to ttyUSB%d (or usb/tts/%d for devfs)",
mydbg(__FILE__"box_get_device failed"); serial->port[i].number, serial->port[i].number);
goto probe_error; }
}
mydbg(__FILE__"DeviceData.portb = 0x%x",DeviceData.portb);
DeviceData.portb &= ~FULLPWRBIT;
mydbg(__FILE__"Changing DeviceData.portb to 0x%x",DeviceData.portb);
status = box_set_device(serial, &DeviceData);
if (status < 0)
{
mydbg(__FILE__"box_set_device failed\n");
goto probe_error;
}
/* initialize the devfs nodes for this device and let the user know what ports we are bound to */
for (i = 0; i < serial->num_ports; ++i)
{
dev_info(&interface->dev, "Converter now attached to ttyUSB%d (or usb/tts/%d for devfs)",
serial->port[i].number, serial->port[i].number);
}
//usb_serial_console_init (debug, minor); //usb_serial_console_init (debug, minor);
///***********TAG add start next board here ****/// ///***********TAG add start next board here ****///
status = box_get_device(serial, &DeviceData); status = box_get_device(serial, &DeviceData);
if (status < 0) if (status < 0) {
{ mydbg(__FILE__ "box_get_device failed");
mydbg(__FILE__"box_get_device failed"); goto probe_error;
goto probe_error; }
} //*****************and before we power up lets initialiaze parnent device stuff here before
//*****************we set thmem via any other method such as the property pages
//*****************and before we power up lets initialiaze parnent device stuff here before switch (serial->product) {
//*****************we set thmem via any other method such as the property pages case DEVICE_ID_QUATECH_RS232_SINGLE_PORT:
switch (serial->product) case DEVICE_ID_QUATECH_RS232_DUAL_PORT:
{ case DEVICE_ID_QUATECH_RS232_FOUR_PORT:
case DEVICE_ID_QUATECH_RS232_SINGLE_PORT: case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A:
case DEVICE_ID_QUATECH_RS232_DUAL_PORT: case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B:
case DEVICE_ID_QUATECH_RS232_FOUR_PORT: case DEVICE_ID_QUATECH_RS232_16_PORT_A:
case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A: case DEVICE_ID_QUATECH_RS232_16_PORT_B:
case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B: case DEVICE_ID_QUATECH_RS232_16_PORT_C:
case DEVICE_ID_QUATECH_RS232_16_PORT_A: case DEVICE_ID_QUATECH_RS232_16_PORT_D:
case DEVICE_ID_QUATECH_RS232_16_PORT_B: DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
case DEVICE_ID_QUATECH_RS232_16_PORT_C: DeviceData.porta |= CLKS_X4;
case DEVICE_ID_QUATECH_RS232_16_PORT_D: DeviceData.portb &= ~(LOOPMODE_BITS);
DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS); DeviceData.portb |= RS232_MODE;
DeviceData.porta |= CLKS_X4; break;
DeviceData.portb &= ~(LOOPMODE_BITS);
DeviceData.portb |= RS232_MODE; case DEVICE_ID_QUATECH_RS422_SINGLE_PORT:
break; case DEVICE_ID_QUATECH_RS422_DUAL_PORT:
case DEVICE_ID_QUATECH_RS422_FOUR_PORT:
case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A:
case DEVICE_ID_QUATECH_RS422_SINGLE_PORT: case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B:
case DEVICE_ID_QUATECH_RS422_DUAL_PORT: case DEVICE_ID_QUATECH_RS422_16_PORT_A:
case DEVICE_ID_QUATECH_RS422_FOUR_PORT: case DEVICE_ID_QUATECH_RS422_16_PORT_B:
case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A: case DEVICE_ID_QUATECH_RS422_16_PORT_C:
case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B: case DEVICE_ID_QUATECH_RS422_16_PORT_D:
case DEVICE_ID_QUATECH_RS422_16_PORT_A: DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
case DEVICE_ID_QUATECH_RS422_16_PORT_B: DeviceData.porta |= CLKS_X4;
case DEVICE_ID_QUATECH_RS422_16_PORT_C: DeviceData.portb &= ~(LOOPMODE_BITS);
case DEVICE_ID_QUATECH_RS422_16_PORT_D: DeviceData.portb |= ALL_LOOPBACK;
DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS); break;
DeviceData.porta |= CLKS_X4; default:
DeviceData.portb &= ~(LOOPMODE_BITS); DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
DeviceData.portb |= ALL_LOOPBACK; DeviceData.porta |= CLKS_X4;
break; DeviceData.portb &= ~(LOOPMODE_BITS);
default: DeviceData.portb |= RS232_MODE;
DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS); break;
DeviceData.porta |= CLKS_X4;
DeviceData.portb &= ~(LOOPMODE_BITS);
DeviceData.portb |= RS232_MODE;
break;
}
status = BoxSetPrebufferLevel(serial); //sets to default vaue
if (status < 0)
{
mydbg(__FILE__"BoxSetPrebufferLevel failed\n");
goto probe_error;
}
status = BoxSetATC(serial, ATC_DISABLED);
if (status < 0)
{
mydbg(__FILE__"BoxSetATC failed\n");
goto probe_error;
}
//****************************************************************************
mydbg(__FILE__"DeviceData.portb = 0x%x",DeviceData.portb);
DeviceData.portb |= NEXT_BOARD_POWER_BIT;
mydbg(__FILE__"Changing DeviceData.portb to 0x%x",DeviceData.portb);
status = box_set_device(serial, &DeviceData);
if (status < 0)
{
mydbg(__FILE__"box_set_device failed\n");
goto probe_error;
}
mydbg("Exit Success %s\n", __FUNCTION__);
usb_set_intfdata (interface, serial);
return 0;
}
status = BoxSetPrebufferLevel(serial); //sets to default vaue
if (status < 0) {
mydbg(__FILE__ "BoxSetPrebufferLevel failed\n");
goto probe_error;
}
status = BoxSetATC(serial, ATC_DISABLED);
if (status < 0) {
mydbg(__FILE__ "BoxSetATC failed\n");
goto probe_error;
}
//****************************************************************************
mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
probe_error: DeviceData.portb |= NEXT_BOARD_POWER_BIT;
mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
for (i = 0; i < num_bulk_in; ++i)
{ status = box_set_device(serial, &DeviceData);
port = &serial->port[i]; if (status < 0) {
if (port->read_urb) mydbg(__FILE__ "box_set_device failed\n");
usb_free_urb (port->read_urb); goto probe_error;
if (port->bulk_in_buffer) }
kfree (port->bulk_in_buffer);
}
for (i = 0; i < num_bulk_out; ++i)
{
port = &serial->port[i];
if (port->write_urb)
usb_free_urb (port->write_urb);
if (port->bulk_out_buffer)
kfree (port->bulk_out_buffer);
if (port->xfer_to_tty_buffer)
kfree (port->xfer_to_tty_buffer);
}
for (i = 0; i < num_interrupt_in; ++i)
{
port = &serial->port[i];
if (port->interrupt_in_urb)
usb_free_urb (port->interrupt_in_urb);
if (port->interrupt_in_buffer)
kfree (port->interrupt_in_buffer);
}
/* return the minor range that this device had */
return_serial (serial);
mydbg("Exit fail %s\n", __FUNCTION__);
/* free up any memory that we allocated */
kfree (serial);
return -EIO;
}
mydbg("Exit Success %s\n", __FUNCTION__);
usb_set_intfdata(interface, serial);
return 0;
probe_error:
for (i = 0; i < num_bulk_in; ++i) {
port = &serial->port[i];
if (port->read_urb)
usb_free_urb(port->read_urb);
if (port->bulk_in_buffer)
kfree(port->bulk_in_buffer);
}
for (i = 0; i < num_bulk_out; ++i) {
port = &serial->port[i];
if (port->write_urb)
usb_free_urb(port->write_urb);
if (port->bulk_out_buffer)
kfree(port->bulk_out_buffer);
if (port->xfer_to_tty_buffer)
kfree(port->xfer_to_tty_buffer);
}
for (i = 0; i < num_interrupt_in; ++i) {
port = &serial->port[i];
if (port->interrupt_in_urb)
usb_free_urb(port->interrupt_in_urb);
if (port->interrupt_in_buffer)
kfree(port->interrupt_in_buffer);
}
/* return the minor range that this device had */
return_serial(serial);
mydbg("Exit fail %s\n", __FUNCTION__);
/* free up any memory that we allocated */
kfree(serial);
return -EIO;
}
//returns the serial_table array pointers that are taken //returns the serial_table array pointers that are taken
//up in consecutive positions for each port to a common usb_serial structure //up in consecutive positions for each port to a common usb_serial structure
//back to NULL //back to NULL
static void return_serial(struct usb_serial *serial) static void return_serial(struct usb_serial *serial)
{ {
int i; int i;
mydbg("%s\n", __FUNCTION__); mydbg("%s\n", __FUNCTION__);
if (serial == NULL) if (serial == NULL)
return; return;
for (i = 0; i < serial->num_ports; ++i) for (i = 0; i < serial->num_ports; ++i) {
{ serial_table[serial->minor + i] = NULL;
serial_table[serial->minor + i] = NULL; }
}
return; return;
} }
//Finds the first locatio int the serial_table array where it can fit //Finds the first locatio int the serial_table array where it can fit
...@@ -820,808 +779,748 @@ static void return_serial(struct usb_serial *serial) ...@@ -820,808 +779,748 @@ static void return_serial(struct usb_serial *serial)
//,allocates a stucture points to it in all the structures, and returns the index //,allocates a stucture points to it in all the structures, and returns the index
//to the first location in the array in the "minor" variable. //to the first location in the array in the "minor" variable.
static struct usb_serial *get_free_serial (int num_ports, int *minor) static struct usb_serial *get_free_serial(int num_ports, int *minor)
{ {
struct usb_serial *serial = NULL; struct usb_serial *serial = NULL;
int i, j; int i, j;
int good_spot; int good_spot;
mydbg("%s %d\n", __FUNCTION__, num_ports); mydbg("%s %d\n", __FUNCTION__, num_ports);
*minor = 0; *minor = 0;
for (i = 0; i < SERIAL_TTY_MINORS; ++i) for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
{ if (serial_table[i])
if (serial_table[i]) continue;
continue;
good_spot = 1;
good_spot = 1; //find a spot in the array where you can fit consecutive positions
//find a spot in the array where you can fit consecutive positions //to put the pointers to the usb_serail allocated structure for all
//to put the pointers to the usb_serail allocated structure for all //the minor numbers (ie. ports)
//the minor numbers (ie. ports) for (j = 1; j <= num_ports - 1; ++j)
for (j = 1; j <= num_ports-1; ++j) if (serial_table[i + j])
if (serial_table[i+j]) good_spot = 0;
good_spot = 0; if (good_spot == 0)
if (good_spot == 0) continue;
continue;
if (!(serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL))) {
if (!(serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL))) err("%s - Out of memory", __FUNCTION__);
{ return NULL;
err("%s - Out of memory", __FUNCTION__); }
return NULL; memset(serial, 0, sizeof(struct usb_serial));
} serial_table[i] = serial;
memset(serial, 0, sizeof(struct usb_serial)); *minor = i;
serial_table[i] = serial; mydbg("%s - minor base = %d\n", __FUNCTION__, *minor);
*minor = i; //copy in the pointer into the array starting a the *minor position
mydbg("%s - minor base = %d\n", __FUNCTION__, *minor); //*minor is the index into the array
//copy in the pointer into the array starting a the *minor position for (i = *minor + 1;
//*minor is the index into the array (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
for (i = *minor+1; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) serial_table[i] = serial;
serial_table[i] = serial; return serial;
return serial; }
} return NULL;
return NULL;
} }
static int flip_that( struct tty_struct *tty, __u16 UartNumber, struct usb_serial *serial) static int flip_that(struct tty_struct *tty, __u16 UartNumber,
struct usb_serial *serial)
{ {
tty_flip_buffer_push(tty); tty_flip_buffer_push(tty);
tty_schedule_flip(tty); tty_schedule_flip(tty);
return 0; return 0;
} }
//Handles processing and moving data to the tty layer //Handles processing and moving data to the tty layer
static void port_sofrint(void *private) static void port_sofrint(void *private)
{ {
struct usb_serial_port *port = (struct usb_serial_port *)private; struct usb_serial_port *port = (struct usb_serial_port *)private;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
struct tty_struct *tty = port->tty; struct tty_struct *tty = port->tty;
unsigned char *data = port->read_urb->transfer_buffer; unsigned char *data = port->read_urb->transfer_buffer;
unsigned int UartNumber; unsigned int UartNumber;
struct urb *urb = port->read_urb; struct urb *urb = port->read_urb;
unsigned int RxCount = urb->actual_length; unsigned int RxCount = urb->actual_length;
int i, result; int i, result;
int flag, flag_data; int flag, flag_data;
//UartNumber = MINOR(port->tty->device) - serial->minor;
UartNumber = tty->index - serial->minor;
mydbg("%s - port %d\n", __FUNCTION__, port->number);
mydbg ("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
if (port_paranoia_check (port, __FUNCTION__) != 0) {
mydbg("%s - port_paranoia_check, exiting\n", __FUNCTION__);
port->ReadBulkStopped = 1;
return;
}
if (!serial) {
mydbg("%s - bad serial pointer, exiting\n", __FUNCTION__);
return;
}
if (port->closePending == 1) //Were closing , stop reading
{
mydbg("%s - (port->closepending == 1\n", __FUNCTION__);
port->ReadBulkStopped = 1;
return;
}
//RxHolding is asserted by throttle, if we assert it, we're not receiving any more
//characters and let the box handle the flow control
if (port->RxHolding == 1) {
port->ReadBulkStopped = 1;
return;
}
if (urb->status) {
port->ReadBulkStopped = 1;
mydbg("%s - nonzero read bulk status received: %d\n", __FUNCTION__, urb->status);
return;
}
tty = port->tty;
mydbg("%s - port %d, tty =0x%p\n", __FUNCTION__, port->number, tty);
if (tty && RxCount) {
flag_data = 0;
for (i = 0; i < RxCount ; ++i) {
//Look ahead code here
if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b) && (NEXTCHAR == 0x1b)) {
flag = 0;
switch (THIRDCHAR) {
case 0x00:
//Line status change 4th byte must follow
if (i > (RxCount - 4)) {
mydbg("Illegal escape sequences in received data\n");
break;
}
ProcessLineStatus(port, FOURTHCHAR);
i += 3;
flag = 1;
break;
case 0x01:
//Modem status status change 4th byte must follow
mydbg("Modem status status. \n");
if (i > (RxCount - 4)) {
mydbg("Illegal escape sequences in received data\n");
break;
}
ProcessModemStatus(port, FOURTHCHAR);
i += 3;
flag = 1;
break;
case 0xff:
mydbg("No status sequence. \n");
ProcessRxChar(port, THISCHAR);
ProcessRxChar(port, NEXTCHAR);
i += 2;
break;
}//end switch
if (flag == 1)
continue;
} //endif
if(tty && urb->actual_length) {
tty_buffer_request_room(tty, 1);
tty_insert_flip_string(tty, (data + i), 1);
}
}//endfor //UartNumber = MINOR(port->tty->device) - serial->minor;
UartNumber = tty->index - serial->minor;
tty_flip_buffer_push(tty); mydbg("%s - port %d\n", __FUNCTION__, port->number);
mydbg("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
}//endif if (port_paranoia_check(port, __FUNCTION__) != 0) {
mydbg("%s - port_paranoia_check, exiting\n", __FUNCTION__);
port->ReadBulkStopped = 1;
return;
}
/* Continue trying to always read */ if (!serial) {
usb_fill_bulk_urb (port->read_urb, serial->dev, mydbg("%s - bad serial pointer, exiting\n", __FUNCTION__);
usb_rcvbulkpipe (serial->dev, return;
port->bulk_in_endpointAddress), }
port->read_urb->transfer_buffer, if (port->closePending == 1) //Were closing , stop reading
port->read_urb->transfer_buffer_length, {
qt_read_bulk_callback, port); mydbg("%s - (port->closepending == 1\n", __FUNCTION__);
result = usb_submit_urb(port->read_urb, GFP_ATOMIC); port->ReadBulkStopped = 1;
if (result) return;
mydbg("%s - failed resubmitting read urb, error %d", __FUNCTION__, result); }
else //RxHolding is asserted by throttle, if we assert it, we're not receiving any more
{ //characters and let the box handle the flow control
if (tty && RxCount) if (port->RxHolding == 1) {
flip_that(tty, UartNumber, serial); port->ReadBulkStopped = 1;
} return;
}
if (urb->status) {
port->ReadBulkStopped = 1;
return; mydbg("%s - nonzero read bulk status received: %d\n",
__FUNCTION__, urb->status);
return;
}
} tty = port->tty;
mydbg("%s - port %d, tty =0x%p\n", __FUNCTION__, port->number, tty);
if (tty && RxCount) {
flag_data = 0;
for (i = 0; i < RxCount; ++i) {
//Look ahead code here
if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
&& (NEXTCHAR == 0x1b)) {
flag = 0;
switch (THIRDCHAR) {
case 0x00:
//Line status change 4th byte must follow
if (i > (RxCount - 4)) {
mydbg
("Illegal escape sequences in received data\n");
break;
}
ProcessLineStatus(port, FOURTHCHAR);
i += 3;
flag = 1;
break;
case 0x01:
//Modem status status change 4th byte must follow
mydbg("Modem status status. \n");
if (i > (RxCount - 4)) {
mydbg
("Illegal escape sequences in received data\n");
break;
}
ProcessModemStatus(port, FOURTHCHAR);
i += 3;
flag = 1;
break;
case 0xff:
mydbg("No status sequence. \n");
ProcessRxChar(port, THISCHAR);
ProcessRxChar(port, NEXTCHAR);
i += 2;
break;
} //end switch
if (flag == 1)
continue;
} //endif
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, 1);
tty_insert_flip_string(tty, (data + i), 1);
}
} //endfor
tty_flip_buffer_push(tty);
} //endif
/* Continue trying to always read */
usb_fill_bulk_urb(port->read_urb, serial->dev,
usb_rcvbulkpipe(serial->dev,
port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer,
port->read_urb->transfer_buffer_length,
qt_read_bulk_callback, port);
result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
if (result)
mydbg("%s - failed resubmitting read urb, error %d",
__FUNCTION__, result);
else {
if (tty && RxCount)
flip_that(tty, UartNumber, serial);
}
return;
}
static void qt_read_bulk_callback(struct urb *urb) static void qt_read_bulk_callback(struct urb *urb)
{ {
struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
if (urb->status) {
if (urb->status) port->ReadBulkStopped = 1;
{ mydbg("%s - nonzero write bulk status received: %d\n",
__FUNCTION__, urb->status);
port->ReadBulkStopped = 1; return;
mydbg("%s - nonzero write bulk status received: %d\n", __FUNCTION__, urb->status); }
return;
}
port_sofrint((void *) port); port_sofrint((void *)port);
schedule_work(&port->work); schedule_work(&port->work);
} }
static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data)
{
struct tty_struct *tty;
struct urb *urb = port->read_urb;
tty = port->tty;
/* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data){ if (tty && urb->actual_length) {
struct tty_struct *tty;
struct urb *urb = port->read_urb;
tty = port->tty;
/* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
if(tty && urb->actual_length)
{
tty_buffer_request_room(tty, 1); tty_buffer_request_room(tty, 1);
tty_insert_flip_string(tty, &Data, 1); tty_insert_flip_string(tty, &Data, 1);
//tty_flip_buffer_push(tty); //tty_flip_buffer_push(tty);
} }
return; return;
} }
static void ProcessLineStatus(struct usb_serial_port *port, unsigned char line_status){ static void ProcessLineStatus(struct usb_serial_port *port,
unsigned char line_status)
{
port->shadowLSR = line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | port->shadowLSR =
SERIAL_LSR_BI); line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
return; SERIAL_LSR_BI);
return;
} }
static void ProcessModemStatus(struct usb_serial_port *port,
unsigned char modem_status)
{
static void ProcessModemStatus(struct usb_serial_port *port, unsigned char modem_status){ port->shadowMSR = modem_status;
wake_up_interruptible(&port->wait);
port->shadowMSR = modem_status; return;
wake_up_interruptible(&port->wait);
return;
} }
static void serqt_usb_disconnect(struct usb_interface *interface)
{
struct usb_serial *serial = usb_get_intfdata(interface);
//struct device *dev = &interface->dev;
struct usb_serial_port *port;
int i;
mydbg("%s\n", __FUNCTION__);
if (serial) {
serial->dev = NULL;
for (i = 0; i < serial->num_ports; ++i)
serial->port[i].open_count = 0;
for (i = 0; i < serial->num_bulk_in; ++i) {
port = &serial->port[i];
if (port->read_urb) {
usb_unlink_urb(port->read_urb);
usb_free_urb(port->read_urb);
}
if (port->bulk_in_buffer)
kfree(port->bulk_in_buffer);
}
for (i = 0; i < serial->num_bulk_out; ++i) {
port = &serial->port[i];
if (port->write_urb) {
usb_unlink_urb(port->write_urb);
usb_free_urb(port->write_urb);
}
if (port->bulk_out_buffer)
kfree(port->bulk_out_buffer);
}
for (i = 0; i < serial->num_interrupt_in; ++i) {
port = &serial->port[i];
if (port->interrupt_in_urb) {
usb_unlink_urb(port->interrupt_in_urb);
usb_free_urb(port->interrupt_in_urb);
}
if (port->interrupt_in_buffer)
kfree(port->interrupt_in_buffer);
}
static void serqt_usb_disconnect(struct usb_interface *interface){ /* return the minor range that this device had */
struct usb_serial *serial = usb_get_intfdata (interface); return_serial(serial);
//struct device *dev = &interface->dev;
struct usb_serial_port *port;
int i;
mydbg ("%s\n", __FUNCTION__);
if (serial)
{
serial->dev = NULL;
for (i = 0; i < serial->num_ports; ++i)
serial->port[i].open_count = 0;
for (i = 0; i < serial->num_bulk_in; ++i)
{
port = &serial->port[i];
if (port->read_urb)
{
usb_unlink_urb (port->read_urb);
usb_free_urb (port->read_urb);
}
if (port->bulk_in_buffer)
kfree (port->bulk_in_buffer);
}
for (i = 0; i < serial->num_bulk_out; ++i)
{
port = &serial->port[i];
if (port->write_urb)
{
usb_unlink_urb (port->write_urb);
usb_free_urb (port->write_urb);
}
if (port->bulk_out_buffer)
kfree (port->bulk_out_buffer);
}
for (i = 0; i < serial->num_interrupt_in; ++i)
{
port = &serial->port[i];
if (port->interrupt_in_urb)
{
usb_unlink_urb (port->interrupt_in_urb);
usb_free_urb (port->interrupt_in_urb);
}
if (port->interrupt_in_buffer)
kfree (port->interrupt_in_buffer);
}
/* return the minor range that this device had */
return_serial (serial);
/* free up any memory that we allocated */
kfree (serial);
} else /* free up any memory that we allocated */
{ kfree(serial);
dev_info(&interface->dev, "device disconnected");
}
} else {
dev_info(&interface->dev, "device disconnected");
}
} }
static struct usb_serial *get_serial_by_minor(unsigned int minor)
static struct usb_serial *get_serial_by_minor (unsigned int minor)
{ {
return serial_table[minor]; return serial_table[minor];
} }
/***************************************************************************** /*****************************************************************************
* Driver tty interface functions * Driver tty interface functions
*****************************************************************************/ *****************************************************************************/
static int serial_open (struct tty_struct *tty, struct file * filp){ static int serial_open(struct tty_struct *tty, struct file *filp)
struct usb_serial *serial; {
struct usb_serial_port *port; struct usb_serial *serial;
unsigned int portNumber; struct usb_serial_port *port;
int retval = 0; unsigned int portNumber;
int retval = 0;
mydbg("%s\n", __FUNCTION__); mydbg("%s\n", __FUNCTION__);
/* initialize the pointer incase something fails */ /* initialize the pointer incase something fails */
tty->driver_data = NULL; tty->driver_data = NULL;
/* get the serial object associated with this tty pointer */ /* get the serial object associated with this tty pointer */
//serial = get_serial_by_minor (MINOR(tty->device)); //serial = get_serial_by_minor (MINOR(tty->device));
/* get the serial object associated with this tty pointer */ /* get the serial object associated with this tty pointer */
serial = get_serial_by_minor(tty->index); serial = get_serial_by_minor(tty->index);
if (serial_paranoia_check(serial, __FUNCTION__))
return -ENODEV;
if (serial_paranoia_check (serial, __FUNCTION__)) /* set up our port structure making the tty driver remember our port object, and us it */
return -ENODEV; portNumber = tty->index - serial->minor;
port = &serial->port[portNumber];
tty->driver_data = port;
/* set up our port structure making the tty driver remember our port object, and us it */
portNumber = tty->index - serial->minor;
port = &serial->port[portNumber];
tty->driver_data = port;
down (&port->sem);
port->tty = tty;
down(&port->sem);
port->tty = tty;
++port->open_count; ++port->open_count;
if (port->open_count == 1) if (port->open_count == 1) {
{ port->closePending = 0;
port->closePending = 0; mydbg("%s port->closepending = 0\n", __FUNCTION__);
mydbg("%s port->closepending = 0\n", __FUNCTION__);
port->RxHolding = 0; port->RxHolding = 0;
mydbg("%s port->RxHolding = 0\n", __FUNCTION__); mydbg("%s port->RxHolding = 0\n", __FUNCTION__);
retval = qt_open(port, filp); retval = qt_open(port, filp);
} }
if (retval) if (retval) {
{ port->open_count = 0;
port->open_count = 0; }
} mydbg("%s returning port->closePending = %d\n", __FUNCTION__,
mydbg("%s returning port->closePending = %d\n", __FUNCTION__, port->closePending); port->closePending);
up (&port->sem); up(&port->sem);
return retval; return retval;
} }
/***************************************************************************** /*****************************************************************************
*device's specific driver functions *device's specific driver functions
*****************************************************************************/ *****************************************************************************/
static int qt_open (struct usb_serial_port *port, struct file *filp){ static int qt_open(struct usb_serial_port *port, struct file *filp)
struct usb_serial *serial = port->serial; {
int result = 0; struct usb_serial *serial = port->serial;
unsigned int UartNumber; int result = 0;
struct qt_get_device_data DeviceData; unsigned int UartNumber;
struct qt_open_channel_data ChannelData; struct qt_get_device_data DeviceData;
unsigned short default_divisor = 0x30; //gives 9600 baud rate struct qt_open_channel_data ChannelData;
unsigned char default_LCR = SERIAL_8_DATA; // 8, none , 1 unsigned short default_divisor = 0x30; //gives 9600 baud rate
int status = 0; unsigned char default_LCR = SERIAL_8_DATA; // 8, none , 1
int status = 0;
if (port_paranoia_check (port, __FUNCTION__))
return -ENODEV;
mydbg("%s - port %d\n", __FUNCTION__, port->number);
/* force low_latency on so that our tty_push actually forces the data through,
otherwise it is scheduled, and with high data rates (like with OHCI) data
can get lost. */
if (port->tty)
port->tty->low_latency = 0;
UartNumber = port->tty->index - serial->minor;
status = box_get_device(serial, &DeviceData); if (port_paranoia_check(port, __FUNCTION__))
if (status < 0) return -ENODEV;
{
mydbg(__FILE__"box_get_device failed\n");
return status;
}
serial->num_OpenCount++;
mydbg("%s serial->num_OpenCount = %d\n", __FUNCTION__, serial->num_OpenCount);
//Open uart channel
//Port specific setups mydbg("%s - port %d\n", __FUNCTION__, port->number);
status = BoxOPenCloseChannel(serial, UartNumber, 1, &ChannelData);
if (status < 0)
{
mydbg(__FILE__"BoxOPenCloseChannel failed\n");
return status;
}
mydbg(__FILE__"BoxOPenCloseChannel completed.\n");
port->shadowLSR = ChannelData.line_status & /* force low_latency on so that our tty_push actually forces the data through,
(SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI); otherwise it is scheduled, and with high data rates (like with OHCI) data
can get lost. */
if (port->tty)
port->tty->low_latency = 0;
port->shadowMSR = ChannelData.modem_status & UartNumber = port->tty->index - serial->minor;
(SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
status = box_get_device(serial, &DeviceData);
if (status < 0) {
mydbg(__FILE__ "box_get_device failed\n");
return status;
}
serial->num_OpenCount++;
mydbg("%s serial->num_OpenCount = %d\n", __FUNCTION__,
serial->num_OpenCount);
//Open uart channel
//Port specific setups
status = BoxOPenCloseChannel(serial, UartNumber, 1, &ChannelData);
if (status < 0) {
mydbg(__FILE__ "BoxOPenCloseChannel failed\n");
return status;
}
mydbg(__FILE__ "BoxOPenCloseChannel completed.\n");
//Set Baud rate to default and turn off (default)flow control here port->shadowLSR = ChannelData.line_status &
status = BoxSetUart(serial, UartNumber, default_divisor, default_LCR); (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
if (status < 0)
{
mydbg(__FILE__"BoxSetUart failed\n");
return status;
}
mydbg(__FILE__"BoxSetUart completed.\n");
port->shadowMSR = ChannelData.modem_status &
(SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
//Put this here to make it responsive to stty and defauls set by the tty layer //Set Baud rate to default and turn off (default)flow control here
qt_set_termios(port, NULL); status = BoxSetUart(serial, UartNumber, default_divisor, default_LCR);
if (status < 0) {
mydbg(__FILE__ "BoxSetUart failed\n");
return status;
}
mydbg(__FILE__ "BoxSetUart completed.\n");
//Put this here to make it responsive to stty and defauls set by the tty layer
qt_set_termios(port, NULL);
//Initialize the wait que head //Initialize the wait que head
init_waitqueue_head(&(port->wait)); init_waitqueue_head(&(port->wait));
/* if we have a bulk endpoint, start reading from it */ /* if we have a bulk endpoint, start reading from it */
if (serial->num_bulk_in) if (serial->num_bulk_in) {
{ /* Start reading from the device */
/* Start reading from the device */ usb_fill_bulk_urb(port->read_urb, serial->dev,
usb_fill_bulk_urb (port->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev,
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), port->
port->read_urb->transfer_buffer, bulk_in_endpointAddress),
port->read_urb->transfer_buffer_length, port->read_urb->transfer_buffer,
qt_read_bulk_callback, port->read_urb->transfer_buffer_length,
port); qt_read_bulk_callback, port);
port->ReadBulkStopped = 0; port->ReadBulkStopped = 0;
result = usb_submit_urb(port->read_urb, GFP_ATOMIC); result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
if (result) if (result) {
{ err("%s - failed resubmitting read urb, error %d\n",
err("%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result); __FUNCTION__, result);
port->ReadBulkStopped = 1; port->ReadBulkStopped = 1;
} }
} }
return result; return result;
} }
static void serial_close(struct tty_struct *tty, struct file * filp){ static void serial_close(struct tty_struct *tty, struct file *filp)
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; {
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct usb_serial_port *port =
(struct usb_serial_port *)tty->driver_data;
if (!serial) struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
return;
down (&port->sem); if (!serial)
return;
mydbg("%s - port %d\n", __FUNCTION__, port->number); down(&port->sem);
/* if disconnect beat us to the punch here, there's nothing to do */ mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (tty->driver_data)
{
if (!port->open_count)
{
mydbg ("%s - port not opened\n", __FUNCTION__);
goto exit;
}
--port->open_count; /* if disconnect beat us to the punch here, there's nothing to do */
if (port->open_count <= 0) if (tty->driver_data) {
{ if (!port->open_count) {
port->closePending = 1; mydbg("%s - port not opened\n", __FUNCTION__);
mydbg ("%s - port->closePending = 1\n", __FUNCTION__); goto exit;
}
if (serial->dev) --port->open_count;
{ if (port->open_count <= 0) {
qt_close(port, filp); port->closePending = 1;
port->open_count = 0; mydbg("%s - port->closePending = 1\n", __FUNCTION__);
}
}
} if (serial->dev) {
qt_close(port, filp);
port->open_count = 0;
}
}
exit: }
up (&port->sem);
mydbg("%s - %d return\n", __FUNCTION__, port->number); exit:
up(&port->sem);
mydbg("%s - %d return\n", __FUNCTION__, port->number);
} }
static void qt_close (struct usb_serial_port *port, struct file *filp){ static void qt_close(struct usb_serial_port *port, struct file *filp)
unsigned long jift = jiffies + 10 * HZ; {
__u8 LSR_Value, MCR_Value; unsigned long jift = jiffies + 10 * HZ;
struct usb_serial *serial = port->serial; __u8 LSR_Value, MCR_Value;
int status; struct usb_serial *serial = port->serial;
unsigned int UartNumber; int status;
unsigned int UartNumber;
struct qt_open_channel_data ChannelData;
status = 0;
LSR_Value = 0;
mydbg("%s - port %d\n", __FUNCTION__, port->number);
UartNumber = port->tty->index - serial->minor;
/* shutdown any bulk reads that might be going on */
if (serial->num_bulk_out)
usb_unlink_urb (port->write_urb);
if (serial->num_bulk_in)
usb_unlink_urb (port->read_urb);
//wait up to 30 seconds for transmitter to empty
do
{
status = BoxGetRegister(serial, UartNumber, LINE_STATUS_REGISTER, &LSR_Value);
if (status < 0)
{
mydbg(__FILE__"box_get_device failed\n");
break;
}
if ((LSR_Value & SERIAL_LSR_TEMT) && (port->ReadBulkStopped == 1))
break;
schedule();
}
while (jiffies <= jift);
if(jiffies > jift)
mydbg("%s - port %d timout of checking transmitter empty\n", __FUNCTION__, port->number);
else
mydbg("%s - port %d checking transmitter empty succeded\n", __FUNCTION__, port->number);
struct qt_open_channel_data ChannelData;
status = 0;
LSR_Value = 0;
status = BoxGetRegister(serial, UartNumber, MODEM_CONTROL_REGISTER, &MCR_Value); mydbg("%s - port %d\n", __FUNCTION__, port->number);
mydbg(__FILE__"BoxGetRegister MCR = 0x%x.\n", MCR_Value); UartNumber = port->tty->index - serial->minor;
/* shutdown any bulk reads that might be going on */
if (serial->num_bulk_out)
usb_unlink_urb(port->write_urb);
if (serial->num_bulk_in)
usb_unlink_urb(port->read_urb);
//wait up to 30 seconds for transmitter to empty
do {
status =
BoxGetRegister(serial, UartNumber, LINE_STATUS_REGISTER,
&LSR_Value);
if (status < 0) {
mydbg(__FILE__ "box_get_device failed\n");
break;
}
if ((LSR_Value & SERIAL_LSR_TEMT)
&& (port->ReadBulkStopped == 1))
break;
schedule();
if (status >= 0) }
{ while (jiffies <= jift);
MCR_Value &= ~(SERIAL_MCR_DTR | SERIAL_MCR_RTS);
if (jiffies > jift)
mydbg("%s - port %d timout of checking transmitter empty\n",
__FUNCTION__, port->number);
else
mydbg("%s - port %d checking transmitter empty succeded\n",
__FUNCTION__, port->number);
status =
BoxGetRegister(serial, UartNumber, MODEM_CONTROL_REGISTER,
&MCR_Value);
mydbg(__FILE__ "BoxGetRegister MCR = 0x%x.\n", MCR_Value);
if (status >= 0) {
MCR_Value &= ~(SERIAL_MCR_DTR | SERIAL_MCR_RTS);
// status = BoxSetRegister(serial, UartNumber, MODEM_CONTROL_REGISTER, MCR_Value); // status = BoxSetRegister(serial, UartNumber, MODEM_CONTROL_REGISTER, MCR_Value);
} }
//Close uart channel
status = BoxOPenCloseChannel(serial, UartNumber, 0, &ChannelData);
if(status < 0)
mydbg("%s - port %d BoxOPenCloseChannel failed.\n", __FUNCTION__, port->number);
serial->num_OpenCount--; //Close uart channel
status = BoxOPenCloseChannel(serial, UartNumber, 0, &ChannelData);
if (status < 0)
mydbg("%s - port %d BoxOPenCloseChannel failed.\n",
__FUNCTION__, port->number);
serial->num_OpenCount--;
} }
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
int count)
static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial; (struct usb_serial_port *)tty->driver_data;
int retval = -EINVAL; struct usb_serial *serial;
unsigned int UartNumber; int retval = -EINVAL;
int from_user = 0; unsigned int UartNumber;
int from_user = 0;
serial = get_usb_serial (port, __FUNCTION__);
if(serial == NULL)
return -ENODEV;
//This can happen if we get disconnected a
if (port->open_count == 0)
{
return -ENODEV;
}
UartNumber = port->tty->index - serial->minor;
mydbg("%s - port %d, %d byte(s)\n", __FUNCTION__, port->number, count);
mydbg("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
if (!port->open_count)
{
mydbg("%s - port not opened\n", __FUNCTION__);
goto exit;
}
retval = qt_write(port, from_user, buf, count);
exit:
return retval;
}
static int qt_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count){
int result;
unsigned int UartNumber;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
if(serial == NULL)
return -ENODEV;
serial = get_usb_serial(port, __FUNCTION__);
if (serial == NULL)
return -ENODEV;
//This can happen if we get disconnected a
if (port->open_count == 0) {
return -ENODEV;
}
UartNumber = port->tty->index - serial->minor;
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d, %d byte(s)\n", __FUNCTION__, port->number, count);
mydbg("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
if (count == 0) if (!port->open_count) {
{ mydbg("%s - port not opened\n", __FUNCTION__);
mydbg("%s - write request of 0 bytes\n", __FUNCTION__); goto exit;
return(0); }
}
retval = qt_write(port, from_user, buf, count);
UartNumber = port->tty->index - serial->minor; exit:
/* only do something if we have a bulk out endpoint */ return retval;
if (serial->num_bulk_out) }
{
if (port->write_urb->status == -EINPROGRESS)
{
mydbg("%s - already writing\n", __FUNCTION__);
return(0);
}
count = (count > port->bulk_out_size) ? port->bulk_out_size : count; static int qt_write(struct usb_serial_port *port, int from_user,
const unsigned char *buf, int count)
{
int result;
unsigned int UartNumber;
if (from_user) struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
{ if (serial == NULL)
if (copy_from_user(port->write_urb->transfer_buffer, buf, count)) return -ENODEV;
return -EFAULT;
} else
{
memcpy (port->write_urb->transfer_buffer, buf, count);
}
//usb_serial_debug_data(__FILE__, __FUNCTION__, count, port->write_urb->transfer_buffer); mydbg("%s - port %d\n", __FUNCTION__, port->number);
/* set up our urb */ if (count == 0) {
mydbg("%s - write request of 0 bytes\n", __FUNCTION__);
return (0);
}
UartNumber = port->tty->index - serial->minor;
/* only do something if we have a bulk out endpoint */
if (serial->num_bulk_out) {
if (port->write_urb->status == -EINPROGRESS) {
mydbg("%s - already writing\n", __FUNCTION__);
return (0);
}
usb_fill_bulk_urb (port->write_urb, serial->dev, count =
usb_sndbulkpipe (serial->dev, (count > port->bulk_out_size) ? port->bulk_out_size : count;
port->bulk_out_endpointAddress),
port->write_urb->transfer_buffer, count,
qt_write_bulk_callback, port);
if (from_user) {
if (copy_from_user
(port->write_urb->transfer_buffer, buf, count))
return -EFAULT;
} else {
memcpy(port->write_urb->transfer_buffer, buf, count);
}
//usb_serial_debug_data(__FILE__, __FUNCTION__, count, port->write_urb->transfer_buffer);
/* set up our urb */
usb_fill_bulk_urb(port->write_urb, serial->dev,
usb_sndbulkpipe(serial->dev,
port->
bulk_out_endpointAddress),
port->write_urb->transfer_buffer, count,
qt_write_bulk_callback, port);
/* send the data out the bulk port */ /* send the data out the bulk port */
result = usb_submit_urb(port->write_urb, GFP_ATOMIC); result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
if (result) if (result)
mydbg("%s - failed submitting write urb, error %d\n", __FUNCTION__, result); mydbg("%s - failed submitting write urb, error %d\n",
else __FUNCTION__, result);
result = count; else
result = count;
return result; return result;
} }
/* no bulk out, so return 0 bytes written */ /* no bulk out, so return 0 bytes written */
return(0); return (0);
} }
static void qt_write_bulk_callback(struct urb *urb) static void qt_write_bulk_callback(struct urb *urb)
{ {
struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (!serial)
{
mydbg("%s - bad serial pointer, exiting\n", __FUNCTION__);
return;
}
if (urb->status)
{
mydbg("%s - nonzero write bulk status received: %d\n", __FUNCTION__, urb->status);
return;
}
//
port_softint(&port->work);
schedule_work(&port->work);
return;
}
static void port_softint(struct work_struct *work) mydbg("%s - port %d\n", __FUNCTION__, port->number);
{
struct usb_serial_port *port =
container_of(work, struct usb_serial_port, work);
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
struct tty_struct *tty;
if (!serial) {
mydbg("%s - bad serial pointer, exiting\n", __FUNCTION__);
return;
}
mydbg("%s - port %d\n", __FUNCTION__, port->number); if (urb->status) {
mydbg("%s - nonzero write bulk status received: %d\n",
__FUNCTION__, urb->status);
return;
}
//
port_softint(&port->work);
schedule_work(&port->work);
return;
}
static void port_softint(struct work_struct *work)
{
struct usb_serial_port *port =
container_of(work, struct usb_serial_port, work);
struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
struct tty_struct *tty;
if (!serial) mydbg("%s - port %d\n", __FUNCTION__, port->number);
return;
if (!serial)
return;
tty = port->tty; tty = port->tty;
if (!tty) if (!tty)
return; return;
#if 0 #if 0
if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP))
{ && tty->ldisc.write_wakeup) {
mydbg("%s - write wakeup call.\n", __FUNCTION__); mydbg("%s - write wakeup call.\n", __FUNCTION__);
(tty->ldisc.write_wakeup)(tty); (tty->ldisc.write_wakeup) (tty);
} }
#endif #endif
wake_up_interruptible(&tty->write_wait); wake_up_interruptible(&tty->write_wait);
} }
static int serial_write_room (struct tty_struct *tty) static int serial_write_room(struct tty_struct *tty)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
int retval = -EINVAL; struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
int retval = -EINVAL;
if (!serial) if (!serial)
return -ENODEV; return -ENODEV;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (!port->open_count) if (!port->open_count) {
{ mydbg("%s - port not open\n", __FUNCTION__);
mydbg("%s - port not open\n", __FUNCTION__); goto exit;
goto exit; }
}
retval = qt_write_room(port); retval = qt_write_room(port);
exit: exit:
up (&port->sem); up(&port->sem);
return retval; return retval;
} }
static int qt_write_room (struct usb_serial_port *port) static int qt_write_room(struct usb_serial_port *port)
{ {
struct usb_serial *serial = port->serial; struct usb_serial *serial = port->serial;
int room = 0; int room = 0;
if (port->closePending == 1) if (port->closePending == 1) {
{ mydbg("%s - port->closePending == 1\n", __FUNCTION__);
mydbg("%s - port->closePending == 1\n", __FUNCTION__); return -ENODEV;
return -ENODEV; }
}
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (serial->num_bulk_out) if (serial->num_bulk_out) {
{ if (port->write_urb->status != -EINPROGRESS)
if (port->write_urb->status != -EINPROGRESS) room = port->bulk_out_size;
room = port->bulk_out_size; }
}
mydbg("%s - returns %d\n", __FUNCTION__, room); mydbg("%s - returns %d\n", __FUNCTION__, room);
return(room); return (room);
} }
static int serial_chars_in_buffer (struct tty_struct *tty) static int serial_chars_in_buffer(struct tty_struct *tty)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
int retval = -EINVAL; int retval = -EINVAL;
if (!serial) if (!serial)
return -ENODEV; return -ENODEV;
down (&port->sem); down(&port->sem);
mydbg("%s = port %d\n", __FUNCTION__, port->number); mydbg("%s = port %d\n", __FUNCTION__, port->number);
...@@ -1633,275 +1532,267 @@ static int serial_chars_in_buffer (struct tty_struct *tty) ...@@ -1633,275 +1532,267 @@ static int serial_chars_in_buffer (struct tty_struct *tty)
retval = qt_chars_in_buffer(port); retval = qt_chars_in_buffer(port);
exit: exit:
up (&port->sem); up(&port->sem);
return retval; return retval;
} }
static int qt_chars_in_buffer(struct usb_serial_port *port)
static int qt_chars_in_buffer (struct usb_serial_port *port)
{ {
struct usb_serial *serial = port->serial; struct usb_serial *serial = port->serial;
int chars = 0; int chars = 0;
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (serial->num_bulk_out) if (serial->num_bulk_out) {
{ if (port->write_urb->status == -EINPROGRESS)
if (port->write_urb->status == -EINPROGRESS) chars = port->write_urb->transfer_buffer_length;
chars = port->write_urb->transfer_buffer_length; }
}
mydbg("%s - returns %d\n", __FUNCTION__, chars); mydbg("%s - returns %d\n", __FUNCTION__, chars);
return(chars); return (chars);
} }
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
static int serial_tiocmset (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear) unsigned int set, unsigned int clear)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
int retval = -ENODEV; struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
unsigned int UartNumber; int retval = -ENODEV;
mydbg("In %s \n", __FUNCTION__); unsigned int UartNumber;
mydbg("In %s \n", __FUNCTION__);
if (!serial)
return -ENODEV;
if (!serial)
return -ENODEV;
UartNumber = port->tty->index - serial->minor; UartNumber = port->tty->index - serial->minor;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d \n", __FUNCTION__, port->number); mydbg("%s - port %d \n", __FUNCTION__, port->number);
mydbg ("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding); mydbg("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
if (!port->open_count) if (!port->open_count) {
{ mydbg("%s - port not open\n", __FUNCTION__);
mydbg ("%s - port not open\n", __FUNCTION__); goto exit;
goto exit; }
}
retval = qt_tiocmset(port, file, set); retval = qt_tiocmset(port, file, set);
exit: exit:
up (&port->sem); up(&port->sem);
return retval; return retval;
} }
static int qt_tiocmset(struct usb_serial_port *port, struct file *file,
static int qt_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int value) unsigned int value)
{ {
__u8 MCR_Value; __u8 MCR_Value;
int status; int status;
unsigned int UartNumber; unsigned int UartNumber;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
if(serial == NULL) if (serial == NULL)
return -ENODEV; return -ENODEV;
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
/**************************************************************************************/ /**************************************************************************************/
/** TIOCMGET /** TIOCMGET
*/ */
UartNumber = port->tty->index - serial->minor; UartNumber = port->tty->index - serial->minor;
status = BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER, &MCR_Value); status =
if (status < 0) BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER,
return -ESPIPE; &MCR_Value);
if (status < 0)
//Turn off the RTS and DTR and loopbcck and then only return -ESPIPE;
//trun on what was asked for
MCR_Value &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP); //Turn off the RTS and DTR and loopbcck and then only
if (value & TIOCM_RTS) //trun on what was asked for
MCR_Value |= SERIAL_MCR_RTS; MCR_Value &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
if (value & TIOCM_DTR) if (value & TIOCM_RTS)
MCR_Value |= SERIAL_MCR_DTR; MCR_Value |= SERIAL_MCR_RTS;
if (value & TIOCM_LOOP) if (value & TIOCM_DTR)
MCR_Value |= SERIAL_MCR_LOOP; MCR_Value |= SERIAL_MCR_DTR;
if (value & TIOCM_LOOP)
status = BoxSetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER, MCR_Value); MCR_Value |= SERIAL_MCR_LOOP;
if (status < 0)
return -ESPIPE; status =
else BoxSetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER,
return 0; MCR_Value);
if (status < 0)
return -ESPIPE;
else
return 0;
} }
static int serial_tiocmget(struct tty_struct *tty, struct file *file) static int serial_tiocmget(struct tty_struct *tty, struct file *file)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
(struct usb_serial_port *)tty->driver_data;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
int retval = -ENODEV; int retval = -ENODEV;
unsigned int UartNumber; unsigned int UartNumber;
mydbg("In %s \n", __FUNCTION__); mydbg("In %s \n", __FUNCTION__);
if (!serial) if (!serial)
return -ENODEV; return -ENODEV;
UartNumber = port->tty->index - serial->minor;
UartNumber = port->tty->index - serial->minor;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
mydbg ("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding); mydbg("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
if (!port->open_count) if (!port->open_count) {
{ mydbg("%s - port not open\n", __FUNCTION__);
mydbg ("%s - port not open\n", __FUNCTION__); goto exit;
goto exit; }
}
retval = qt_tiocmget(port, file); retval = qt_tiocmget(port, file);
exit: exit:
up (&port->sem); up(&port->sem);
return retval; return retval;
} }
static int qt_tiocmget(struct usb_serial_port *port, struct file *file)
static int qt_tiocmget(struct usb_serial_port *port, struct file * file)
{ {
__u8 MCR_Value; __u8 MCR_Value;
__u8 MSR_Value; __u8 MSR_Value;
unsigned int result = 0; unsigned int result = 0;
int status; int status;
unsigned int UartNumber; unsigned int UartNumber;
struct tty_struct * tty; struct tty_struct *tty;
struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
if (serial == NULL)
return -ENODEV;
tty = port->tty;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); mydbg("%s - port %d, tty =0x%p\n", __FUNCTION__, port->number, tty);
if(serial == NULL)
return -ENODEV;
tty = port->tty;
mydbg("%s - port %d, tty =0x%p\n", __FUNCTION__, port->number, tty);
/**************************************************************************************/ /**************************************************************************************/
/** TIOCMGET /** TIOCMGET
*/ */
UartNumber = port->tty->index - serial->minor; UartNumber = port->tty->index - serial->minor;
status = BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER, &MCR_Value); status =
if (status >= 0) BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER,
{ &MCR_Value);
status = BoxGetRegister(port->serial, UartNumber, MODEM_STATUS_REGISTER, &MSR_Value); if (status >= 0) {
status =
} BoxGetRegister(port->serial, UartNumber,
MODEM_STATUS_REGISTER, &MSR_Value);
if (status >= 0)
{
result = ((MCR_Value & SERIAL_MCR_DTR) ? TIOCM_DTR: 0)
//DTR IS SET
| ((MCR_Value & SERIAL_MCR_RTS) ? TIOCM_RTS: 0)
//RTS IS SET
| ((MSR_Value & SERIAL_MSR_CTS) ? TIOCM_CTS: 0)
//CTS is set
| ((MSR_Value & SERIAL_MSR_CD) ? TIOCM_CAR: 0)
//Carrier detect is set
| ((MSR_Value & SERIAL_MSR_RI) ? TIOCM_RI: 0)
//Ring indicator set
| ((MSR_Value & SERIAL_MSR_DSR) ? TIOCM_DSR: 0);
//DSR is set
return result;
}
else
return -ESPIPE;
//endif tatus => 0
}
}
static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg) if (status >= 0) {
{ result = ((MCR_Value & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
//DTR IS SET
| ((MCR_Value & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
//RTS IS SET
| ((MSR_Value & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
//CTS is set
| ((MSR_Value & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
//Carrier detect is set
| ((MSR_Value & SERIAL_MSR_RI) ? TIOCM_RI : 0)
//Ring indicator set
| ((MSR_Value & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
//DSR is set
return result;
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; } else
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); return -ESPIPE;
int retval = -ENODEV; //endif tatus => 0
unsigned int UartNumber; }
mydbg("In %s \n", __FUNCTION__);
if (!serial) static int serial_ioctl(struct tty_struct *tty, struct file *file,
return -ENODEV; unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port =
(struct usb_serial_port *)tty->driver_data;
struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
int retval = -ENODEV;
unsigned int UartNumber;
mydbg("In %s \n", __FUNCTION__);
UartNumber = port->tty->index - serial->minor; if (!serial)
return -ENODEV;
UartNumber = port->tty->index - serial->minor;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d, cmd 0x%.4x\n", __FUNCTION__, port->number, cmd); mydbg("%s - port %d, cmd 0x%.4x\n", __FUNCTION__, port->number, cmd);
mydbg ("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding); mydbg("%s - port->RxHolding = %d\n", __FUNCTION__, port->RxHolding);
if (!port->open_count) if (!port->open_count) {
{ mydbg("%s - port not open\n", __FUNCTION__);
mydbg ("%s - port not open\n", __FUNCTION__); goto exit;
goto exit; }
}
retval = qt_ioctl(port, file, cmd, arg); retval = qt_ioctl(port, file, cmd, arg);
exit: exit:
up (&port->sem); up(&port->sem);
return retval; return retval;
} }
static int qt_ioctl(struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg) static int qt_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg)
{ {
__u8 MCR_Value; __u8 MCR_Value;
__u8 MSR_Value; __u8 MSR_Value;
unsigned short Prev_MSR_Value; unsigned short Prev_MSR_Value;
unsigned int value, result = 0; unsigned int value, result = 0;
int status; int status;
unsigned int UartNumber; unsigned int UartNumber;
struct tty_struct * tty; struct tty_struct *tty;
struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); if (serial == NULL)
if(serial == NULL) return -ENODEV;
return -ENODEV; tty = port->tty;
tty = port->tty;
mydbg("%s - port %d, tty =0x%p\n", __FUNCTION__, port->number, tty); mydbg("%s - port %d, tty =0x%p\n", __FUNCTION__, port->number, tty);
/**************************************************************************************/ /**************************************************************************************/
/** TIOCMGET /** TIOCMGET
*/ */
UartNumber = port->tty->index - serial->minor; UartNumber = port->tty->index - serial->minor;
if(cmd == TIOCMGET) if (cmd == TIOCMGET) {
{ MCR_Value = port->shadowMCR;
MCR_Value = port->shadowMCR; MSR_Value = port->shadowMSR;
MSR_Value = port->shadowMSR;
{
{ result = ((MCR_Value & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
result = ((MCR_Value & SERIAL_MCR_DTR) ? TIOCM_DTR: 0) //DTR IS SET
//DTR IS SET | ((MCR_Value & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
| ((MCR_Value & SERIAL_MCR_RTS) ? TIOCM_RTS: 0) //RTS IS SET
//RTS IS SET | ((MSR_Value & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
| ((MSR_Value & SERIAL_MSR_CTS) ? TIOCM_CTS: 0) //CTS is set
//CTS is set | ((MSR_Value & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
| ((MSR_Value & SERIAL_MSR_CD) ? TIOCM_CAR: 0) //Carrier detect is set
//Carrier detect is set | ((MSR_Value & SERIAL_MSR_RI) ? TIOCM_RI : 0)
| ((MSR_Value & SERIAL_MSR_RI) ? TIOCM_RI: 0) //Ring indicator set
//Ring indicator set | ((MSR_Value & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
| ((MSR_Value & SERIAL_MSR_DSR) ? TIOCM_DSR: 0); //DSR is set
//DSR is set if (copy_to_user
if(copy_to_user((unsigned int *)arg, &result, sizeof(unsigned int))) ((unsigned int *)arg, &result,
return -EFAULT; sizeof(unsigned int)))
return 0; return -EFAULT;
return 0;
}//endif tatus => 0
} //endif tatus => 0
}//endif(cmd == TIOCMGET)
} //endif(cmd == TIOCMGET)
/**************************************************************************************/ /**************************************************************************************/
/** End TIOCMGET /** End TIOCMGET
*/ */
...@@ -1910,110 +1801,115 @@ static int qt_ioctl(struct usb_serial_port *port, struct file * file, unsigned i ...@@ -1910,110 +1801,115 @@ static int qt_ioctl(struct usb_serial_port *port, struct file * file, unsigned i
/**************************************************************************************/ /**************************************************************************************/
if(cmd == TIOCMBIS || cmd == TIOCMBIC || cmd == TIOCMSET) if (cmd == TIOCMBIS || cmd == TIOCMBIC || cmd == TIOCMSET) {
{ status =
status = BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER, &MCR_Value); BoxGetRegister(port->serial, UartNumber,
if (status < 0) MODEM_CONTROL_REGISTER, &MCR_Value);
return -ESPIPE; if (status < 0)
if (copy_from_user(&value, (unsigned int *)arg, sizeof(unsigned int))) return -ESPIPE;
return -EFAULT; if (copy_from_user
(&value, (unsigned int *)arg, sizeof(unsigned int)))
switch (cmd) return -EFAULT;
{
case TIOCMBIS: switch (cmd) {
if (value & TIOCM_RTS) case TIOCMBIS:
MCR_Value |= SERIAL_MCR_RTS; if (value & TIOCM_RTS)
if (value & TIOCM_DTR) MCR_Value |= SERIAL_MCR_RTS;
MCR_Value |= SERIAL_MCR_DTR; if (value & TIOCM_DTR)
if (value & TIOCM_LOOP) MCR_Value |= SERIAL_MCR_DTR;
MCR_Value |= SERIAL_MCR_LOOP; if (value & TIOCM_LOOP)
break; MCR_Value |= SERIAL_MCR_LOOP;
case TIOCMBIC: break;
if (value & TIOCM_RTS) case TIOCMBIC:
MCR_Value &= ~SERIAL_MCR_RTS; if (value & TIOCM_RTS)
if (value & TIOCM_DTR) MCR_Value &= ~SERIAL_MCR_RTS;
MCR_Value &= ~SERIAL_MCR_DTR; if (value & TIOCM_DTR)
if (value & TIOCM_LOOP) MCR_Value &= ~SERIAL_MCR_DTR;
MCR_Value &= ~SERIAL_MCR_LOOP; if (value & TIOCM_LOOP)
break; MCR_Value &= ~SERIAL_MCR_LOOP;
case TIOCMSET: break;
//Turn off the RTS and DTR and loopbcck and then only case TIOCMSET:
//trun on what was asked for //Turn off the RTS and DTR and loopbcck and then only
MCR_Value &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP); //trun on what was asked for
if (value & TIOCM_RTS) MCR_Value &=
MCR_Value |= SERIAL_MCR_RTS; ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR |
if (value & TIOCM_DTR) SERIAL_MCR_LOOP);
MCR_Value |= SERIAL_MCR_DTR; if (value & TIOCM_RTS)
if (value & TIOCM_LOOP) MCR_Value |= SERIAL_MCR_RTS;
MCR_Value |= SERIAL_MCR_LOOP; if (value & TIOCM_DTR)
break; MCR_Value |= SERIAL_MCR_DTR;
default: if (value & TIOCM_LOOP)
break; MCR_Value |= SERIAL_MCR_LOOP;
break;
} default:
status = BoxSetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER, MCR_Value); break;
if (status < 0)
return -ESPIPE; }
else status =
{ BoxSetRegister(port->serial, UartNumber,
port->shadowMCR = MCR_Value; MODEM_CONTROL_REGISTER, MCR_Value);
return 0; if (status < 0)
} return -ESPIPE;
else {
port->shadowMCR = MCR_Value;
} return 0;
}
}
/**************************************************************************************/ /**************************************************************************************/
/** TIOCMBIS, TIOCMBIC, AND TIOCMSET end /** TIOCMBIS, TIOCMBIC, AND TIOCMSET end
*/ */
/**************************************************************************************/ /**************************************************************************************/
if(cmd == TIOCMIWAIT) if (cmd == TIOCMIWAIT) {
{ DECLARE_WAITQUEUE(wait, current);
DECLARE_WAITQUEUE(wait, current); Prev_MSR_Value = port->shadowMSR & SERIAL_MSR_MASK;
Prev_MSR_Value = port->shadowMSR & SERIAL_MSR_MASK; while (1) {
while(1) add_wait_queue(&port->wait, &wait);
{ set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&port->wait, &wait); schedule();
set_current_state(TASK_INTERRUPTIBLE); remove_wait_queue(&port->wait, &wait);
schedule(); /* see if a signal woke us up */
remove_wait_queue(&port->wait, &wait); if (signal_pending(current))
/* see if a signal woke us up */ return -ERESTARTSYS;
if(signal_pending(current)) MSR_Value = port->shadowMSR & SERIAL_MSR_MASK;
return -ERESTARTSYS; if (MSR_Value == Prev_MSR_Value)
MSR_Value = port->shadowMSR & SERIAL_MSR_MASK; return -EIO; //no change error
if(MSR_Value == Prev_MSR_Value)
return -EIO; //no change error if ((arg & TIOCM_RNG
&& ((Prev_MSR_Value & SERIAL_MSR_RI) ==
if((arg & TIOCM_RNG && ((Prev_MSR_Value & SERIAL_MSR_RI) == (MSR_Value & SERIAL_MSR_RI)))
(MSR_Value & SERIAL_MSR_RI))) || || (arg & TIOCM_DSR
(arg & TIOCM_DSR && ((Prev_MSR_Value & SERIAL_MSR_DSR) == && ((Prev_MSR_Value & SERIAL_MSR_DSR) ==
(MSR_Value & SERIAL_MSR_DSR))) || (MSR_Value & SERIAL_MSR_DSR)))
(arg & TIOCM_CD && ((Prev_MSR_Value & SERIAL_MSR_CD) == || (arg & TIOCM_CD
(MSR_Value & SERIAL_MSR_CD))) || && ((Prev_MSR_Value & SERIAL_MSR_CD) ==
(arg & TIOCM_CTS && ((Prev_MSR_Value & SERIAL_MSR_CTS) == (MSR_Value & SERIAL_MSR_CD)))
(MSR_Value & SERIAL_MSR_CTS)))) || (arg & TIOCM_CTS
{ && ((Prev_MSR_Value & SERIAL_MSR_CTS) ==
return 0; (MSR_Value & SERIAL_MSR_CTS)))) {
} return 0;
}
}//endwhile
} //endwhile
}
mydbg("%s -No ioctl for that one. port = %d\n", __FUNCTION__, port->number); }
mydbg("%s -No ioctl for that one. port = %d\n", __FUNCTION__,
port->number);
return -ENOIOCTLCMD;
return -ENOIOCTLCMD;
} }
static void serial_set_termios (struct tty_struct *tty, struct ktermios *old) static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
if (!serial) if (!serial)
return; return;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
...@@ -2023,210 +1919,197 @@ static void serial_set_termios (struct tty_struct *tty, struct ktermios *old) ...@@ -2023,210 +1919,197 @@ static void serial_set_termios (struct tty_struct *tty, struct ktermios *old)
} }
/* pass on to the driver specific version of this function if it is available */ /* pass on to the driver specific version of this function if it is available */
qt_set_termios(port, old); qt_set_termios(port, old);
exit: exit:
up (&port->sem); up(&port->sem);
} }
static void qt_set_termios(struct usb_serial_port *port, struct ktermios *old_termios) static void qt_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
{ {
unsigned int cflag; unsigned int cflag;
int baud, divisor, remainder; int baud, divisor, remainder;
unsigned char LCR_change_to = 0; unsigned char LCR_change_to = 0;
struct tty_struct *tty; struct tty_struct *tty;
int status; int status;
struct usb_serial *serial; struct usb_serial *serial;
__u16 UartNumber; __u16 UartNumber;
__u16 tmp, tmp2; __u16 tmp, tmp2;
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
tmp = port->tty->index; tmp = port->tty->index;
mydbg("%s - MINOR(port->tty->index) = %d\n", __FUNCTION__, tmp); mydbg("%s - MINOR(port->tty->index) = %d\n", __FUNCTION__, tmp);
serial = port->serial;
serial = port->serial; tmp2 = serial->minor;
tmp2 = serial->minor; mydbg("%s - serial->minor = %d\n", __FUNCTION__, tmp2);
mydbg("%s - serial->minor = %d\n", __FUNCTION__, tmp2);
UartNumber = port->tty->index - serial->minor;
tty = port->tty;
UartNumber = port->tty->index - serial->minor;
cflag = tty->termios->c_cflag;
tty = port->tty;
if (old_termios) {
cflag = tty->termios->c_cflag; if ((cflag == old_termios->c_cflag)
&& (RELEVANT_IFLAG(tty->termios->c_iflag) ==
if (old_termios) RELEVANT_IFLAG(old_termios->c_iflag))) {
{ mydbg("%s - Nothing to change\n", __FUNCTION__);
if((cflag == old_termios->c_cflag) && (RELEVANT_IFLAG(tty->termios->c_iflag) == return;
RELEVANT_IFLAG(old_termios->c_iflag))) }
{
mydbg("%s - Nothing to change\n", __FUNCTION__); }
return;
} mydbg("%s - 3\n", __FUNCTION__);
switch (cflag) {
} case CS5:
LCR_change_to |= SERIAL_5_DATA;
mydbg("%s - 3\n", __FUNCTION__); break;
case CS6:
switch(cflag) LCR_change_to |= SERIAL_6_DATA;
{ break;
case CS5: case CS7:
LCR_change_to |= SERIAL_5_DATA; LCR_change_to |= SERIAL_7_DATA;
break; break;
case CS6: default:
LCR_change_to |= SERIAL_6_DATA; case CS8:
break; LCR_change_to |= SERIAL_8_DATA;
case CS7: break;
LCR_change_to |= SERIAL_7_DATA; }
break;
default: //Parity stuff
case CS8: if (cflag & PARENB) {
LCR_change_to |= SERIAL_8_DATA; if (cflag & PARODD)
break; LCR_change_to |= SERIAL_ODD_PARITY;
} else
LCR_change_to |= SERIAL_EVEN_PARITY;
//Parity stuff }
if(cflag & PARENB) if (cflag & CSTOPB)
{ LCR_change_to |= SERIAL_TWO_STOPB;
if(cflag & PARODD) else
LCR_change_to |= SERIAL_ODD_PARITY; LCR_change_to |= SERIAL_TWO_STOPB;
else
LCR_change_to |= SERIAL_EVEN_PARITY; mydbg("%s - 4\n", __FUNCTION__);
} //Thats the LCR stuff, go ahead and set it
if(cflag & CSTOPB) baud = tty_get_baud_rate(tty);
LCR_change_to |= SERIAL_TWO_STOPB; if (!baud) {
else /* pick a default, any default... */
LCR_change_to |= SERIAL_TWO_STOPB; baud = 9600;
}
mydbg("%s - 4\n", __FUNCTION__);
//Thats the LCR stuff, go ahead and set it mydbg("%s - got baud = %d\n", __FUNCTION__, baud);
baud = tty_get_baud_rate(tty);
if (!baud) { divisor = MAX_BAUD_RATE / baud;
/* pick a default, any default... */ remainder = MAX_BAUD_RATE % baud;
baud = 9600; //Round to nearest divisor
} if (((remainder * 2) >= baud) && (baud != 110))
divisor++;
mydbg("%s - got baud = %d\n", __FUNCTION__, baud);
//Set Baud rate to default and turn off (default)flow control here
status =
divisor = MAX_BAUD_RATE / baud; BoxSetUart(serial, UartNumber, (unsigned short)divisor,
remainder = MAX_BAUD_RATE % baud; LCR_change_to);
//Round to nearest divisor if (status < 0) {
if(((remainder * 2) >= baud) && (baud != 110)) mydbg(__FILE__ "BoxSetUart failed\n");
divisor++; return;
}
//Set Baud rate to default and turn off (default)flow control here //************************Now determine flow control
status = BoxSetUart(serial, UartNumber, (unsigned short) divisor, LCR_change_to);
if (status < 0)
{
mydbg(__FILE__"BoxSetUart failed\n");
return;
}
//************************Now determine flow control
if(cflag & CRTSCTS)
{
mydbg("%s - Enabling HW flow control port %d\n", __FUNCTION__, port->number);
//Enable RTS/CTS flow control
status = BoxSetHW_FlowCtrl(serial, UartNumber, 1);
if (status < 0)
{
mydbg(__FILE__"BoxSetHW_FlowCtrl failed\n");
return;
}
}
else
{
//Disable RTS/CTS flow control
mydbg("%s - disabling HW flow control port %d\n", __FUNCTION__, port->number);
status = BoxSetHW_FlowCtrl(serial, UartNumber, 0);
if (status < 0)
{
mydbg(__FILE__"BoxSetHW_FlowCtrl failed\n");
return;
}
}
//*************************************************
/* if we are implementing XON/XOFF, set the start and stop character in the device */
if (I_IXOFF(tty) || I_IXON(tty))
{
unsigned char stop_char = STOP_CHAR(tty);
unsigned char start_char = START_CHAR(tty);
status = BoxSetSW_FlowCtrl(serial, UartNumber, stop_char, start_char);
if(status < 0)
mydbg(__FILE__"BoxSetSW_FlowCtrl (enabled) failed\n");
} if (cflag & CRTSCTS) {
else mydbg("%s - Enabling HW flow control port %d\n", __FUNCTION__,
{ port->number);
//disable SW flow control
status = BoxDisable_SW_FlowCtrl(serial, UartNumber);
if(status < 0)
mydbg(__FILE__"BoxSetSW_FlowCtrl (diabling) failed\n");
} //Enable RTS/CTS flow control
status = BoxSetHW_FlowCtrl(serial, UartNumber, 1);
if (status < 0) {
mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
return;
}
} else {
//Disable RTS/CTS flow control
mydbg("%s - disabling HW flow control port %d\n", __FUNCTION__,
port->number);
status = BoxSetHW_FlowCtrl(serial, UartNumber, 0);
if (status < 0) {
mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
return;
}
}
//*************************************************
/* if we are implementing XON/XOFF, set the start and stop character in the device */
if (I_IXOFF(tty) || I_IXON(tty)) {
unsigned char stop_char = STOP_CHAR(tty);
unsigned char start_char = START_CHAR(tty);
status =
BoxSetSW_FlowCtrl(serial, UartNumber, stop_char,
start_char);
if (status < 0)
mydbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n");
} else {
//disable SW flow control
status = BoxDisable_SW_FlowCtrl(serial, UartNumber);
if (status < 0)
mydbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n");
}
} }
/**************************************************************************** /****************************************************************************
* BoxGetRegister * BoxGetRegister
* issuse a GET_REGISTER vendor-spcific request on the default control pipe * issuse a GET_REGISTER vendor-spcific request on the default control pipe
* If successful, fills in the pValue with the register value asked for * If successful, fills in the pValue with the register value asked for
****************************************************************************/ ****************************************************************************/
static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number, static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
unsigned short Register_Num, __u8 *pValue ) unsigned short Register_Num, __u8 * pValue)
{ {
int result; int result;
__u16 current_length; __u16 current_length;
current_length = sizeof(struct qt_get_device_data); current_length = sizeof(struct qt_get_device_data);
result = usb_control_msg (serial->dev, usb_rcvctrlpipe(serial->dev, 0), QT_GET_SET_REGISTER, result =
0xC0, Register_Num, Uart_Number, (void *)pValue, sizeof(*pValue), 300); usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
QT_GET_SET_REGISTER, 0xC0, Register_Num,
Uart_Number, (void *)pValue, sizeof(*pValue), 300);
return result; return result;
} }
/**************************************************************************** /****************************************************************************
* BoxSetRegister * BoxSetRegister
* issuse a GET_REGISTER vendor-spcific request on the default control pipe * issuse a GET_REGISTER vendor-spcific request on the default control pipe
* If successful, fills in the pValue with the register value asked for * If successful, fills in the pValue with the register value asked for
****************************************************************************/ ****************************************************************************/
static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number, static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
unsigned short Register_Num, unsigned short Value ) unsigned short Register_Num, unsigned short Value)
{ {
int result; int result;
unsigned short RegAndByte; unsigned short RegAndByte;
RegAndByte = Value; RegAndByte = Value;
RegAndByte = RegAndByte << 8; RegAndByte = RegAndByte << 8;
RegAndByte = RegAndByte + Register_Num; RegAndByte = RegAndByte + Register_Num;
// result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_GET_SET_REGISTER, // result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_GET_SET_REGISTER,
// 0xC0, Register_Num, Uart_Number, NULL, 0, 300); // 0xC0, Register_Num, Uart_Number, NULL, 0, 300);
result =
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
NULL, 0, 300);
result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_GET_SET_REGISTER, return result;
0x40, RegAndByte, Uart_Number, NULL,0, 300);
return result;
} }
/** /**
* box_get_device * box_get_device
* Issue a GET_DEVICE vendor-specific request on the default control pipe If * Issue a GET_DEVICE vendor-specific request on the default control pipe If
...@@ -2261,15 +2144,16 @@ static int box_get_device(struct usb_serial *serial, ...@@ -2261,15 +2144,16 @@ static int box_get_device(struct usb_serial *serial,
* successful returns the number of bytes written, otherwise it returns a * successful returns the number of bytes written, otherwise it returns a
* negative error number of the problem. * negative error number of the problem.
*/ */
static int box_set_device(struct usb_serial *serial, struct qt_get_device_data *device_data) static int box_set_device(struct usb_serial *serial,
struct qt_get_device_data *device_data)
{ {
int result; int result;
__u16 length; __u16 length;
__u16 PortSettings; __u16 PortSettings;
PortSettings = ((__u16)(device_data->portb)); PortSettings = ((__u16) (device_data->portb));
PortSettings = (PortSettings << 8); PortSettings = (PortSettings << 8);
PortSettings += ((__u16)(device_data->porta)); PortSettings += ((__u16) (device_data->porta));
length = sizeof(struct qt_get_device_data); length = sizeof(struct qt_get_device_data);
mydbg("%s - PortSettings = 0x%x\n", __FUNCTION__, PortSettings); mydbg("%s - PortSettings = 0x%x\n", __FUNCTION__, PortSettings);
...@@ -2286,35 +2170,36 @@ static int box_set_device(struct usb_serial *serial, struct qt_get_device_data * ...@@ -2286,35 +2170,36 @@ static int box_set_device(struct usb_serial *serial, struct qt_get_device_data *
* purpose is to allow the device driver and the device to synchronize state information. * purpose is to allow the device driver and the device to synchronize state information.
* OpenClose = 1 for open , 0 for close * OpenClose = 1 for open , 0 for close
****************************************************************************/ ****************************************************************************/
static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number, __u16 OpenClose, struct qt_open_channel_data *pDeviceData) static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
__u16 OpenClose,
struct qt_open_channel_data *pDeviceData)
{ {
int result; int result;
__u16 length; __u16 length;
__u8 Direcion; __u8 Direcion;
unsigned int pipe; unsigned int pipe;
length = sizeof(struct qt_open_channel_data); length = sizeof(struct qt_open_channel_data);
if (OpenClose == 1) //IF OPENING
{
Direcion = USBD_TRANSFER_DIRECTION_IN;
pipe = usb_rcvctrlpipe(serial->dev, 0);
result = usb_control_msg (serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
Direcion, OpenClose, Uart_Number, pDeviceData, length, 300);
}
else
{
Direcion = USBD_TRANSFER_DIRECTION_OUT;
pipe = usb_sndctrlpipe(serial->dev, 0);
result = usb_control_msg (serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
Direcion, OpenClose, Uart_Number, NULL, 0, 300);
}
if (OpenClose == 1) //IF OPENING
{
Direcion = USBD_TRANSFER_DIRECTION_IN;
pipe = usb_rcvctrlpipe(serial->dev, 0);
result =
usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
Direcion, OpenClose, Uart_Number,
pDeviceData, length, 300);
} else {
Direcion = USBD_TRANSFER_DIRECTION_OUT;
pipe = usb_sndctrlpipe(serial->dev, 0);
result =
usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
Direcion, OpenClose, Uart_Number, NULL, 0,
300);
}
return result; return result;
} }
/**************************************************************************** /****************************************************************************
...@@ -2333,24 +2218,22 @@ static int BoxSetPrebufferLevel(struct usb_serial *serial) ...@@ -2333,24 +2218,22 @@ static int BoxSetPrebufferLevel(struct usb_serial *serial)
return result; return result;
} }
/**************************************************************************** /****************************************************************************
* BoxSetATC * BoxSetATC
TELLS BOX WHEN TO ASSERT automatic transmitter control TELLS BOX WHEN TO ASSERT automatic transmitter control
****************************************************************************/ ****************************************************************************/
static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode) static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
{ {
int result; int result;
__u16 buffer_length; __u16 buffer_length;
buffer_length = PREFUFF_LEVEL_CONSERVATIVE; buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_SET_ATF, result =
0x40, n_Mode, 0, NULL, 0, 300); usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
return result; return result;
} }
/**************************************************************************** /****************************************************************************
...@@ -2358,184 +2241,182 @@ static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode) ...@@ -2358,184 +2241,182 @@ static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
* issuse a SET_UART vendor-spcific request on the default control pipe * issuse a SET_UART vendor-spcific request on the default control pipe
* If successful sets baud rate divisor and LCR value * If successful sets baud rate divisor and LCR value
****************************************************************************/ ****************************************************************************/
static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number, static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
unsigned short default_divisor, unsigned char default_LCR ) unsigned short default_divisor, unsigned char default_LCR)
{ {
int result; int result;
unsigned short UartNumandLCR; unsigned short UartNumandLCR;
UartNumandLCR = (default_LCR << 8) + Uart_Number; UartNumandLCR = (default_LCR << 8) + Uart_Number;
result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_GET_SET_UART, result =
0x40, default_divisor, UartNumandLCR, NULL, 0, 300); usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
QT_GET_SET_UART, 0x40, default_divisor,
UartNumandLCR, NULL, 0, 300);
return result; return result;
} }
static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int UartNumber,
static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int UartNumber, int bSet) int bSet)
{ {
__u8 MCR_Value = 0; __u8 MCR_Value = 0;
__u8 MSR_Value = 0, MOUT_Value = 0; __u8 MSR_Value = 0, MOUT_Value = 0;
struct usb_serial_port *port; struct usb_serial_port *port;
unsigned int status; unsigned int status;
port = serial->port; port = serial->port;
if (bSet == 1) if (bSet == 1) {
{ MCR_Value = SERIAL_MCR_RTS; //flow control, box will clear RTS line to prevent remote
MCR_Value = SERIAL_MCR_RTS; //flow control, box will clear RTS line to prevent remote } //device from xmitting more chars
} //device from xmitting more chars else { //no flow control to remote device
else MCR_Value = 0;
{ //no flow control to remote device
MCR_Value = 0;
} }
MOUT_Value = MCR_Value << 8; MOUT_Value = MCR_Value << 8;
if(bSet == 1)
{
MSR_Value = SERIAL_MSR_CTS; //flow control, box will inhibit xmit data if CTS line is asserted
}
else
{
MSR_Value = 0; //Box will not inhimbe xmit data due to CTS line
}
MOUT_Value |= MSR_Value;
if (bSet == 1) {
MSR_Value = SERIAL_MSR_CTS; //flow control, box will inhibit xmit data if CTS line is asserted
} else {
MSR_Value = 0; //Box will not inhimbe xmit data due to CTS line
}
MOUT_Value |= MSR_Value;
status = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_HW_FLOW_CONTROL_MASK, status =
0x40, MOUT_Value, UartNumber, NULL, 0, 300); usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
return status; QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
UartNumber, NULL, 0, 300);
return status;
} }
static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber, unsigned char stop_char, unsigned char start_char) static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber,
unsigned char stop_char, unsigned char start_char)
{ {
__u16 nSWflowout; __u16 nSWflowout;
int result; int result;
nSWflowout = start_char << 8; nSWflowout = start_char << 8;
nSWflowout = (unsigned short)stop_char; nSWflowout = (unsigned short)stop_char;
result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_SW_FLOW_CONTROL_MASK, result =
0x40, nSWflowout, UartNumber, NULL, 0, 300); usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
return result; QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
UartNumber, NULL, 0, 300);
return result;
} }
static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber) static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber)
{ {
int result; int result;
result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_SW_FLOW_CONTROL_DISABLE, result =
0x40, 0, UartNumber, NULL, 0, 300); usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
return result; QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber,
NULL, 0, 300);
return result;
} }
/***************************************************************************** /*****************************************************************************
* SerialThrottle * SerialThrottle
* this function is called by the tty driver when it wants to stop the data * this function is called by the tty driver when it wants to stop the data
* being read from the port. * being read from the port.
*****************************************************************************/ *****************************************************************************/
static void serial_throttle(struct tty_struct *tty)
static void serial_throttle (struct tty_struct * tty)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
mydbg("%s - port %d\n", __FUNCTION__, port->number); struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (!serial) if (!serial)
return; return;
down (&port->sem); down(&port->sem);
if (!port->open_count) { if (!port->open_count) {
mydbg ("%s - port not open\n", __FUNCTION__); mydbg("%s - port not open\n", __FUNCTION__);
goto exit; goto exit;
} }
//shut down any bulk reads that may be going on //shut down any bulk reads that may be going on
// usb_unlink_urb (port->read_urb); // usb_unlink_urb (port->read_urb);
/* pass on to the driver specific version of this function */ /* pass on to the driver specific version of this function */
port->RxHolding = 1; port->RxHolding = 1;
mydbg("%s - port->RxHolding = 1\n", __FUNCTION__); mydbg("%s - port->RxHolding = 1\n", __FUNCTION__);
exit: exit:
up (&port->sem); up(&port->sem);
return; return;
} }
static void serial_unthrottle (struct tty_struct * tty) static void serial_unthrottle(struct tty_struct *tty)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
unsigned int result; struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
unsigned int result;
if (!serial) if (!serial)
return; return;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
if (!port->open_count) { if (!port->open_count) {
mydbg ("%s - port not open\n", __FUNCTION__); mydbg("%s - port not open\n", __FUNCTION__);
goto exit; goto exit;
} }
if(port->RxHolding == 1) if (port->RxHolding == 1) {
{ mydbg("%s -port->RxHolding == 1\n", __FUNCTION__);
mydbg ("%s -port->RxHolding == 1\n", __FUNCTION__);
port->RxHolding = 0;
port->RxHolding = 0; mydbg("%s - port->RxHolding = 0\n", __FUNCTION__);
mydbg ("%s - port->RxHolding = 0\n", __FUNCTION__);
/* if we have a bulk endpoint, start it up */
/* if we have a bulk endpoint, start it up */ if ((serial->num_bulk_in) && (port->ReadBulkStopped == 1)) {
if ((serial->num_bulk_in) && (port->ReadBulkStopped == 1)) /* Start reading from the device */
{ usb_fill_bulk_urb(port->read_urb, serial->dev,
/* Start reading from the device */ usb_rcvbulkpipe(serial->dev,
usb_fill_bulk_urb (port->read_urb, serial->dev, port->
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), bulk_in_endpointAddress),
port->read_urb->transfer_buffer, port->read_urb->transfer_buffer,
port->read_urb->transfer_buffer_length, port->read_urb->
qt_read_bulk_callback, transfer_buffer_length,
port); qt_read_bulk_callback, port);
result = usb_submit_urb(port->read_urb, GFP_ATOMIC); result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
if (result) if (result)
err("%s - failed restarting read urb, error %d", __FUNCTION__, result); err("%s - failed restarting read urb, error %d",
} __FUNCTION__, result);
} }
exit: }
up (&port->sem); exit:
return; up(&port->sem);
return;
} }
static int serial_break(struct tty_struct *tty, int break_state)
static int serial_break (struct tty_struct *tty, int break_state)
{ {
struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data; struct usb_serial_port *port =
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); (struct usb_serial_port *)tty->driver_data;
__u16 UartNumber, Break_Value; struct usb_serial *serial = get_usb_serial(port, __FUNCTION__);
unsigned int result; __u16 UartNumber, Break_Value;
unsigned int result;
UartNumber = port->tty->index - serial->minor; UartNumber = port->tty->index - serial->minor;
if (!serial) if (!serial)
return -ENODEV; return -ENODEV;
if(break_state == -1) if (break_state == -1)
Break_Value = 1; Break_Value = 1;
else else
Break_Value = 0; Break_Value = 0;
down (&port->sem); down(&port->sem);
mydbg("%s - port %d\n", __FUNCTION__, port->number); mydbg("%s - port %d\n", __FUNCTION__, port->number);
...@@ -2544,18 +2425,18 @@ static int serial_break (struct tty_struct *tty, int break_state) ...@@ -2544,18 +2425,18 @@ static int serial_break (struct tty_struct *tty, int break_state)
goto exit; goto exit;
} }
result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_BREAK_CONTROL, result =
0x40, Break_Value, UartNumber, NULL, 0, 300); usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
QT_BREAK_CONTROL, 0x40, Break_Value, UartNumber,
NULL, 0, 300);
exit: exit:
up (&port->sem); up(&port->sem);
return 0; return 0;
} }
static int serial_read_proc(char *page, char **start, off_t off, int count,
int *eof, void *data)
static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
{ {
struct usb_serial *serial; struct usb_serial *serial;
int length = 0; int length = 0;
...@@ -2563,21 +2444,26 @@ static int serial_read_proc (char *page, char **start, off_t off, int count, int ...@@ -2563,21 +2444,26 @@ static int serial_read_proc (char *page, char **start, off_t off, int count, int
off_t begin = 0; off_t begin = 0;
mydbg("%s\n", __FUNCTION__); mydbg("%s\n", __FUNCTION__);
length += sprintf (page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION); length += sprintf(page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION);
for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) { for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
serial = get_serial_by_minor(i); serial = get_serial_by_minor(i);
if (serial == NULL) if (serial == NULL)
continue; continue;
length += sprintf (page+length, "%d:\n", i); length += sprintf(page + length, "%d:\n", i);
length += sprintf (page+length, " vendor:%04x product:%04x\n", serial->vendor, serial->product); length +=
length += sprintf (page+length, " num_ports:%d\n", serial->num_ports); sprintf(page + length, " vendor:%04x product:%04x\n",
length += sprintf (page+length, " port:%d\n", i - serial->minor + 1); serial->vendor, serial->product);
length +=
sprintf(page + length, " num_ports:%d\n",
serial->num_ports);
length +=
sprintf(page + length, " port:%d\n", i - serial->minor + 1);
// usb_make_path(serial->dev, tmp, sizeof(tmp)); // usb_make_path(serial->dev, tmp, sizeof(tmp));
// length += sprintf (page+length, " path:%s", tmp); // length += sprintf (page+length, " path:%s", tmp);
length += sprintf (page+length, "\n"); length += sprintf(page + length, "\n");
if ((length + begin) > (off + count)) if ((length + begin) > (off + count))
goto done; goto done;
if ((length + begin) < off) { if ((length + begin) < off) {
...@@ -2589,348 +2475,323 @@ static int serial_read_proc (char *page, char **start, off_t off, int count, int ...@@ -2589,348 +2475,323 @@ static int serial_read_proc (char *page, char **start, off_t off, int count, int
done: done:
if (off >= (length + begin)) if (off >= (length + begin))
return 0; return 0;
*start = page + (off-begin); *start = page + (off - begin);
return ((count < begin+length-off) ? count : begin+length-off); return ((count < begin + length - off) ? count : begin + length - off);
} }
int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
unsigned long arg)
int ioctl_serial_usb (struct inode *innod, struct file *filp, unsigned int cmd,
unsigned long arg)
{ {
unsigned err; unsigned err;
unsigned ucOPR_NewValue, uc_Value; unsigned ucOPR_NewValue, uc_Value;
int *p_Num_of_adapters, counts, index, *p_QMCR_Value; int *p_Num_of_adapters, counts, index, *p_QMCR_Value;
struct identity *p_Identity_of; struct identity *p_Identity_of;
struct identity Identity_of; struct identity Identity_of;
struct usb_serial *lastserial, *serial; struct usb_serial *lastserial, *serial;
mydbg(KERN_DEBUG"ioctl_serial_usb cmd =\n"); mydbg(KERN_DEBUG "ioctl_serial_usb cmd =\n");
if (_IOC_TYPE(cmd) != SERIALQT_PCI_IOC_MAGIC) if (_IOC_TYPE(cmd) != SERIALQT_PCI_IOC_MAGIC)
return -ENOTTY; return -ENOTTY;
if (_IOC_NR(cmd) > SERIALQT_IOC_MAXNR) if (_IOC_NR(cmd) > SERIALQT_IOC_MAXNR)
return -ENOTTY; return -ENOTTY;
mydbg(KERN_DEBUG"ioctl_serial_usb cmd = 0x%x\n", cmd); mydbg(KERN_DEBUG "ioctl_serial_usb cmd = 0x%x\n", cmd);
err = 0; err = 0;
switch (cmd) switch (cmd) {
{
case SERIALQT_WRITE_QMCR:
err = -ENOTTY; //initialize as error so if we don't find this one we give//an error.
case SERIALQT_WRITE_QMCR: index = arg >> 16;
err = -ENOTTY; //initialize as error so if we don't find this one we give//an error. counts = 0;
index = arg >> 16;
counts = 0; ucOPR_NewValue = arg;
ucOPR_NewValue = arg; err = EmulateWriteQMCR_Reg(index, ucOPR_NewValue);
break;
err = EmulateWriteQMCR_Reg(index, ucOPR_NewValue); case SERIALQT_READ_QMCR:
break; err = -ENOTTY; //initialize as error so if we don't find this one we give
//an error.
case SERIALQT_READ_QMCR: p_QMCR_Value = (int *)arg;
err = -ENOTTY; //initialize as error so if we don't find this one we give index = arg >> 16;
//an error. counts = 0;
p_QMCR_Value = (int *)arg;
index = arg >> 16; err = EmulateReadQMCR_Reg(index, &uc_Value);
counts = 0; if (err == 0) {
err = put_user(uc_Value, p_QMCR_Value);
}
break;
err = EmulateReadQMCR_Reg(index, &uc_Value);
if (err == 0) case SERIALQT_GET_NUMOF_UNITS:
{ p_Num_of_adapters = (int *)arg;
err = put_user(uc_Value, p_QMCR_Value); counts = 0; //Initialize counts to zero
} //struct usb_serial *lastserial = serial_table[0], *serial;
break; lastserial = serial_table[0];
case SERIALQT_GET_NUMOF_UNITS: mydbg(KERN_DEBUG "SERIALQT_GET_NUMOF_UNITS \n");
p_Num_of_adapters = (int *)arg; //if first pointer is nonull, we at least have one box
counts = 0; //Initialize counts to zero if (lastserial)
//struct usb_serial *lastserial = serial_table[0], *serial; counts = 1; //we at least have one box
lastserial = serial_table[0];
for (index = 1; index < SERIAL_TTY_MINORS; index++) {
mydbg(KERN_DEBUG"SERIALQT_GET_NUMOF_UNITS \n"); serial = serial_table[index];
//if first pointer is nonull, we at least have one box if (serial) {
if(lastserial) if (serial != lastserial) {
counts = 1; //we at least have one box //we had a change in the array, hence another box is there
lastserial = serial;
for (index = 1; index < SERIAL_TTY_MINORS ; index++) counts++;
{ }
serial = serial_table[index]; } else
if(serial) break;
{ }
if(serial != lastserial)
{
//we had a change in the array, hence another box is there
lastserial = serial;
counts++;
}
}
else
break;
}
mydbg(KERN_DEBUG"ioctl_serial_usb writting counts = %d", counts);
err = put_user(counts, p_Num_of_adapters);
break;
case SERIALQT_GET_THIS_UNIT:
counts = 0;
p_Identity_of = (struct identity *)arg;
//copy user structure to local variable
get_user(Identity_of.index, &p_Identity_of->index);
mydbg(KERN_DEBUG"SERIALQT_GET_THIS_UNIT Identity_of.index\n");
mydbg(KERN_DEBUG"SERIALQT_GET_THIS_UNIT Identity_of.index= 0x%x\n", Identity_of.index);
err = -ENOTTY; //initialize as error so if we don't find this one we give
//an error.
serial = find_the_box(Identity_of.index);
if(serial)
{
err = put_user(serial->product, &p_Identity_of->n_identity);
} mydbg(KERN_DEBUG "ioctl_serial_usb writting counts = %d",
break; counts);
err = put_user(counts, p_Num_of_adapters);
break;
case SERIALQT_GET_THIS_UNIT:
counts = 0;
p_Identity_of = (struct identity *)arg;
//copy user structure to local variable
get_user(Identity_of.index, &p_Identity_of->index);
mydbg(KERN_DEBUG "SERIALQT_GET_THIS_UNIT Identity_of.index\n");
mydbg(KERN_DEBUG
"SERIALQT_GET_THIS_UNIT Identity_of.index= 0x%x\n",
Identity_of.index);
err = -ENOTTY; //initialize as error so if we don't find this one we give
//an error.
serial = find_the_box(Identity_of.index);
if (serial) {
err =
put_user(serial->product,
&p_Identity_of->n_identity);
case SERIALQT_IS422_EXTENDED: }
err = -ENOTTY; //initialize as error so if we don't find this one we give break;
mydbg(KERN_DEBUG"SERIALQT_IS422_EXTENDED \n");
//an error. case SERIALQT_IS422_EXTENDED:
index = arg >> 16; err = -ENOTTY; //initialize as error so if we don't find this one we give
mydbg(KERN_DEBUG "SERIALQT_IS422_EXTENDED \n");
//an error.
index = arg >> 16;
counts = 0;
mydbg(KERN_DEBUG
"SERIALQT_IS422_EXTENDED, looking Identity_of.indext = 0x%x\n",
index);
serial = find_the_box(index);
if (serial) {
mydbg("%s index = 0x%x, serial = 0x%p\n", __FUNCTION__,
index, serial);
for (counts = 0; serqt_422_table[counts] != 0; counts++) {
mydbg
("%s serial->product = = 0x%x, serqt_422_table[counts] = 0x%x\n",
__FUNCTION__, serial->product,
serqt_422_table[counts]);
if (serial->product == serqt_422_table[counts]) {
err = 0;
mydbg
("%s found match for 422extended\n",
__FUNCTION__);
break;
}
}
}
break;
default:
err = -ENOTTY;
counts = 0; } //End switch
mydbg(KERN_DEBUG"SERIALQT_IS422_EXTENDED, looking Identity_of.indext = 0x%x\n",index); mydbg("%s returning err = 0x%x\n", __FUNCTION__, err);
serial = find_the_box(index); return err;
if(serial) }
{
mydbg("%s index = 0x%x, serial = 0x%p\n", __FUNCTION__, index, serial);
for (counts = 0; serqt_422_table[counts] != 0; counts++)
{
mydbg("%s serial->product = = 0x%x, serqt_422_table[counts] = 0x%x\n", __FUNCTION__, serial->product, serqt_422_table[counts]); static struct usb_serial *find_the_box(unsigned int index)
if(serial->product == serqt_422_table[counts]) {
{ struct usb_serial *lastserial, *foundserial, *serial;
err = 0; int counts = 0, index2;
lastserial = serial_table[0];
foundserial = NULL;
for (index2 = 0; index2 < SERIAL_TTY_MINORS; index2++) {
serial = serial_table[index2];
mydbg("%s index = 0x%x, index2 = 0x%x, serial = 0x%p\n",
__FUNCTION__, index, index2, serial);
if (serial) {
//first see if this is the unit we'er looking for
mydbg
("%s inside if(serial) counts = 0x%x , index = 0x%x\n",
__FUNCTION__, counts, index);
if (counts == index) {
//we found the one we're looking for, copythe product Id to user
mydbg
("%s we found the one we're looking for serial = 0x%p\n",
__FUNCTION__, serial);
foundserial = serial;
break;
}
if (serial != lastserial) {
//when we have a change in the pointer
lastserial = serial;
counts++;
}
} else
break; // no matches
}
mydbg("%s found match for 422extended\n", __FUNCTION__); mydbg("%s returning foundserial = 0x%p\n", __FUNCTION__, foundserial);
break; return foundserial;
} }
}
}
break;
static int EmulateWriteQMCR_Reg(int index, unsigned uc_value)
{
__u16 ATC_Mode = 0;
struct usb_serial *serial;
int status;
struct qt_get_device_data DeviceData;
unsigned uc_temp = 0;
mydbg("Inside %s, uc_value = 0x%x\n", __FUNCTION__, uc_value);
DeviceData.porta = 0;
DeviceData.portb = 0;
serial = find_the_box(index);
//Determine Duplex mode
if (!(serial))
return -ENOTTY;
status = box_get_device(serial, &DeviceData);
if (status < 0) {
mydbg(__FILE__ "box_set_device failed\n");
return status;
}
uc_temp = uc_value & QMCR_HALF_DUPLEX_MASK;
switch (uc_temp) {
case QMCR_FULL_DUPLEX:
DeviceData.porta &= ~DUPMODE_BITS;
DeviceData.porta |= FULL_DUPLEX;
ATC_Mode = ATC_DISABLED;
break;
case QMCR_HALF_DUPLEX_RTS:
DeviceData.porta &= ~DUPMODE_BITS;
DeviceData.porta |= HALF_DUPLEX_RTS;
ATC_Mode = ATC_RTS_ENABLED;
break;
case QMCR_HALF_DUPLEX_DTR:
DeviceData.porta &= ~DUPMODE_BITS;
DeviceData.porta |= HALF_DUPLEX_DTR;
ATC_Mode = ATC_DTR_ENABLED;
break;
default:
break;
}
default: uc_temp = uc_value & QMCR_CONNECTOR_MASK;
err = -ENOTTY; switch (uc_temp) {
case QMCR_MODEM_CONTROL:
DeviceData.portb &= ~LOOPMODE_BITS; //reset connection bits
DeviceData.portb |= MODEM_CTRL;
break;
case QMCR_ALL_LOOPBACK:
DeviceData.portb &= ~LOOPMODE_BITS; //reset connection bits
DeviceData.portb |= ALL_LOOPBACK;
break;
}
mydbg(__FILE__ "Calling box_set_device with failed\n");
status = box_set_device(serial, &DeviceData);
if (status < 0) {
mydbg(__FILE__ "box_set_device failed\n");
return status;
}
if (uc_value & QMCR_RX_EN_MASK) //This bit (otherwise unused) i'll used to detect whether ATC is selected
{
mydbg(__FILE__
"calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
DeviceData.porta, DeviceData.portb);
status = BoxSetATC(serial, ATC_Mode);
if (status < 0) {
mydbg(__FILE__ "BoxSetATC failed\n");
return status;
}
} else {
mydbg(__FILE__
"calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
DeviceData.porta, DeviceData.portb);
status = BoxSetATC(serial, ATC_DISABLED);
if (status < 0) {
mydbg(__FILE__ "BoxSetATC failed\n");
return status;
}
}
} //End switch return 0;
mydbg("%s returning err = 0x%x\n", __FUNCTION__, err);
return err;
} }
static int EmulateReadQMCR_Reg(int index, unsigned *uc_value)
{
struct usb_serial *serial;
int status;
struct qt_get_device_data DeviceData;
__u8 uc_temp;
*uc_value = 0;
static struct usb_serial *find_the_box(unsigned int index) serial = find_the_box(index);
{ if (!(serial))
struct usb_serial *lastserial, *foundserial, *serial; return -ENOTTY;
int counts = 0, index2;
lastserial = serial_table[0];
foundserial = NULL;
for (index2 = 0; index2 < SERIAL_TTY_MINORS ; index2++)
{
serial = serial_table[index2];
mydbg("%s index = 0x%x, index2 = 0x%x, serial = 0x%p\n", __FUNCTION__, index, index2, serial);
if(serial)
{
//first see if this is the unit we'er looking for
mydbg("%s inside if(serial) counts = 0x%x , index = 0x%x\n", __FUNCTION__, counts, index);
if(counts == index)
{
//we found the one we're looking for, copythe product Id to user
mydbg("%s we found the one we're looking for serial = 0x%p\n", __FUNCTION__, serial);
foundserial = serial;
break;
}
if(serial != lastserial)
{
//when we have a change in the pointer
lastserial = serial;
counts++;
}
}
else
break; // no matches
}
mydbg("%s returning foundserial = 0x%p\n", __FUNCTION__, foundserial);
return foundserial;
}
status = box_get_device(serial, &DeviceData);
if (status < 0) {
mydbg(__FILE__ "box_get_device failed\n");
return status;
}
uc_temp = DeviceData.porta & DUPMODE_BITS;
switch (uc_temp) {
case FULL_DUPLEX:
*uc_value |= QMCR_FULL_DUPLEX;
break;
case HALF_DUPLEX_RTS:
*uc_value |= QMCR_HALF_DUPLEX_RTS;
break;
case HALF_DUPLEX_DTR:
*uc_value |= QMCR_HALF_DUPLEX_DTR;
break;
default:
break;
}
uc_temp = DeviceData.portb & LOOPMODE_BITS; //I use this for ATC control se
static int EmulateWriteQMCR_Reg(int index, unsigned uc_value) switch (uc_temp) {
{ case ALL_LOOPBACK:
*uc_value |= QMCR_ALL_LOOPBACK;
__u16 ATC_Mode = 0; break;
struct usb_serial *serial; case MODEM_CTRL:
int status; *uc_value |= QMCR_MODEM_CONTROL;
struct qt_get_device_data DeviceData; break;
unsigned uc_temp = 0; default:
mydbg("Inside %s, uc_value = 0x%x\n", __FUNCTION__, uc_value); break;
DeviceData.porta = 0;
DeviceData.portb = 0;
serial = find_the_box(index);
//Determine Duplex mode
if(!(serial))
return -ENOTTY;
status = box_get_device(serial, &DeviceData);
if (status < 0)
{
mydbg(__FILE__"box_set_device failed\n");
return status;
}
uc_temp = uc_value & QMCR_HALF_DUPLEX_MASK;
switch (uc_temp)
{
case QMCR_FULL_DUPLEX:
DeviceData.porta &= ~DUPMODE_BITS;
DeviceData.porta |= FULL_DUPLEX;
ATC_Mode = ATC_DISABLED;
break;
case QMCR_HALF_DUPLEX_RTS:
DeviceData.porta &= ~DUPMODE_BITS;
DeviceData.porta |= HALF_DUPLEX_RTS;
ATC_Mode = ATC_RTS_ENABLED;
break;
case QMCR_HALF_DUPLEX_DTR:
DeviceData.porta &= ~DUPMODE_BITS;
DeviceData.porta |= HALF_DUPLEX_DTR;
ATC_Mode = ATC_DTR_ENABLED;
break;
default:
break;
}
uc_temp = uc_value & QMCR_CONNECTOR_MASK;
switch (uc_temp)
{
case QMCR_MODEM_CONTROL:
DeviceData.portb &= ~LOOPMODE_BITS; //reset connection bits
DeviceData.portb |= MODEM_CTRL;
break;
case QMCR_ALL_LOOPBACK:
DeviceData.portb &= ~LOOPMODE_BITS; //reset connection bits
DeviceData.portb |= ALL_LOOPBACK;
break;
}
mydbg(__FILE__"Calling box_set_device with failed\n");
status = box_set_device(serial, &DeviceData);
if (status < 0)
{
mydbg(__FILE__"box_set_device failed\n");
return status;
}
if(uc_value & QMCR_RX_EN_MASK) //This bit (otherwise unused) i'll used to detect whether ATC is selected
{
mydbg(__FILE__"calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n", DeviceData.porta, DeviceData.portb);
status = BoxSetATC(serial, ATC_Mode);
if (status < 0)
{
mydbg(__FILE__"BoxSetATC failed\n");
return status;
}
}
else
{
mydbg(__FILE__"calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n", DeviceData.porta, DeviceData.portb);
status = BoxSetATC(serial, ATC_DISABLED);
if (status < 0)
{
mydbg(__FILE__"BoxSetATC failed\n");
return status;
}
}
return 0;
}
}
return 0;
static int EmulateReadQMCR_Reg(int index, unsigned *uc_value) }
{
struct usb_serial *serial;
int status;
struct qt_get_device_data DeviceData;
__u8 uc_temp;
*uc_value = 0;
serial = find_the_box(index);
if(!(serial))
return -ENOTTY;
status = box_get_device(serial, &DeviceData);
if (status < 0)
{
mydbg(__FILE__"box_get_device failed\n");
return status;
}
uc_temp = DeviceData.porta & DUPMODE_BITS;
switch (uc_temp)
{
case FULL_DUPLEX:
*uc_value |= QMCR_FULL_DUPLEX;
break;
case HALF_DUPLEX_RTS:
*uc_value |= QMCR_HALF_DUPLEX_RTS;
break;
case HALF_DUPLEX_DTR:
*uc_value |= QMCR_HALF_DUPLEX_DTR;
break;
default:
break;
}
uc_temp = DeviceData.portb & LOOPMODE_BITS; //I use this for ATC control se
switch (uc_temp)
{
case ALL_LOOPBACK:
*uc_value |= QMCR_ALL_LOOPBACK;
break;
case MODEM_CTRL:
*uc_value |= QMCR_MODEM_CONTROL;
break;
default:
break;
}
return 0;
}
static int __init serqt_usb_init(void) static int __init serqt_usb_init(void)
{ {
...@@ -2952,16 +2813,19 @@ static int __init serqt_usb_init(void) ...@@ -2952,16 +2813,19 @@ static int __init serqt_usb_init(void)
/* register this driver with the USB subsystem */ /* register this driver with the USB subsystem */
result = usb_register(&serqt_usb_driver); result = usb_register(&serqt_usb_driver);
if (result < 0) { if (result < 0) {
err("usb_register failed for the "__FILE__" driver. Error number %d", result); err("usb_register failed for the " __FILE__
" driver. Error number %d", result);
return result; return result;
} }
status = 0; // Dynamic assignment of major number status = 0; // Dynamic assignment of major number
major_number = register_chrdev(status, "SerialQT_USB", &serialqt_usb_fops); major_number =
register_chrdev(status, "SerialQT_USB", &serialqt_usb_fops);
if (major_number < 0) { if (major_number < 0) {
mydbg(KERN_DEBUG"No devices found \n\n"); mydbg(KERN_DEBUG "No devices found \n\n");
return -EBUSY; return -EBUSY;
} else } else
mydbg(KERN_DEBUG"SerQT_USB major number assignment = %d \n\n", major_number); mydbg(KERN_DEBUG "SerQT_USB major number assignment = %d \n\n",
major_number);
printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION); printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);
return 0; return 0;
...@@ -2969,10 +2833,10 @@ static int __init serqt_usb_init(void) ...@@ -2969,10 +2833,10 @@ static int __init serqt_usb_init(void)
static void __exit serqt_usb_exit(void) static void __exit serqt_usb_exit(void)
{ {
/* deregister this driver with the USB subsystem */ /* deregister this driver with the USB subsystem */
usb_deregister(&serqt_usb_driver); usb_deregister(&serqt_usb_driver);
tty_unregister_driver(&serial_tty_driver); tty_unregister_driver(&serial_tty_driver);
unregister_chrdev(major_number, "SerialQT_USB"); unregister_chrdev(major_number, "SerialQT_USB");
} }
module_init(serqt_usb_init); module_init(serqt_usb_init);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或