0c21260398
Avoid using port->tty where possible (makes refcount fixing easier later). Remove unused code (the ioctl path is not used if the device has mget/mset functions) Remove various un-needed typecasts and long names so it could read it to do the changes. Signed-off-by: Alan Cox <alan@lxorguk.ukuu.org.uk> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2657 lines
70 KiB
C
2657 lines
70 KiB
C
/*
|
|
* This code was developed for the Quatech USB line for linux, it used
|
|
* much of the code developed by Greg Kroah-Hartman for USB serial devices
|
|
*
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/tty.h>
|
|
#include <linux/tty_flip.h>
|
|
#include <linux/module.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/types.h>
|
|
#include <linux/version.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
/* Use our own dbg macro */
|
|
/* #define DEBUG_ON */
|
|
/* #undef dbg */
|
|
#ifdef DEBUG_ON
|
|
#define mydbg(const...) printk(const)
|
|
#else
|
|
#define mydbg(const...)
|
|
#endif
|
|
|
|
/* parity check flag */
|
|
#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
|
|
|
|
#define SERIAL_TTY_MAJOR 0 /* Nice legal number now */
|
|
#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 PREFUFF_LEVEL_CONSERVATIVE 128
|
|
#define ATC_DISABLED 0x00
|
|
|
|
#define RR_BITS 0x03 /* for clearing clock bits */
|
|
#define DUPMODE_BITS 0xc0
|
|
|
|
#define RS232_MODE 0x00
|
|
#define RTSCTS_TO_CONNECTOR 0x40
|
|
#define CLKS_X4 0x02
|
|
|
|
#define LOOPMODE_BITS 0x41 /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
|
|
#define ALL_LOOPBACK 0x01
|
|
#define MODEM_CTRL 0x40
|
|
|
|
#define THISCHAR data[i]
|
|
#define NEXTCHAR data[i + 1]
|
|
#define THIRDCHAR data[i + 2]
|
|
#define FOURTHCHAR data[i + 3]
|
|
|
|
/*
|
|
* Useful defintions for port A, Port B and Port C
|
|
*/
|
|
#define FULLPWRBIT 0x00000080
|
|
#define NEXT_BOARD_POWER_BIT 0x00000004
|
|
|
|
#define SERIAL_LSR_OE 0x02
|
|
#define SERIAL_LSR_PE 0x04
|
|
#define SERIAL_LSR_FE 0x08
|
|
#define SERIAL_LSR_BI 0x10
|
|
|
|
#define SERIAL_LSR_TEMT 0x40
|
|
|
|
#define DIV_LATCH_LS 0x00
|
|
#define XMT_HOLD_REGISTER 0x00
|
|
#define XVR_BUFFER_REGISTER 0x00
|
|
#define DIV_LATCH_MS 0x01
|
|
#define FIFO_CONTROL_REGISTER 0x02
|
|
#define LINE_CONTROL_REGISTER 0x03
|
|
#define MODEM_CONTROL_REGISTER 0x04
|
|
#define LINE_STATUS_REGISTER 0x05
|
|
#define MODEM_STATUS_REGISTER 0x06
|
|
|
|
#define SERIAL_MCR_DTR 0x01
|
|
#define SERIAL_MCR_RTS 0x02
|
|
#define SERIAL_MCR_LOOP 0x10
|
|
|
|
#define SERIAL_MSR_CTS 0x10
|
|
#define SERIAL_MSR_CD 0x80
|
|
#define SERIAL_MSR_RI 0x40
|
|
#define SERIAL_MSR_DSR 0x20
|
|
#define SERIAL_MSR_MASK 0xf0
|
|
|
|
#define SERIAL_8_DATA 0x03
|
|
#define SERIAL_7_DATA 0x02
|
|
#define SERIAL_6_DATA 0x01
|
|
#define SERIAL_5_DATA 0x00
|
|
|
|
#define SERIAL_ODD_PARITY 0X08
|
|
#define SERIAL_EVEN_PARITY 0X18
|
|
#define SERIAL_TWO_STOPB 0x04
|
|
#define SERIAL_ONE_STOPB 0x00
|
|
|
|
#define MAX_BAUD_RATE 460800
|
|
#define MAX_BAUD_REMAINDER 4608
|
|
|
|
#define QT_SET_GET_DEVICE 0xc2
|
|
#define QT_OPEN_CLOSE_CHANNEL 0xca
|
|
#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
|
|
#define QT_SET_ATF 0xcd
|
|
#define QT_GET_SET_REGISTER 0xc0
|
|
#define QT_GET_SET_UART 0xc1
|
|
#define QT_HW_FLOW_CONTROL_MASK 0xc5
|
|
#define QT_SW_FLOW_CONTROL_MASK 0xc6
|
|
#define QT_SW_FLOW_CONTROL_DISABLE 0xc7
|
|
#define QT_BREAK_CONTROL 0xc8
|
|
|
|
#define SERIALQT_PCI_IOC_MAGIC 'k'
|
|
#define SERIALQT_WRITE_QOPR _IOW(SERIALQT_PCI_IOC_MAGIC, 0, int)
|
|
#define SERIALQT_WRITE_QMCR _IOW(SERIALQT_PCI_IOC_MAGIC, 1, int)
|
|
#define SERIALQT_GET_NUMOF_UNITS _IOR(SERIALQT_PCI_IOC_MAGIC, 2, 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_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 USBD_TRANSFER_DIRECTION_IN 0xc0
|
|
#define USBD_TRANSFER_DIRECTION_OUT 0x40
|
|
|
|
#define ATC_DISABLED 0x00
|
|
#define ATC_RTS_ENABLED 0x02
|
|
#define ATC_DTR_ENABLED 0x01
|
|
|
|
#define RR_BITS 0x03 /* for clearing clock bits */
|
|
#define DUPMODE_BITS 0xc0
|
|
|
|
#define FULL_DUPLEX 0x00
|
|
#define HALF_DUPLEX_RTS 0x40
|
|
#define HALF_DUPLEX_DTR 0x80
|
|
|
|
#define QMCR_FULL_DUPLEX 0x00
|
|
#define QMCR_HALF_DUPLEX_RTS 0x02
|
|
#define QMCR_HALF_DUPLEX_DTR 0x01
|
|
#define QMCR_HALF_DUPLEX_MASK 0x03
|
|
#define QMCR_CONNECTOR_MASK 0x1C
|
|
|
|
#define QMCR_RX_EN_MASK 0x20
|
|
|
|
#define QMCR_ALL_LOOPBACK 0x10
|
|
#define QMCR_MODEM_CONTROL 0X00
|
|
|
|
#define SERIALQT_IOC_MAXNR 6
|
|
|
|
struct usb_serial_port {
|
|
struct usb_serial *serial; /* pointer back to the owner of this port */
|
|
struct tty_struct *tty; /* the coresponding tty for this port */
|
|
unsigned char number;
|
|
char active; /* someone has this device open */
|
|
|
|
unsigned char *interrupt_in_buffer;
|
|
struct urb *interrupt_in_urb;
|
|
__u8 interrupt_in_endpointAddress;
|
|
|
|
unsigned char *bulk_in_buffer;
|
|
unsigned char *xfer_to_tty_buffer;
|
|
struct urb *read_urb;
|
|
__u8 bulk_in_endpointAddress;
|
|
|
|
unsigned char *bulk_out_buffer;
|
|
int bulk_out_size;
|
|
struct urb *write_urb;
|
|
__u8 bulk_out_endpointAddress;
|
|
|
|
wait_queue_head_t write_wait;
|
|
wait_queue_head_t wait;
|
|
struct work_struct work;
|
|
|
|
int open_count; /* number of times this port has been opened */
|
|
struct semaphore sem; /* locks this structure */
|
|
|
|
__u8 shadowLCR; /* last LCR value received */
|
|
__u8 shadowMCR; /* last MCR value received */
|
|
__u8 shadowMSR; /* last MSR value received */
|
|
__u8 shadowLSR; /* last LSR value received */
|
|
int RxHolding;
|
|
char closePending;
|
|
int ReadBulkStopped;
|
|
|
|
void *private; /* data private to the specific port */
|
|
};
|
|
|
|
struct identity {
|
|
int index;
|
|
int n_identity;
|
|
};
|
|
|
|
struct usb_serial {
|
|
struct usb_device *dev;
|
|
struct usb_interface *interface; /* the interface 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 num_ports; /* the number of ports this device has */
|
|
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_out; /* number of bulk out endpoints we have */
|
|
unsigned char num_OpenCount; /* the number of ports this device has */
|
|
|
|
__u16 vendor; /* vendor id of this device */
|
|
__u16 product; /* product id of this device */
|
|
struct usb_serial_port port[MAX_NUM_PORTS];
|
|
|
|
void *private; /* data private to the specific driver */
|
|
};
|
|
|
|
static inline int port_paranoia_check(struct usb_serial_port *port,
|
|
const char *function)
|
|
{
|
|
if (!port) {
|
|
dbg("%s - port == NULL", function);
|
|
return -1;
|
|
}
|
|
if (!port->serial) {
|
|
dbg("%s - port->serial == NULL\n", function);
|
|
return -1;
|
|
}
|
|
if (!port->tty) {
|
|
dbg("%s - port->tty == NULL\n", function);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
if (!serial) {
|
|
dbg("%s - serial == NULL\n", function);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline struct usb_serial *get_usb_serial(struct usb_serial_port *port,
|
|
const char *function)
|
|
{
|
|
/* if no port was specified, or it fails a paranoia check */
|
|
if (!port ||
|
|
port_paranoia_check(port, function) ||
|
|
serial_paranoia_check(port->serial, function)) {
|
|
/* then say that we dont have a valid usb_serial thing, which will
|
|
* end up genrating -ENODEV return values */
|
|
return NULL;
|
|
}
|
|
|
|
return port->serial;
|
|
}
|
|
|
|
struct qt_get_device_data {
|
|
__u8 porta;
|
|
__u8 portb;
|
|
__u8 portc;
|
|
};
|
|
|
|
struct qt_open_channel_data {
|
|
__u8 line_status;
|
|
__u8 modem_status;
|
|
};
|
|
|
|
static void ProcessLineStatus(struct usb_serial_port *port,
|
|
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 struct usb_serial *get_free_serial(int num_ports, int *minor);
|
|
|
|
static int serqt_probe(struct usb_interface *interface,
|
|
const struct usb_device_id *id);
|
|
|
|
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_get_device(struct usb_serial *serial,
|
|
struct qt_get_device_data *pDeviceData);
|
|
static int serial_open(struct tty_struct *tty, struct file *filp);
|
|
static void serial_close(struct tty_struct *tty, struct file *filp);
|
|
static int serial_write_room(struct tty_struct *tty);
|
|
static int serial_ioctl(struct tty_struct *tty, struct file *file,
|
|
unsigned int cmd, unsigned long arg);
|
|
static void serial_set_termios(struct tty_struct *tty, struct ktermios *old);
|
|
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
|
|
int count);
|
|
|
|
static void serial_throttle(struct tty_struct *tty);
|
|
static void serial_unthrottle(struct tty_struct *tty);
|
|
static int serial_break(struct tty_struct *tty, int break_state);
|
|
static int serial_chars_in_buffer(struct tty_struct *tty);
|
|
|
|
static int qt_open(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *filp);
|
|
static int BoxSetPrebufferLevel(struct usb_serial *serial);
|
|
|
|
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 BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
|
|
__u16 OpenClose,
|
|
struct qt_open_channel_data *pDeviceData);
|
|
static void qt_close(struct tty_struct *tty, 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 int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|
const unsigned char *buf, int count);
|
|
static void port_softint(struct work_struct *work);
|
|
static int qt_write_room(struct usb_serial_port *port);
|
|
static int qt_chars_in_buffer(struct usb_serial_port *port);
|
|
static int qt_ioctl(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *file, unsigned int cmd, unsigned long arg);
|
|
static void qt_set_termios(struct tty_struct *tty,
|
|
struct usb_serial_port *port,
|
|
struct ktermios *old_termios);
|
|
static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
|
|
int bSet);
|
|
static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index);
|
|
static int EmulateWriteQMCR_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 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,
|
|
unsigned char stop_char, unsigned char start_char);
|
|
static void qt_read_bulk_callback(struct urb *urb);
|
|
|
|
static void port_sofrint(void *private);
|
|
|
|
static void return_serial(struct usb_serial *serial);
|
|
|
|
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
|
|
unsigned int set, unsigned int clear);
|
|
static int serial_tiocmget(struct tty_struct *tty, struct file *file);
|
|
|
|
static int qt_tiocmset(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *file, unsigned int value);
|
|
|
|
static int qt_tiocmget(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *file);
|
|
|
|
/* Version Information */
|
|
#define DRIVER_VERSION "v2.14"
|
|
#define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
|
|
#define DRIVER_DESC "Quatech USB to Serial Driver"
|
|
|
|
#define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
|
|
#define DEVICE_ID_QUATECH_RS232_SINGLE_PORT 0xC020 /* SSU100 */
|
|
#define DEVICE_ID_QUATECH_RS422_SINGLE_PORT 0xC030 /* SSU200 */
|
|
#define DEVICE_ID_QUATECH_RS232_DUAL_PORT 0xC040 /* DSU100 */
|
|
#define DEVICE_ID_QUATECH_RS422_DUAL_PORT 0xC050 /* DSU200 */
|
|
#define DEVICE_ID_QUATECH_RS232_FOUR_PORT 0xC060 /* QSU100 */
|
|
#define DEVICE_ID_QUATECH_RS422_FOUR_PORT 0xC070 /* QSU200 */
|
|
#define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A 0xC080 /* ESU100A */
|
|
#define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B 0xC081 /* ESU100B */
|
|
#define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A 0xC0A0 /* ESU200A */
|
|
#define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B 0xC0A1 /* ESU200B */
|
|
#define DEVICE_ID_QUATECH_RS232_16_PORT_A 0xC090 /* HSU100A */
|
|
#define DEVICE_ID_QUATECH_RS232_16_PORT_B 0xC091 /* HSU100B */
|
|
#define DEVICE_ID_QUATECH_RS232_16_PORT_C 0xC092 /* HSU100C */
|
|
#define DEVICE_ID_QUATECH_RS232_16_PORT_D 0xC093 /* HSU100D */
|
|
#define DEVICE_ID_QUATECH_RS422_16_PORT_A 0xC0B0 /* HSU200A */
|
|
#define DEVICE_ID_QUATECH_RS422_16_PORT_B 0xC0B1 /* HSU200B */
|
|
#define DEVICE_ID_QUATECH_RS422_16_PORT_C 0xC0B2 /* HSU200C */
|
|
#define DEVICE_ID_QUATECH_RS422_16_PORT_D 0xC0B3 /* HSU200D */
|
|
|
|
/* table of Quatech devices */
|
|
static struct usb_device_id serqt_table[] = {
|
|
{USB_DEVICE
|
|
(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_SINGLE_PORT)},
|
|
{USB_DEVICE
|
|
(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_SINGLE_PORT)},
|
|
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_DUAL_PORT)},
|
|
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_DUAL_PORT)},
|
|
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_FOUR_PORT)},
|
|
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_FOUR_PORT)},
|
|
{USB_DEVICE
|
|
(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A)},
|
|
{USB_DEVICE
|
|
(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B)},
|
|
{USB_DEVICE
|
|
(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A)},
|
|
{USB_DEVICE
|
|
(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B)},
|
|
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_A)},
|
|
{USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_B)},
|
|
{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);
|
|
|
|
static int major_number;
|
|
static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
|
|
|
|
/* table of Quatech 422devices */
|
|
static unsigned int serqt_422_table[] = {
|
|
DEVICE_ID_QUATECH_RS422_SINGLE_PORT,
|
|
DEVICE_ID_QUATECH_RS422_DUAL_PORT,
|
|
DEVICE_ID_QUATECH_RS422_FOUR_PORT,
|
|
DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A,
|
|
DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B,
|
|
DEVICE_ID_QUATECH_RS422_16_PORT_A,
|
|
DEVICE_ID_QUATECH_RS422_16_PORT_B,
|
|
DEVICE_ID_QUATECH_RS422_16_PORT_C,
|
|
DEVICE_ID_QUATECH_RS422_16_PORT_D,
|
|
0 /* terminate with zero */
|
|
};
|
|
|
|
/* usb specific object needed to register this driver with the usb subsystem */
|
|
static struct usb_driver serqt_usb_driver = {
|
|
.name = "quatech-usb-serial",
|
|
.probe = serqt_probe,
|
|
.disconnect = serqt_usb_disconnect,
|
|
.id_table = serqt_table,
|
|
};
|
|
|
|
static struct ktermios *serial_termios[SERIAL_TTY_MINORS];
|
|
static struct ktermios *serial_termios_locked[SERIAL_TTY_MINORS];
|
|
|
|
static const struct tty_operations serial_ops = {
|
|
.open = serial_open,
|
|
.close = serial_close,
|
|
.write = serial_write,
|
|
.write_room = serial_write_room,
|
|
.ioctl = serial_ioctl,
|
|
.set_termios = serial_set_termios,
|
|
.throttle = serial_throttle,
|
|
.unthrottle = serial_unthrottle,
|
|
.break_ctl = serial_break,
|
|
.chars_in_buffer = serial_chars_in_buffer,
|
|
.tiocmset = serial_tiocmset,
|
|
.tiocmget = serial_tiocmget,
|
|
};
|
|
|
|
static struct tty_driver serial_tty_driver = {
|
|
.magic = TTY_DRIVER_MAGIC,
|
|
.driver_name = "Quatech usb-serial",
|
|
.name = "ttyQT_USB",
|
|
.major = SERIAL_TTY_MAJOR,
|
|
.minor_start = 0,
|
|
.num = SERIAL_TTY_MINORS,
|
|
.type = TTY_DRIVER_TYPE_SERIAL,
|
|
.subtype = SERIAL_TYPE_NORMAL,
|
|
.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV,
|
|
|
|
.termios = serial_termios,
|
|
.termios_locked = serial_termios_locked,
|
|
.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL,
|
|
|
|
.init_termios.c_iflag = ICRNL | IXON,
|
|
.init_termios.c_oflag = OPOST,
|
|
|
|
.init_termios.c_lflag =
|
|
ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN,
|
|
};
|
|
|
|
/* fops for parent device */
|
|
static const struct file_operations serialqt_usb_fops = {
|
|
.ioctl = ioctl_serial_usb,
|
|
};
|
|
|
|
/**
|
|
* serqt_probe
|
|
*
|
|
* Called by the usb core when a new device is connected that it thinks
|
|
* this driver might be interested in.
|
|
*
|
|
*/
|
|
static int serqt_probe(struct usb_interface *interface,
|
|
const struct usb_device_id *id)
|
|
{
|
|
struct usb_device *dev = interface_to_usbdev(interface);
|
|
struct usb_serial *serial = NULL;
|
|
struct usb_serial_port *port;
|
|
struct usb_endpoint_descriptor *endpoint;
|
|
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_out_endpoint[MAX_NUM_PORTS];
|
|
int minor;
|
|
int buffer_size;
|
|
int i;
|
|
struct usb_host_interface *iface_desc;
|
|
int num_interrupt_in = 0;
|
|
int num_bulk_in = 0;
|
|
int num_bulk_out = 0;
|
|
int num_ports;
|
|
struct qt_get_device_data DeviceData;
|
|
int status;
|
|
|
|
mydbg("In %s\n", __func__);
|
|
|
|
/* let's find the endpoints needed */
|
|
/* check out the endpoints */
|
|
iface_desc = interface->cur_altsetting;;
|
|
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
|
|
endpoint = &iface_desc->endpoint[i].desc;
|
|
|
|
if ((endpoint->bEndpointAddress & 0x80) &&
|
|
((endpoint->bmAttributes & 3) == 0x02)) {
|
|
/* we found a bulk in endpoint */
|
|
mydbg("found bulk in");
|
|
bulk_in_endpoint[num_bulk_in] = endpoint;
|
|
++num_bulk_in;
|
|
}
|
|
|
|
if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
|
|
((endpoint->bmAttributes & 3) == 0x02)) {
|
|
/* we found a bulk out endpoint */
|
|
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 */
|
|
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) {
|
|
err("Quatech device with no bulk out, not allowed.");
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
serial = get_free_serial(num_ports, &minor);
|
|
if (serial == NULL) {
|
|
err("No more free serial devices");
|
|
return -ENODEV;
|
|
}
|
|
|
|
serial->dev = dev;
|
|
serial->interface = interface;
|
|
serial->minor = minor;
|
|
serial->num_ports = num_ports;
|
|
serial->num_bulk_in = num_bulk_in;
|
|
serial->num_bulk_out = num_bulk_out;
|
|
serial->num_interrupt_in = num_interrupt_in;
|
|
serial->vendor = dev->descriptor.idVendor;
|
|
serial->product = dev->descriptor.idProduct;
|
|
|
|
/* set up the endpoint information */
|
|
for (i = 0; i < num_bulk_in; ++i) {
|
|
endpoint = bulk_in_endpoint[i];
|
|
port = &serial->port[i];
|
|
port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (!port->read_urb) {
|
|
err("No free urbs available");
|
|
goto probe_error;
|
|
}
|
|
buffer_size = endpoint->wMaxPacketSize;
|
|
port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
|
|
port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
|
|
port->xfer_to_tty_buffer = kmalloc(buffer_size, GFP_KERNEL);
|
|
if (!port->bulk_in_buffer) {
|
|
err("Couldn't allocate bulk_in_buffer");
|
|
goto probe_error;
|
|
}
|
|
usb_fill_bulk_urb(port->read_urb, dev,
|
|
usb_rcvbulkpipe(dev,
|
|
endpoint->bEndpointAddress),
|
|
port->bulk_in_buffer, buffer_size,
|
|
qt_read_bulk_callback, port);
|
|
}
|
|
|
|
for (i = 0; i < num_bulk_out; ++i) {
|
|
endpoint = bulk_out_endpoint[i];
|
|
port = &serial->port[i];
|
|
port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (!port->write_urb) {
|
|
err("No free urbs available");
|
|
goto probe_error;
|
|
}
|
|
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);
|
|
if (!port->bulk_out_buffer) {
|
|
err("Couldn't allocate bulk_out_buffer");
|
|
goto probe_error;
|
|
}
|
|
usb_fill_bulk_urb(port->write_urb, dev,
|
|
usb_sndbulkpipe(dev,
|
|
endpoint->bEndpointAddress),
|
|
port->bulk_out_buffer, buffer_size,
|
|
qt_write_bulk_callback, port);
|
|
|
|
}
|
|
|
|
/* For us numb of bulkin or out = number of ports */
|
|
mydbg("%s - setting up %d port structures for this device\n",
|
|
__func__, num_bulk_in);
|
|
for (i = 0; i < num_bulk_in; ++i) {
|
|
port = &serial->port[i];
|
|
port->number = i + serial->minor;
|
|
port->serial = serial;
|
|
|
|
INIT_WORK(&port->work, port_softint);
|
|
|
|
init_MUTEX(&port->sem);
|
|
|
|
}
|
|
status = box_get_device(serial, &DeviceData);
|
|
if (status < 0) {
|
|
mydbg(__FILE__ "box_get_device failed");
|
|
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); */
|
|
|
|
/***********TAG add start next board here ****/
|
|
status = box_get_device(serial, &DeviceData);
|
|
if (status < 0) {
|
|
mydbg(__FILE__ "box_get_device failed");
|
|
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
|
|
*/
|
|
switch (serial->product) {
|
|
case DEVICE_ID_QUATECH_RS232_SINGLE_PORT:
|
|
case DEVICE_ID_QUATECH_RS232_DUAL_PORT:
|
|
case DEVICE_ID_QUATECH_RS232_FOUR_PORT:
|
|
case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A:
|
|
case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B:
|
|
case DEVICE_ID_QUATECH_RS232_16_PORT_A:
|
|
case DEVICE_ID_QUATECH_RS232_16_PORT_B:
|
|
case DEVICE_ID_QUATECH_RS232_16_PORT_C:
|
|
case DEVICE_ID_QUATECH_RS232_16_PORT_D:
|
|
DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
|
|
DeviceData.porta |= CLKS_X4;
|
|
DeviceData.portb &= ~(LOOPMODE_BITS);
|
|
DeviceData.portb |= RS232_MODE;
|
|
break;
|
|
|
|
case DEVICE_ID_QUATECH_RS422_SINGLE_PORT:
|
|
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_EIGHT_PORT_B:
|
|
case DEVICE_ID_QUATECH_RS422_16_PORT_A:
|
|
case DEVICE_ID_QUATECH_RS422_16_PORT_B:
|
|
case DEVICE_ID_QUATECH_RS422_16_PORT_C:
|
|
case DEVICE_ID_QUATECH_RS422_16_PORT_D:
|
|
DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
|
|
DeviceData.porta |= CLKS_X4;
|
|
DeviceData.portb &= ~(LOOPMODE_BITS);
|
|
DeviceData.portb |= ALL_LOOPBACK;
|
|
break;
|
|
default:
|
|
DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
|
|
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", __func__);
|
|
|
|
usb_set_intfdata(interface, serial);
|
|
return 0;
|
|
|
|
probe_error:
|
|
|
|
for (i = 0; i < num_bulk_in; ++i) {
|
|
port = &serial->port[i];
|
|
usb_free_urb(port->read_urb);
|
|
kfree(port->bulk_in_buffer);
|
|
}
|
|
for (i = 0; i < num_bulk_out; ++i) {
|
|
port = &serial->port[i];
|
|
usb_free_urb(port->write_urb);
|
|
kfree(port->bulk_out_buffer);
|
|
kfree(port->xfer_to_tty_buffer);
|
|
}
|
|
for (i = 0; i < num_interrupt_in; ++i) {
|
|
port = &serial->port[i];
|
|
usb_free_urb(port->interrupt_in_urb);
|
|
kfree(port->interrupt_in_buffer);
|
|
}
|
|
|
|
/* return the minor range that this device had */
|
|
return_serial(serial);
|
|
mydbg("Exit fail %s\n", __func__);
|
|
|
|
/* free up any memory that we allocated */
|
|
kfree(serial);
|
|
return -EIO;
|
|
}
|
|
|
|
/*
|
|
* returns the serial_table array pointers that are taken
|
|
* up in consecutive positions for each port to a common usb_serial structure
|
|
* back to NULL
|
|
*/
|
|
static void return_serial(struct usb_serial *serial)
|
|
{
|
|
int i;
|
|
|
|
mydbg("%s\n", __func__);
|
|
|
|
if (serial == NULL)
|
|
return;
|
|
|
|
for (i = 0; i < serial->num_ports; ++i)
|
|
serial_table[serial->minor + i] = NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Finds the first locatio int the serial_table array where it can fit
|
|
* num_ports number of consecutive points to a common usb_serial
|
|
* structure,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.
|
|
*/
|
|
static struct usb_serial *get_free_serial(int num_ports, int *minor)
|
|
{
|
|
struct usb_serial *serial = NULL;
|
|
int i, j;
|
|
int good_spot;
|
|
|
|
mydbg("%s %d\n", __func__, num_ports);
|
|
|
|
*minor = 0;
|
|
for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
|
|
if (serial_table[i])
|
|
continue;
|
|
|
|
good_spot = 1;
|
|
/*
|
|
* find a spot in the array where you can fit consecutive
|
|
* positions to put the pointers to the usb_serail allocated
|
|
* structure for all the minor numbers (ie. ports)
|
|
*/
|
|
for (j = 1; j <= num_ports - 1; ++j)
|
|
if (serial_table[i + j])
|
|
good_spot = 0;
|
|
if (good_spot == 0)
|
|
continue;
|
|
|
|
serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL);
|
|
if (!serial) {
|
|
err("%s - Out of memory", __func__);
|
|
return NULL;
|
|
}
|
|
memset(serial, 0, sizeof(struct usb_serial));
|
|
serial_table[i] = serial;
|
|
*minor = i;
|
|
mydbg("%s - minor base = %d\n", __func__, *minor);
|
|
|
|
/*
|
|
* copy in the pointer into the array starting a the *minor
|
|
* position minor is the index into the array.
|
|
*/
|
|
for (i = *minor + 1;
|
|
(i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
|
|
serial_table[i] = serial;
|
|
return serial;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int flip_that(struct tty_struct *tty, __u16 index,
|
|
struct usb_serial *serial)
|
|
{
|
|
tty_flip_buffer_push(tty);
|
|
tty_schedule_flip(tty);
|
|
return 0;
|
|
}
|
|
|
|
/* Handles processing and moving data to the tty layer */
|
|
static void port_sofrint(void *private)
|
|
{
|
|
struct usb_serial_port *port = private;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
struct tty_struct *tty = port->tty;
|
|
unsigned char *data = port->read_urb->transfer_buffer;
|
|
unsigned int index;
|
|
struct urb *urb = port->read_urb;
|
|
unsigned int RxCount = urb->actual_length;
|
|
int i, result;
|
|
int flag, flag_data;
|
|
|
|
/* index = MINOR(port->tty->device) - serial->minor; */
|
|
index = tty->index - serial->minor;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
|
|
|
|
if (port_paranoia_check(port, __func__) != 0) {
|
|
mydbg("%s - port_paranoia_check, exiting\n", __func__);
|
|
port->ReadBulkStopped = 1;
|
|
return;
|
|
}
|
|
|
|
if (!serial) {
|
|
mydbg("%s - bad serial pointer, exiting\n", __func__);
|
|
return;
|
|
}
|
|
if (port->closePending == 1) {
|
|
/* Were closing , stop reading */
|
|
mydbg("%s - (port->closepending == 1\n", __func__);
|
|
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",
|
|
__func__, urb->status);
|
|
return;
|
|
}
|
|
|
|
tty = port->tty;
|
|
mydbg("%s - port %d, tty =0x%p\n", __func__, 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;
|
|
}
|
|
if (flag == 1)
|
|
continue;
|
|
}
|
|
|
|
if (tty && urb->actual_length) {
|
|
tty_buffer_request_room(tty, 1);
|
|
tty_insert_flip_string(tty, (data + i), 1);
|
|
}
|
|
|
|
}
|
|
tty_flip_buffer_push(tty);
|
|
}
|
|
|
|
/* 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",
|
|
__func__, result);
|
|
else {
|
|
if (tty && RxCount)
|
|
flip_that(tty, index, serial);
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
static void qt_read_bulk_callback(struct urb *urb)
|
|
{
|
|
|
|
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
|
|
|
|
if (urb->status) {
|
|
port->ReadBulkStopped = 1;
|
|
mydbg("%s - nonzero write bulk status received: %d\n",
|
|
__func__, urb->status);
|
|
return;
|
|
}
|
|
|
|
port_sofrint((void *)port);
|
|
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. */
|
|
|
|
if (tty && urb->actual_length) {
|
|
tty_buffer_request_room(tty, 1);
|
|
tty_insert_flip_string(tty, &Data, 1);
|
|
/* tty_flip_buffer_push(tty); */
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
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 |
|
|
SERIAL_LSR_BI);
|
|
return;
|
|
}
|
|
|
|
static void ProcessModemStatus(struct usb_serial_port *port,
|
|
unsigned char modem_status)
|
|
{
|
|
|
|
port->shadowMSR = modem_status;
|
|
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", __func__);
|
|
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];
|
|
usb_unlink_urb(port->read_urb);
|
|
usb_free_urb(port->read_urb);
|
|
kfree(port->bulk_in_buffer);
|
|
}
|
|
for (i = 0; i < serial->num_bulk_out; ++i) {
|
|
port = &serial->port[i];
|
|
usb_unlink_urb(port->write_urb);
|
|
usb_free_urb(port->write_urb);
|
|
kfree(port->bulk_out_buffer);
|
|
}
|
|
for (i = 0; i < serial->num_interrupt_in; ++i) {
|
|
port = &serial->port[i];
|
|
usb_unlink_urb(port->interrupt_in_urb);
|
|
usb_free_urb(port->interrupt_in_urb);
|
|
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 {
|
|
dev_info(&interface->dev, "device disconnected");
|
|
}
|
|
|
|
}
|
|
|
|
static struct usb_serial *get_serial_by_minor(unsigned int minor)
|
|
{
|
|
return serial_table[minor];
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Driver tty interface functions
|
|
*****************************************************************************/
|
|
static int serial_open(struct tty_struct *tty, struct file *filp)
|
|
{
|
|
struct usb_serial *serial;
|
|
struct usb_serial_port *port;
|
|
unsigned int portNumber;
|
|
int retval = 0;
|
|
|
|
mydbg("%s\n", __func__);
|
|
|
|
/* initialize the pointer incase something fails */
|
|
tty->driver_data = NULL;
|
|
|
|
/* get the serial object associated with this tty pointer */
|
|
/* serial = get_serial_by_minor (MINOR(tty->device)); */
|
|
|
|
/* get the serial object associated with this tty pointer */
|
|
serial = get_serial_by_minor(tty->index);
|
|
|
|
if (serial_paranoia_check(serial, __func__))
|
|
return -ENODEV;
|
|
|
|
/* 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;
|
|
|
|
++port->open_count;
|
|
if (port->open_count == 1) {
|
|
port->closePending = 0;
|
|
mydbg("%s port->closepending = 0\n", __func__);
|
|
|
|
port->RxHolding = 0;
|
|
mydbg("%s port->RxHolding = 0\n", __func__);
|
|
|
|
retval = qt_open(tty, port, filp);
|
|
}
|
|
|
|
if (retval)
|
|
port->open_count = 0;
|
|
mydbg("%s returning port->closePending = %d\n", __func__,
|
|
port->closePending);
|
|
|
|
up(&port->sem);
|
|
return retval;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*device's specific driver functions
|
|
*****************************************************************************/
|
|
static int qt_open(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *filp)
|
|
{
|
|
struct usb_serial *serial = port->serial;
|
|
int result = 0;
|
|
unsigned int index;
|
|
struct qt_get_device_data DeviceData;
|
|
struct qt_open_channel_data ChannelData;
|
|
unsigned short default_divisor = 0x30; /* gives 9600 baud rate */
|
|
unsigned char default_LCR = SERIAL_8_DATA; /* 8, none , 1 */
|
|
int status = 0;
|
|
|
|
if (port_paranoia_check(port, __func__))
|
|
return -ENODEV;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
index = tty->index - serial->minor;
|
|
|
|
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", __func__,
|
|
serial->num_OpenCount);
|
|
/* Open uart channel */
|
|
|
|
/* Port specific setups */
|
|
status = BoxOPenCloseChannel(serial, index, 1, &ChannelData);
|
|
if (status < 0) {
|
|
mydbg(__FILE__ "BoxOPenCloseChannel failed\n");
|
|
return status;
|
|
}
|
|
mydbg(__FILE__ "BoxOPenCloseChannel completed.\n");
|
|
|
|
port->shadowLSR = ChannelData.line_status &
|
|
(SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
|
|
|
|
port->shadowMSR = ChannelData.modem_status &
|
|
(SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
|
|
|
|
/* Set Baud rate to default and turn off (default)flow control here */
|
|
status = BoxSetUart(serial, index, 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(tty, port, NULL);
|
|
|
|
/* Initialize the wait que head */
|
|
init_waitqueue_head(&(port->wait));
|
|
|
|
/* if we have a bulk endpoint, start reading from it */
|
|
if (serial->num_bulk_in) {
|
|
/* Start reading from the device */
|
|
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);
|
|
|
|
port->ReadBulkStopped = 0;
|
|
|
|
result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
|
|
|
|
if (result) {
|
|
err("%s - failed resubmitting read urb, error %d\n",
|
|
__func__, result);
|
|
port->ReadBulkStopped = 1;
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void serial_close(struct tty_struct *tty, struct file *filp)
|
|
{
|
|
struct usb_serial_port *port =
|
|
tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
|
|
if (!serial)
|
|
return;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
/* if disconnect beat us to the punch here, there's nothing to do */
|
|
if (tty->driver_data) {
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not opened\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
--port->open_count;
|
|
if (port->open_count <= 0) {
|
|
port->closePending = 1;
|
|
mydbg("%s - port->closePending = 1\n", __func__);
|
|
|
|
if (serial->dev) {
|
|
qt_close(tty, port, filp);
|
|
port->open_count = 0;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
|
|
mydbg("%s - %d return\n", __func__, port->number);
|
|
|
|
}
|
|
|
|
static void qt_close(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *filp)
|
|
{
|
|
unsigned long jift = jiffies + 10 * HZ;
|
|
u8 lsr, mcr;
|
|
struct usb_serial *serial = port->serial;
|
|
int status;
|
|
unsigned int index;
|
|
|
|
struct qt_open_channel_data ChannelData;
|
|
status = 0;
|
|
lsr = 0;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
index = 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, index, LINE_STATUS_REGISTER, &lsr);
|
|
if (status < 0) {
|
|
mydbg(__FILE__ "box_get_device failed\n");
|
|
break;
|
|
}
|
|
|
|
if ((lsr & SERIAL_LSR_TEMT)
|
|
&& (port->ReadBulkStopped == 1))
|
|
break;
|
|
schedule();
|
|
|
|
}
|
|
while (jiffies <= jift);
|
|
|
|
if (jiffies > jift)
|
|
mydbg("%s - port %d timout of checking transmitter empty\n",
|
|
__func__, port->number);
|
|
else
|
|
mydbg("%s - port %d checking transmitter empty succeded\n",
|
|
__func__, port->number);
|
|
|
|
status =
|
|
BoxGetRegister(serial, index, MODEM_CONTROL_REGISTER,
|
|
&mcr);
|
|
mydbg(__FILE__ "BoxGetRegister MCR = 0x%x.\n", mcr);
|
|
|
|
if (status >= 0) {
|
|
mcr &= ~(SERIAL_MCR_DTR | SERIAL_MCR_RTS);
|
|
/* status = BoxSetRegister(serial, index, MODEM_CONTROL_REGISTER, mcr); */
|
|
}
|
|
|
|
/* Close uart channel */
|
|
status = BoxOPenCloseChannel(serial, index, 0, &ChannelData);
|
|
if (status < 0)
|
|
mydbg("%s - port %d BoxOPenCloseChannel failed.\n",
|
|
__func__, port->number);
|
|
|
|
serial->num_OpenCount--;
|
|
|
|
}
|
|
|
|
static int serial_write(struct tty_struct *tty, const unsigned char *buf,
|
|
int count)
|
|
{
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial;
|
|
int retval = -EINVAL;
|
|
unsigned int index;
|
|
|
|
serial = get_usb_serial(port, __func__);
|
|
if (serial == NULL)
|
|
return -ENODEV;
|
|
/* This can happen if we get disconnected a */
|
|
if (port->open_count == 0)
|
|
return -ENODEV;
|
|
index = tty->index - serial->minor;
|
|
|
|
mydbg("%s - port %d, %d byte(s)\n", __func__, port->number, count);
|
|
mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not opened\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
retval = qt_write(tty, port, buf, count);
|
|
|
|
exit:
|
|
return retval;
|
|
}
|
|
|
|
static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|
const unsigned char *buf, int count)
|
|
{
|
|
int result;
|
|
unsigned int index;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
|
|
if (serial == NULL)
|
|
return -ENODEV;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (count == 0) {
|
|
mydbg("%s - write request of 0 bytes\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
index = 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", __func__);
|
|
return 0;
|
|
}
|
|
|
|
count =
|
|
(count > port->bulk_out_size) ? port->bulk_out_size : count;
|
|
memcpy(port->write_urb->transfer_buffer, buf, count);
|
|
|
|
/* usb_serial_debug_data(__FILE__, __func__, 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 */
|
|
result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
|
|
if (result)
|
|
mydbg("%s - failed submitting write urb, error %d\n",
|
|
__func__, result);
|
|
else
|
|
result = count;
|
|
|
|
return result;
|
|
}
|
|
|
|
/* no bulk out, so return 0 bytes written */
|
|
return 0;
|
|
}
|
|
|
|
static void qt_write_bulk_callback(struct urb *urb)
|
|
{
|
|
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!serial) {
|
|
mydbg("%s - bad serial pointer, exiting\n", __func__);
|
|
return;
|
|
}
|
|
|
|
if (urb->status) {
|
|
mydbg("%s - nonzero write bulk status received: %d\n",
|
|
__func__, 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, __func__);
|
|
struct tty_struct *tty;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!serial)
|
|
return;
|
|
|
|
tty = port->tty;
|
|
if (!tty)
|
|
return;
|
|
#if 0
|
|
if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP))
|
|
&& tty->ldisc.write_wakeup) {
|
|
mydbg("%s - write wakeup call.\n", __func__);
|
|
(tty->ldisc.write_wakeup) (tty);
|
|
}
|
|
#endif
|
|
|
|
wake_up_interruptible(&tty->write_wait);
|
|
}
|
|
static int serial_write_room(struct tty_struct *tty)
|
|
{
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
int retval = -EINVAL;
|
|
|
|
if (!serial)
|
|
return -ENODEV;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
retval = qt_write_room(port);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return retval;
|
|
}
|
|
static int qt_write_room(struct usb_serial_port *port)
|
|
{
|
|
struct usb_serial *serial = port->serial;
|
|
int room = 0;
|
|
if (port->closePending == 1) {
|
|
mydbg("%s - port->closePending == 1\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (serial->num_bulk_out) {
|
|
if (port->write_urb->status != -EINPROGRESS)
|
|
room = port->bulk_out_size;
|
|
}
|
|
|
|
mydbg("%s - returns %d\n", __func__, room);
|
|
return room;
|
|
}
|
|
static int serial_chars_in_buffer(struct tty_struct *tty)
|
|
{
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
int retval = -EINVAL;
|
|
|
|
if (!serial)
|
|
return -ENODEV;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s = port %d\n", __func__, port->number);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
retval = qt_chars_in_buffer(port);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return retval;
|
|
}
|
|
|
|
static int qt_chars_in_buffer(struct usb_serial_port *port)
|
|
{
|
|
struct usb_serial *serial = port->serial;
|
|
int chars = 0;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (serial->num_bulk_out) {
|
|
if (port->write_urb->status == -EINPROGRESS)
|
|
chars = port->write_urb->transfer_buffer_length;
|
|
}
|
|
|
|
mydbg("%s - returns %d\n", __func__, chars);
|
|
return chars;
|
|
}
|
|
|
|
static int serial_tiocmset(struct tty_struct *tty, struct file *file,
|
|
unsigned int set, unsigned int clear)
|
|
{
|
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
int retval = -ENODEV;
|
|
unsigned int index;
|
|
mydbg("In %s \n", __func__);
|
|
|
|
if (!serial)
|
|
return -ENODEV;
|
|
|
|
index = tty->index - serial->minor;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d \n", __func__, port->number);
|
|
mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
retval = qt_tiocmset(tty, port, file, set);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return retval;
|
|
}
|
|
|
|
static int qt_tiocmset(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *file, unsigned int value)
|
|
{
|
|
|
|
u8 mcr;
|
|
int status;
|
|
unsigned int index;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
|
|
if (serial == NULL)
|
|
return -ENODEV;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
/**************************************************************************************/
|
|
/** TIOCMGET
|
|
*/
|
|
index = tty->index - serial->minor;
|
|
status =
|
|
BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
|
|
&mcr);
|
|
if (status < 0)
|
|
return -ESPIPE;
|
|
|
|
/*
|
|
* Turn off the RTS and DTR and loopbcck and then only turn on what was
|
|
* asked for
|
|
*/
|
|
mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
|
|
if (value & TIOCM_RTS)
|
|
mcr |= SERIAL_MCR_RTS;
|
|
if (value & TIOCM_DTR)
|
|
mcr |= SERIAL_MCR_DTR;
|
|
if (value & TIOCM_LOOP)
|
|
mcr |= SERIAL_MCR_LOOP;
|
|
|
|
status =
|
|
BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
|
|
mcr);
|
|
if (status < 0)
|
|
return -ESPIPE;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static int serial_tiocmget(struct tty_struct *tty, struct file *file)
|
|
{
|
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
int retval = -ENODEV;
|
|
unsigned int index;
|
|
mydbg("In %s \n", __func__);
|
|
|
|
if (!serial)
|
|
return -ENODEV;
|
|
|
|
index = tty->index - serial->minor;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
retval = qt_tiocmget(tty, port, file);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return retval;
|
|
}
|
|
|
|
static int qt_tiocmget(struct tty_struct *tty,
|
|
struct usb_serial_port *port, struct file *file)
|
|
{
|
|
|
|
u8 mcr;
|
|
u8 msr;
|
|
unsigned int result = 0;
|
|
int status;
|
|
unsigned int index;
|
|
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
if (serial == NULL)
|
|
return -ENODEV;
|
|
|
|
mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
|
|
|
|
/**************************************************************************************/
|
|
/** TIOCMGET
|
|
*/
|
|
index = tty->index - serial->minor;
|
|
status =
|
|
BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
|
|
&mcr);
|
|
if (status >= 0) {
|
|
status =
|
|
BoxGetRegister(port->serial, index,
|
|
MODEM_STATUS_REGISTER, &msr);
|
|
|
|
}
|
|
|
|
if (status >= 0) {
|
|
result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
|
|
/* DTR IS SET */
|
|
| ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
|
|
/* RTS IS SET */
|
|
| ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
|
|
/* CTS is set */
|
|
| ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
|
|
/* Carrier detect is set */
|
|
| ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
|
|
/* Ring indicator set */
|
|
| ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
|
|
/* DSR is set */
|
|
return result;
|
|
|
|
} else
|
|
return -ESPIPE;
|
|
}
|
|
|
|
static int serial_ioctl(struct tty_struct *tty, struct file *file,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
int retval = -ENODEV;
|
|
unsigned int index;
|
|
mydbg("In %s \n", __func__);
|
|
|
|
if (!serial)
|
|
return -ENODEV;
|
|
|
|
index = tty->index - serial->minor;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d, cmd 0x%.4x\n", __func__, port->number, cmd);
|
|
mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
retval = qt_ioctl(tty, port, file, cmd, arg);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return retval;
|
|
}
|
|
static int qt_ioctl(struct tty_struct *tty, struct usb_serial_port *port,
|
|
struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
__u8 mcr;
|
|
__u8 msr;
|
|
unsigned short prev_msr;
|
|
unsigned int value, result = 0;
|
|
int status;
|
|
unsigned int index;
|
|
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
if (serial == NULL)
|
|
return -ENODEV;
|
|
|
|
mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
|
|
|
|
/* TIOCMGET */
|
|
index = tty->index - serial->minor;
|
|
|
|
if (cmd == TIOCMIWAIT) {
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
prev_msr = port->shadowMSR & SERIAL_MSR_MASK;
|
|
while (1) {
|
|
add_wait_queue(&port->wait, &wait);
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
schedule();
|
|
remove_wait_queue(&port->wait, &wait);
|
|
/* see if a signal woke us up */
|
|
if (signal_pending(current))
|
|
return -ERESTARTSYS;
|
|
msr = port->shadowMSR & SERIAL_MSR_MASK;
|
|
if (msr == prev_msr)
|
|
return -EIO; /* no change error */
|
|
|
|
if ((arg & TIOCM_RNG
|
|
&& ((prev_msr & SERIAL_MSR_RI) ==
|
|
(msr & SERIAL_MSR_RI)))
|
|
|| (arg & TIOCM_DSR
|
|
&& ((prev_msr & SERIAL_MSR_DSR) ==
|
|
(msr & SERIAL_MSR_DSR)))
|
|
|| (arg & TIOCM_CD
|
|
&& ((prev_msr & SERIAL_MSR_CD) ==
|
|
(msr & SERIAL_MSR_CD)))
|
|
|| (arg & TIOCM_CTS
|
|
&& ((prev_msr & SERIAL_MSR_CTS) ==
|
|
(msr & SERIAL_MSR_CTS)))) {
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
mydbg("%s -No ioctl for that one. port = %d\n", __func__,
|
|
port->number);
|
|
|
|
return -ENOIOCTLCMD;
|
|
}
|
|
|
|
static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
|
|
{
|
|
struct usb_serial_port *port =
|
|
tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
|
|
if (!serial)
|
|
return;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
/* pass on to the driver specific version of this function if it is available */
|
|
qt_set_termios(tty, port, old);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
}
|
|
|
|
static void qt_set_termios(struct tty_struct *tty,
|
|
struct usb_serial_port *port,
|
|
struct ktermios *old_termios)
|
|
{
|
|
unsigned int cflag;
|
|
int baud, divisor, remainder;
|
|
unsigned char new_LCR = 0;
|
|
int status;
|
|
struct usb_serial *serial;
|
|
__u16 index;
|
|
__u16 tmp, tmp2;
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
tmp = port->tty->index;
|
|
mydbg("%s - MINOR(port->tty->index) = %d\n", __func__, tmp);
|
|
|
|
serial = port->serial;
|
|
tmp2 = serial->minor;
|
|
mydbg("%s - serial->minor = %d\n", __func__, tmp2);
|
|
|
|
index = port->tty->index - serial->minor;
|
|
|
|
cflag = tty->termios->c_cflag;
|
|
|
|
mydbg("%s - 3\n", __func__);
|
|
|
|
switch (cflag) {
|
|
case CS5:
|
|
new_LCR |= SERIAL_5_DATA;
|
|
break;
|
|
case CS6:
|
|
new_LCR |= SERIAL_6_DATA;
|
|
break;
|
|
case CS7:
|
|
new_LCR |= SERIAL_7_DATA;
|
|
break;
|
|
default:
|
|
case CS8:
|
|
new_LCR |= SERIAL_8_DATA;
|
|
break;
|
|
}
|
|
|
|
/* Parity stuff */
|
|
if (cflag & PARENB) {
|
|
if (cflag & PARODD)
|
|
new_LCR |= SERIAL_ODD_PARITY;
|
|
else
|
|
new_LCR |= SERIAL_EVEN_PARITY;
|
|
}
|
|
if (cflag & CSTOPB)
|
|
new_LCR |= SERIAL_TWO_STOPB;
|
|
else
|
|
new_LCR |= SERIAL_TWO_STOPB;
|
|
|
|
mydbg("%s - 4\n", __func__);
|
|
/* Thats the LCR stuff, go ahead and set it */
|
|
baud = tty_get_baud_rate(tty);
|
|
if (!baud)
|
|
/* pick a default, any default... */
|
|
baud = 9600;
|
|
|
|
mydbg("%s - got baud = %d\n", __func__, baud);
|
|
|
|
divisor = MAX_BAUD_RATE / baud;
|
|
remainder = MAX_BAUD_RATE % baud;
|
|
/* Round to nearest divisor */
|
|
if (((remainder * 2) >= baud) && (baud != 110))
|
|
divisor++;
|
|
|
|
/*
|
|
* Set Baud rate to default and turn off (default)flow control here
|
|
*/
|
|
status = BoxSetUart(serial, index, (unsigned short)divisor, new_LCR);
|
|
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", __func__,
|
|
port->number);
|
|
|
|
/* Enable RTS/CTS flow control */
|
|
status = BoxSetHW_FlowCtrl(serial, index, 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", __func__,
|
|
port->number);
|
|
|
|
status = BoxSetHW_FlowCtrl(serial, index, 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, index, stop_char,
|
|
start_char);
|
|
if (status < 0)
|
|
mydbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n");
|
|
|
|
} else {
|
|
/* disable SW flow control */
|
|
status = BoxDisable_SW_FlowCtrl(serial, index);
|
|
if (status < 0)
|
|
mydbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n");
|
|
|
|
}
|
|
tty->termios->c_cflag &= ~CMSPAR;
|
|
/* FIXME: Error cases should be returning the actual bits changed only */
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BoxGetRegister
|
|
* issuse a GET_REGISTER vendor-spcific request on the default control pipe
|
|
* If successful, fills in the pValue with the register value asked for
|
|
****************************************************************************/
|
|
static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
|
|
unsigned short Register_Num, __u8 *pValue)
|
|
{
|
|
int result;
|
|
__u16 current_length;
|
|
|
|
current_length = sizeof(struct qt_get_device_data);
|
|
|
|
result =
|
|
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;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BoxSetRegister
|
|
* issuse a GET_REGISTER vendor-spcific request on the default control pipe
|
|
* If successful, fills in the pValue with the register value asked for
|
|
****************************************************************************/
|
|
static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
|
|
unsigned short Register_Num, unsigned short Value)
|
|
{
|
|
int result;
|
|
unsigned short RegAndByte;
|
|
|
|
RegAndByte = Value;
|
|
RegAndByte = RegAndByte << 8;
|
|
RegAndByte = RegAndByte + Register_Num;
|
|
|
|
/*
|
|
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_GET_SET_REGISTER, 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);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* box_get_device
|
|
* Issue a GET_DEVICE vendor-specific request on the default control pipe If
|
|
* successful, fills in the qt_get_device_data structure pointed to by
|
|
* device_data, otherwise return a negative error number of the problem.
|
|
*/
|
|
static int box_get_device(struct usb_serial *serial,
|
|
struct qt_get_device_data *device_data)
|
|
{
|
|
int result;
|
|
__u16 current_length;
|
|
unsigned char *transfer_buffer;
|
|
|
|
current_length = sizeof(struct qt_get_device_data);
|
|
transfer_buffer = kmalloc(current_length, GFP_KERNEL);
|
|
if (!transfer_buffer)
|
|
return -ENOMEM;
|
|
|
|
result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
|
|
QT_SET_GET_DEVICE, 0xc0, 0, 0,
|
|
transfer_buffer, current_length, 300);
|
|
if (result > 0)
|
|
memcpy(device_data, transfer_buffer, current_length);
|
|
kfree(transfer_buffer);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* box_set_device
|
|
* Issue a SET_DEVICE vendor-specific request on the default control pipe If
|
|
* successful returns the number of bytes written, otherwise it returns a
|
|
* negative error number of the problem.
|
|
*/
|
|
static int box_set_device(struct usb_serial *serial,
|
|
struct qt_get_device_data *device_data)
|
|
{
|
|
int result;
|
|
__u16 length;
|
|
__u16 PortSettings;
|
|
|
|
PortSettings = ((__u16) (device_data->portb));
|
|
PortSettings = (PortSettings << 8);
|
|
PortSettings += ((__u16) (device_data->porta));
|
|
|
|
length = sizeof(struct qt_get_device_data);
|
|
mydbg("%s - PortSettings = 0x%x\n", __func__, PortSettings);
|
|
|
|
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_SET_GET_DEVICE, 0x40, PortSettings,
|
|
0, NULL, 0, 300);
|
|
return result;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BoxOPenCloseChannel
|
|
* This funciotn notifies the device that the device driver wishes to open a particular UART channel. its
|
|
* purpose is to allow the device driver and the device to synchronize state information.
|
|
* 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)
|
|
{
|
|
int result;
|
|
__u16 length;
|
|
__u8 Direcion;
|
|
unsigned int pipe;
|
|
length = sizeof(struct qt_open_channel_data);
|
|
|
|
/* if opening... */
|
|
if (OpenClose == 1) {
|
|
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;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BoxSetPrebufferLevel
|
|
TELLS BOX WHEN TO ASSERT FLOW CONTROL
|
|
****************************************************************************/
|
|
static int BoxSetPrebufferLevel(struct usb_serial *serial)
|
|
{
|
|
int result;
|
|
__u16 buffer_length;
|
|
|
|
buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
|
|
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
|
|
buffer_length, 0, NULL, 0, 300);
|
|
return result;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BoxSetATC
|
|
TELLS BOX WHEN TO ASSERT automatic transmitter control
|
|
****************************************************************************/
|
|
static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
|
|
{
|
|
int result;
|
|
__u16 buffer_length;
|
|
|
|
buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
|
|
|
|
result =
|
|
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
|
|
|
|
return result;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BoxSetUart
|
|
* issuse a SET_UART vendor-spcific request on the default control pipe
|
|
* If successful sets baud rate divisor and LCR value
|
|
****************************************************************************/
|
|
static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
|
|
unsigned short default_divisor, unsigned char default_LCR)
|
|
{
|
|
int result;
|
|
unsigned short UartNumandLCR;
|
|
|
|
UartNumandLCR = (default_LCR << 8) + Uart_Number;
|
|
|
|
result =
|
|
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_GET_SET_UART, 0x40, default_divisor,
|
|
UartNumandLCR, NULL, 0, 300);
|
|
|
|
return result;
|
|
}
|
|
|
|
static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
|
|
int bSet)
|
|
{
|
|
__u8 mcr = 0;
|
|
__u8 msr = 0, MOUT_Value = 0;
|
|
struct usb_serial_port *port;
|
|
unsigned int status;
|
|
|
|
port = serial->port;
|
|
|
|
if (bSet == 1) {
|
|
/* flow control, box will clear RTS line to prevent remote */
|
|
mcr = SERIAL_MCR_RTS;
|
|
} /* device from xmitting more chars */
|
|
else {
|
|
/* no flow control to remote device */
|
|
mcr = 0;
|
|
|
|
}
|
|
MOUT_Value = mcr << 8;
|
|
|
|
if (bSet == 1) {
|
|
/* flow control, box will inhibit xmit data if CTS line is
|
|
* asserted */
|
|
msr = SERIAL_MSR_CTS;
|
|
} else {
|
|
/* Box will not inhimbe xmit data due to CTS line */
|
|
msr = 0;
|
|
}
|
|
MOUT_Value |= msr;
|
|
|
|
status =
|
|
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
|
|
index, NULL, 0, 300);
|
|
return status;
|
|
|
|
}
|
|
|
|
static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index,
|
|
unsigned char stop_char, unsigned char start_char)
|
|
{
|
|
__u16 nSWflowout;
|
|
int result;
|
|
|
|
nSWflowout = start_char << 8;
|
|
nSWflowout = (unsigned short)stop_char;
|
|
|
|
result =
|
|
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
|
|
index, NULL, 0, 300);
|
|
return result;
|
|
|
|
}
|
|
static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index)
|
|
{
|
|
int result;
|
|
|
|
result =
|
|
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
|
|
NULL, 0, 300);
|
|
return result;
|
|
|
|
}
|
|
|
|
static void serial_throttle(struct tty_struct *tty)
|
|
{
|
|
struct usb_serial_port *port =
|
|
tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!serial)
|
|
return;
|
|
|
|
down(&port->sem);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
/* shut down any bulk reads that may be going on */
|
|
/* usb_unlink_urb (port->read_urb); */
|
|
/* pass on to the driver specific version of this function */
|
|
port->RxHolding = 1;
|
|
mydbg("%s - port->RxHolding = 1\n", __func__);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return;
|
|
}
|
|
|
|
static void serial_unthrottle(struct tty_struct *tty)
|
|
{
|
|
struct usb_serial_port *port =
|
|
tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
unsigned int result;
|
|
|
|
if (!serial)
|
|
return;
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
if (port->RxHolding == 1) {
|
|
mydbg("%s -port->RxHolding == 1\n", __func__);
|
|
|
|
port->RxHolding = 0;
|
|
mydbg("%s - port->RxHolding = 0\n", __func__);
|
|
|
|
/* if we have a bulk endpoint, start it up */
|
|
if ((serial->num_bulk_in) && (port->ReadBulkStopped == 1)) {
|
|
/* Start reading from the device */
|
|
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)
|
|
err("%s - failed restarting read urb, error %d",
|
|
__func__, result);
|
|
}
|
|
}
|
|
exit:
|
|
up(&port->sem);
|
|
return;
|
|
|
|
}
|
|
|
|
static int serial_break(struct tty_struct *tty, int break_state)
|
|
{
|
|
struct usb_serial_port *port = tty->driver_data;
|
|
struct usb_serial *serial = get_usb_serial(port, __func__);
|
|
u16 index, onoff;
|
|
unsigned int result;
|
|
|
|
index = tty->index - serial->minor;
|
|
if (!serial)
|
|
return -ENODEV;
|
|
|
|
if (break_state == -1)
|
|
onoff = 1;
|
|
else
|
|
onoff = 0;
|
|
|
|
down(&port->sem);
|
|
|
|
mydbg("%s - port %d\n", __func__, port->number);
|
|
|
|
if (!port->open_count) {
|
|
mydbg("%s - port not open\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
result =
|
|
usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
QT_BREAK_CONTROL, 0x40, onoff, index,
|
|
NULL, 0, 300);
|
|
|
|
exit:
|
|
up(&port->sem);
|
|
return 0;
|
|
}
|
|
|
|
static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
|
|
unsigned err;
|
|
unsigned ucOPR_NewValue, uc_Value;
|
|
int *p_Num_of_adapters, counts, index, *p_QMCR_Value;
|
|
struct identity *p_Identity_of;
|
|
struct identity Identity_of;
|
|
struct usb_serial *lastserial, *serial;
|
|
|
|
mydbg(KERN_DEBUG "ioctl_serial_usb cmd =\n");
|
|
if (_IOC_TYPE(cmd) != SERIALQT_PCI_IOC_MAGIC)
|
|
return -ENOTTY;
|
|
if (_IOC_NR(cmd) > SERIALQT_IOC_MAXNR)
|
|
return -ENOTTY;
|
|
mydbg(KERN_DEBUG "ioctl_serial_usb cmd = 0x%x\n", cmd);
|
|
err = 0;
|
|
switch (cmd) {
|
|
|
|
case SERIALQT_WRITE_QMCR:
|
|
err = -ENOTTY;
|
|
index = arg >> 16;
|
|
counts = 0;
|
|
|
|
ucOPR_NewValue = arg;
|
|
|
|
err = EmulateWriteQMCR_Reg(index, ucOPR_NewValue);
|
|
break;
|
|
|
|
case SERIALQT_READ_QMCR:
|
|
err = -ENOTTY;
|
|
p_QMCR_Value = (int *)arg;
|
|
index = arg >> 16;
|
|
counts = 0;
|
|
|
|
err = EmulateReadQMCR_Reg(index, &uc_Value);
|
|
if (err == 0)
|
|
err = put_user(uc_Value, p_QMCR_Value);
|
|
break;
|
|
|
|
case SERIALQT_GET_NUMOF_UNITS:
|
|
p_Num_of_adapters = (int *)arg;
|
|
counts = 0; /* Initialize counts to zero */
|
|
/* struct usb_serial *lastserial = serial_table[0], *serial; */
|
|
lastserial = serial_table[0];
|
|
|
|
mydbg(KERN_DEBUG "SERIALQT_GET_NUMOF_UNITS \n");
|
|
/* if first pointer is nonull, we at least have one box */
|
|
if (lastserial)
|
|
counts = 1; /* we at least have one box */
|
|
|
|
for (index = 1; index < SERIAL_TTY_MINORS; index++) {
|
|
serial = serial_table[index];
|
|
if (serial) {
|
|
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;
|
|
serial = find_the_box(Identity_of.index);
|
|
if (serial) {
|
|
err =
|
|
put_user(serial->product,
|
|
&p_Identity_of->n_identity);
|
|
|
|
}
|
|
break;
|
|
|
|
case SERIALQT_IS422_EXTENDED:
|
|
err = -ENOTTY;
|
|
mydbg(KERN_DEBUG "SERIALQT_IS422_EXTENDED \n");
|
|
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", __func__,
|
|
index, serial);
|
|
for (counts = 0; serqt_422_table[counts] != 0; counts++) {
|
|
|
|
mydbg
|
|
("%s serial->product = = 0x%x, serqt_422_table[counts] = 0x%x\n",
|
|
__func__, serial->product,
|
|
serqt_422_table[counts]);
|
|
if (serial->product == serqt_422_table[counts]) {
|
|
err = 0;
|
|
|
|
mydbg
|
|
("%s found match for 422extended\n",
|
|
__func__);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
err = -ENOTTY;
|
|
}
|
|
|
|
mydbg("%s returning err = 0x%x\n", __func__, err);
|
|
return err;
|
|
}
|
|
|
|
static struct usb_serial *find_the_box(unsigned int index)
|
|
{
|
|
struct usb_serial *lastserial, *foundserial, *serial;
|
|
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",
|
|
__func__, 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",
|
|
__func__, 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",
|
|
__func__, 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", __func__, foundserial);
|
|
return foundserial;
|
|
}
|
|
|
|
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", __func__, 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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* This bit (otherwise unused) i'll used to detect whether ATC is
|
|
* selected */
|
|
if (uc_value & QMCR_RX_EN_MASK) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* I use this for ATC control se */
|
|
uc_temp = DeviceData.portb & LOOPMODE_BITS;
|
|
|
|
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)
|
|
{
|
|
int i, result;
|
|
int status = 0;
|
|
|
|
mydbg("%s\n", __func__);
|
|
tty_set_operations(&serial_tty_driver, &serial_ops);
|
|
result = tty_register_driver(&serial_tty_driver);
|
|
if (result) {
|
|
mydbg("tty_register_driver failed error = 0x%x", result);
|
|
return result;
|
|
}
|
|
|
|
/* Initalize our global data */
|
|
for (i = 0; i < SERIAL_TTY_MINORS; ++i)
|
|
serial_table[i] = NULL;
|
|
|
|
/* register this driver with the USB subsystem */
|
|
result = usb_register(&serqt_usb_driver);
|
|
if (result < 0) {
|
|
err("usb_register failed for the " __FILE__
|
|
" driver. Error number %d", result);
|
|
return result;
|
|
}
|
|
status = 0; /* Dynamic assignment of major number */
|
|
major_number =
|
|
register_chrdev(status, "SerialQT_USB", &serialqt_usb_fops);
|
|
if (major_number < 0) {
|
|
mydbg(KERN_DEBUG "No devices found \n\n");
|
|
return -EBUSY;
|
|
} else
|
|
mydbg(KERN_DEBUG "SerQT_USB major number assignment = %d \n\n",
|
|
major_number);
|
|
|
|
printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);
|
|
return 0;
|
|
}
|
|
|
|
static void __exit serqt_usb_exit(void)
|
|
{
|
|
/* deregister this driver with the USB subsystem */
|
|
usb_deregister(&serqt_usb_driver);
|
|
tty_unregister_driver(&serial_tty_driver);
|
|
unregister_chrdev(major_number, "SerialQT_USB");
|
|
}
|
|
|
|
module_init(serqt_usb_init);
|
|
module_exit(serqt_usb_exit);
|
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
MODULE_LICENSE("GPL");
|