Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1 | /* |
Greg Kroah-Hartman | c3858cb | 2009-01-29 16:41:35 -0800 | [diff] [blame] | 2 | * Aten 2011 USB serial driver for 4 port devices |
| 3 | * |
| 4 | * Copyright (C) 2000 Inside Out Networks |
| 5 | * Copyright (C) 2001-2002, 2009 Greg Kroah-Hartman <greg@kroah.com> |
| 6 | * Copyright (C) 2009 Novell Inc. |
| 7 | * |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License as published by |
| 10 | * the Free Software Foundation; either version 2 of the License, or |
| 11 | * (at your option) any later version. |
| 12 | * |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 13 | */ |
| 14 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 15 | #include <linux/kernel.h> |
| 16 | #include <linux/errno.h> |
| 17 | #include <linux/init.h> |
| 18 | #include <linux/slab.h> |
| 19 | #include <linux/tty.h> |
| 20 | #include <linux/tty_driver.h> |
| 21 | #include <linux/tty_flip.h> |
| 22 | #include <linux/module.h> |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 23 | #include <linux/serial.h> |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 24 | #include <linux/uaccess.h> |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 25 | #include <linux/usb.h> |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 26 | #include <linux/usb/serial.h> |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 27 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 28 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 29 | #define ZLP_REG1 0x3A /* Zero_Flag_Reg1 58 */ |
| 30 | #define ZLP_REG2 0x3B /* Zero_Flag_Reg2 59 */ |
| 31 | #define ZLP_REG3 0x3C /* Zero_Flag_Reg3 60 */ |
| 32 | #define ZLP_REG4 0x3D /* Zero_Flag_Reg4 61 */ |
| 33 | #define ZLP_REG5 0x3E /* Zero_Flag_Reg5 62 */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 34 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 35 | /* Interrupt Rotinue Defines */ |
| 36 | #define SERIAL_IIR_RLS 0x06 |
| 37 | #define SERIAL_IIR_RDA 0x04 |
| 38 | #define SERIAL_IIR_CTI 0x0c |
| 39 | #define SERIAL_IIR_THR 0x02 |
| 40 | #define SERIAL_IIR_MS 0x00 |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 41 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 42 | /* Emulation of the bit mask on the LINE STATUS REGISTER. */ |
| 43 | #define SERIAL_LSR_DR 0x0001 |
| 44 | #define SERIAL_LSR_OE 0x0002 |
| 45 | #define SERIAL_LSR_PE 0x0004 |
| 46 | #define SERIAL_LSR_FE 0x0008 |
| 47 | #define SERIAL_LSR_BI 0x0010 |
| 48 | #define SERIAL_LSR_THRE 0x0020 |
| 49 | #define SERIAL_LSR_TEMT 0x0040 |
| 50 | #define SERIAL_LSR_FIFOERR 0x0080 |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 51 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 52 | /* MSR bit defines(place holders) */ |
| 53 | #define ATEN_MSR_DELTA_CTS 0x10 |
| 54 | #define ATEN_MSR_DELTA_DSR 0x20 |
| 55 | #define ATEN_MSR_DELTA_RI 0x40 |
| 56 | #define ATEN_MSR_DELTA_CD 0x80 |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 57 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 58 | /* Serial Port register Address */ |
| 59 | #define RECEIVE_BUFFER_REGISTER ((__u16)(0x00)) |
| 60 | #define TRANSMIT_HOLDING_REGISTER ((__u16)(0x00)) |
| 61 | #define INTERRUPT_ENABLE_REGISTER ((__u16)(0x01)) |
| 62 | #define INTERRUPT_IDENT_REGISTER ((__u16)(0x02)) |
| 63 | #define FIFO_CONTROL_REGISTER ((__u16)(0x02)) |
| 64 | #define LINE_CONTROL_REGISTER ((__u16)(0x03)) |
| 65 | #define MODEM_CONTROL_REGISTER ((__u16)(0x04)) |
| 66 | #define LINE_STATUS_REGISTER ((__u16)(0x05)) |
| 67 | #define MODEM_STATUS_REGISTER ((__u16)(0x06)) |
| 68 | #define SCRATCH_PAD_REGISTER ((__u16)(0x07)) |
| 69 | #define DIVISOR_LATCH_LSB ((__u16)(0x00)) |
| 70 | #define DIVISOR_LATCH_MSB ((__u16)(0x01)) |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 71 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 72 | #define SP1_REGISTER ((__u16)(0x00)) |
| 73 | #define CONTROL1_REGISTER ((__u16)(0x01)) |
| 74 | #define CLK_MULTI_REGISTER ((__u16)(0x02)) |
| 75 | #define CLK_START_VALUE_REGISTER ((__u16)(0x03)) |
| 76 | #define DCR1_REGISTER ((__u16)(0x04)) |
| 77 | #define GPIO_REGISTER ((__u16)(0x07)) |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 78 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 79 | #define SERIAL_LCR_DLAB ((__u16)(0x0080)) |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 80 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 81 | /* |
| 82 | * URB POOL related defines |
| 83 | */ |
| 84 | #define NUM_URBS 16 /* URB Count */ |
| 85 | #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 86 | |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 87 | #define USB_VENDOR_ID_ATENINTL 0x0557 |
| 88 | #define ATENINTL_DEVICE_ID_2011 0x2011 |
| 89 | #define ATENINTL_DEVICE_ID_7820 0x7820 |
| 90 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 91 | static struct usb_device_id id_table[] = { |
| 92 | { USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_2011) }, |
| 93 | { USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_7820) }, |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 94 | { } /* terminating entry */ |
| 95 | }; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 96 | MODULE_DEVICE_TABLE(usb, id_table); |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 97 | |
| 98 | /* This structure holds all of the local port information */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 99 | struct ATENINTL_port { |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 100 | int port_num; /*Actual port number in the device(1,2,etc)*/ |
| 101 | __u8 bulk_out_endpoint; /* the bulk out endpoint handle */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 102 | unsigned char *bulk_out_buffer; /* buffer used for the bulk out endpoint */ |
| 103 | struct urb *write_urb; /* write URB for this port */ |
| 104 | __u8 bulk_in_endpoint; /* the bulk in endpoint handle */ |
| 105 | unsigned char *bulk_in_buffer; /* the buffer we use for the bulk in endpoint */ |
| 106 | struct urb *read_urb; /* read URB for this port */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 107 | __u8 shadowLCR; /* last LCR value received */ |
| 108 | __u8 shadowMCR; /* last MCR value received */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 109 | char open; |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 110 | char chaseResponsePending; |
| 111 | wait_queue_head_t wait_chase; /* for handling sleeping while waiting for chase to finish */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 112 | wait_queue_head_t wait_command; /* for handling sleeping while waiting for command to finish */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 113 | struct async_icount icount; |
| 114 | struct usb_serial_port *port; /* loop back to the owner of this object */ |
| 115 | /*Offsets*/ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 116 | __u8 SpRegOffset; |
| 117 | __u8 ControlRegOffset; |
| 118 | __u8 DcrRegOffset; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 119 | /* for processing control URBS in interrupt context */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 120 | struct urb *control_urb; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 121 | char *ctrl_buf; |
| 122 | int MsrLsr; |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 123 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 124 | struct urb *write_urb_pool[NUM_URBS]; |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 125 | /* we pass a pointer to this as the arguement sent to cypress_set_termios old_termios */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 126 | struct ktermios tmp_termios; /* stores the old termios settings */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 127 | spinlock_t lock; /* private lock */ |
| 128 | }; |
| 129 | |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 130 | /* This structure holds all of the individual serial device information */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 131 | struct ATENINTL_serial { |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 132 | __u8 interrupt_in_endpoint; /* the interrupt endpoint handle */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 133 | unsigned char *interrupt_in_buffer; /* the buffer we use for the interrupt endpoint */ |
| 134 | struct urb *interrupt_read_urb; /* our interrupt urb */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 135 | __u8 bulk_in_endpoint; /* the bulk in endpoint handle */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 136 | unsigned char *bulk_in_buffer; /* the buffer we use for the bulk in endpoint */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 137 | struct urb *read_urb; /* our bulk read urb */ |
| 138 | __u8 bulk_out_endpoint; /* the bulk out endpoint handle */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 139 | struct usb_serial *serial; /* loop back to the owner of this object */ |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 140 | int ATEN2011_spectrum_2or4ports; /* this says the number of ports in the device */ |
| 141 | /* Indicates about the no.of opened ports of an individual USB-serial adapater. */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 142 | unsigned int NoOfOpenPorts; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 143 | /* a flag for Status endpoint polling */ |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 144 | unsigned char status_polling_started; |
| 145 | }; |
| 146 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 147 | static void ATEN2011_set_termios(struct tty_struct *tty, |
| 148 | struct usb_serial_port *port, |
| 149 | struct ktermios *old_termios); |
| 150 | static void ATEN2011_change_port_settings(struct tty_struct *tty, |
| 151 | struct ATENINTL_port *ATEN2011_port, |
| 152 | struct ktermios *old_termios); |
Greg Kroah-Hartman | e5ce610 | 2009-01-29 12:57:52 -0800 | [diff] [blame] | 153 | |
| 154 | /************************************* |
| 155 | * Bit definitions for each register * |
| 156 | *************************************/ |
| 157 | #define LCR_BITS_5 0x00 /* 5 bits/char */ |
| 158 | #define LCR_BITS_6 0x01 /* 6 bits/char */ |
| 159 | #define LCR_BITS_7 0x02 /* 7 bits/char */ |
| 160 | #define LCR_BITS_8 0x03 /* 8 bits/char */ |
| 161 | #define LCR_BITS_MASK 0x03 /* Mask for bits/char field */ |
| 162 | |
| 163 | #define LCR_STOP_1 0x00 /* 1 stop bit */ |
| 164 | #define LCR_STOP_1_5 0x04 /* 1.5 stop bits (if 5 bits/char) */ |
| 165 | #define LCR_STOP_2 0x04 /* 2 stop bits (if 6-8 bits/char) */ |
| 166 | #define LCR_STOP_MASK 0x04 /* Mask for stop bits field */ |
| 167 | |
| 168 | #define LCR_PAR_NONE 0x00 /* No parity */ |
| 169 | #define LCR_PAR_ODD 0x08 /* Odd parity */ |
| 170 | #define LCR_PAR_EVEN 0x18 /* Even parity */ |
| 171 | #define LCR_PAR_MARK 0x28 /* Force parity bit to 1 */ |
| 172 | #define LCR_PAR_SPACE 0x38 /* Force parity bit to 0 */ |
| 173 | #define LCR_PAR_MASK 0x38 /* Mask for parity field */ |
| 174 | |
| 175 | #define LCR_SET_BREAK 0x40 /* Set Break condition */ |
| 176 | #define LCR_DL_ENABLE 0x80 /* Enable access to divisor latch */ |
| 177 | |
| 178 | #define MCR_DTR 0x01 /* Assert DTR */ |
| 179 | #define MCR_RTS 0x02 /* Assert RTS */ |
| 180 | #define MCR_OUT1 0x04 /* Loopback only: Sets state of RI */ |
| 181 | #define MCR_MASTER_IE 0x08 /* Enable interrupt outputs */ |
| 182 | #define MCR_LOOPBACK 0x10 /* Set internal (digital) loopback mode */ |
| 183 | #define MCR_XON_ANY 0x20 /* Enable any char to exit XOFF mode */ |
| 184 | |
| 185 | #define ATEN2011_MSR_CTS 0x10 /* Current state of CTS */ |
| 186 | #define ATEN2011_MSR_DSR 0x20 /* Current state of DSR */ |
| 187 | #define ATEN2011_MSR_RI 0x40 /* Current state of RI */ |
| 188 | #define ATEN2011_MSR_CD 0x80 /* Current state of CD */ |
| 189 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 190 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 191 | static int debug; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 192 | |
| 193 | /* |
| 194 | * Version Information |
| 195 | */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 196 | #define DRIVER_VERSION "2.0" |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 197 | #define DRIVER_DESC "ATENINTL 2011 USB Serial Adapter" |
| 198 | |
| 199 | /* |
| 200 | * Defines used for sending commands to port |
| 201 | */ |
| 202 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 203 | #define ATEN_WDR_TIMEOUT (50) /* default urb timeout */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 204 | |
| 205 | /* Requests */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 206 | #define ATEN_RD_RTYPE 0xC0 |
| 207 | #define ATEN_WR_RTYPE 0x40 |
| 208 | #define ATEN_RDREQ 0x0D |
| 209 | #define ATEN_WRREQ 0x0E |
| 210 | #define ATEN_CTRL_TIMEOUT 500 |
| 211 | #define VENDOR_READ_LENGTH (0x01) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 212 | |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 213 | /* set to 1 for RS485 mode and 0 for RS232 mode */ |
| 214 | /* FIXME make this somehow dynamic and not build time specific */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 215 | static int RS485mode; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 216 | |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 217 | static int set_reg_sync(struct usb_serial_port *port, __u16 reg, __u16 val) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 218 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 219 | struct usb_device *dev = port->serial->dev; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 220 | val = val & 0x00ff; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 221 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 222 | dbg("%s: is %x, value %x", __func__, reg, val); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 223 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 224 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ATEN_WRREQ, |
| 225 | ATEN_WR_RTYPE, val, reg, NULL, 0, |
| 226 | ATEN_WDR_TIMEOUT); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 227 | } |
| 228 | |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 229 | static int get_reg_sync(struct usb_serial_port *port, __u16 reg, __u16 *val) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 230 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 231 | struct usb_device *dev = port->serial->dev; |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 232 | int ret; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 233 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 234 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ATEN_RDREQ, |
| 235 | ATEN_RD_RTYPE, 0, reg, val, VENDOR_READ_LENGTH, |
| 236 | ATEN_WDR_TIMEOUT); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 237 | dbg("%s: offset is %x, return val %x", __func__, reg, *val); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 238 | *val = (*val) & 0x00ff; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 239 | return ret; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 240 | } |
| 241 | |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 242 | static int set_uart_reg(struct usb_serial_port *port, __u16 reg, __u16 val) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 243 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 244 | struct usb_device *dev = port->serial->dev; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 245 | struct ATENINTL_serial *a_serial; |
| 246 | __u16 minor; |
| 247 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 248 | a_serial = usb_get_serial_data(port->serial); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 249 | minor = port->serial->minor; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 250 | if (minor == SERIAL_TTY_NO_MINOR) |
| 251 | minor = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 252 | val = val & 0x00ff; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 253 | |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 254 | /* |
| 255 | * For the UART control registers, |
| 256 | * the application number need to be Or'ed |
| 257 | */ |
| 258 | if (a_serial->ATEN2011_spectrum_2or4ports == 4) |
| 259 | val |= (((__u16)port->number - minor) + 1) << 8; |
| 260 | else { |
| 261 | if (((__u16) port->number - minor) == 0) |
| 262 | val |= (((__u16)port->number - minor) + 1) << 8; |
| 263 | else |
| 264 | val |= (((__u16)port->number - minor) + 2) << 8; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 265 | } |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 266 | dbg("%s: application number is %x", __func__, val); |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 267 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 268 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ATEN_WRREQ, |
| 269 | ATEN_WR_RTYPE, val, reg, NULL, 0, |
| 270 | ATEN_WDR_TIMEOUT); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 271 | } |
| 272 | |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 273 | static int get_uart_reg(struct usb_serial_port *port, __u16 reg, __u16 *val) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 274 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 275 | struct usb_device *dev = port->serial->dev; |
| 276 | int ret = 0; |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 277 | __u16 wval; |
| 278 | struct ATENINTL_serial *a_serial; |
| 279 | __u16 minor = port->serial->minor; |
| 280 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 281 | a_serial = usb_get_serial_data(port->serial); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 282 | if (minor == SERIAL_TTY_NO_MINOR) |
| 283 | minor = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 284 | |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 285 | /* wval is same as application number */ |
| 286 | if (a_serial->ATEN2011_spectrum_2or4ports == 4) |
| 287 | wval = (((__u16)port->number - minor) + 1) << 8; |
| 288 | else { |
| 289 | if (((__u16) port->number - minor) == 0) |
| 290 | wval = (((__u16) port->number - minor) + 1) << 8; |
| 291 | else |
| 292 | wval = (((__u16) port->number - minor) + 2) << 8; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 293 | } |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 294 | dbg("%s: application number is %x", __func__, wval); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 295 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ATEN_RDREQ, |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 296 | ATEN_RD_RTYPE, wval, reg, val, VENDOR_READ_LENGTH, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 297 | ATEN_WDR_TIMEOUT); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 298 | *val = (*val) & 0x00ff; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 299 | return ret; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 300 | } |
| 301 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 302 | static int handle_newMsr(struct ATENINTL_port *port, __u8 newMsr) |
| 303 | { |
| 304 | struct ATENINTL_port *ATEN2011_port; |
| 305 | struct async_icount *icount; |
| 306 | ATEN2011_port = port; |
| 307 | icount = &ATEN2011_port->icount; |
| 308 | if (newMsr & |
| 309 | (ATEN_MSR_DELTA_CTS | ATEN_MSR_DELTA_DSR | ATEN_MSR_DELTA_RI | |
| 310 | ATEN_MSR_DELTA_CD)) { |
| 311 | icount = &ATEN2011_port->icount; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 312 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 313 | /* update input line counters */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 314 | if (newMsr & ATEN_MSR_DELTA_CTS) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 315 | icount->cts++; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 316 | if (newMsr & ATEN_MSR_DELTA_DSR) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 317 | icount->dsr++; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 318 | if (newMsr & ATEN_MSR_DELTA_CD) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 319 | icount->dcd++; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 320 | if (newMsr & ATEN_MSR_DELTA_RI) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 321 | icount->rng++; |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 322 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 323 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 324 | return 0; |
| 325 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 326 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 327 | static int handle_newLsr(struct ATENINTL_port *port, __u8 newLsr) |
| 328 | { |
| 329 | struct async_icount *icount; |
| 330 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 331 | dbg("%s - %02x", __func__, newLsr); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 332 | |
| 333 | if (newLsr & SERIAL_LSR_BI) { |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 334 | /* |
| 335 | * Parity and Framing errors only count if they occur exclusive |
| 336 | * of a break being received. |
| 337 | */ |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 338 | newLsr &= (__u8) (SERIAL_LSR_OE | SERIAL_LSR_BI); |
| 339 | } |
| 340 | |
| 341 | /* update input line counters */ |
| 342 | icount = &port->icount; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 343 | if (newLsr & SERIAL_LSR_BI) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 344 | icount->brk++; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 345 | if (newLsr & SERIAL_LSR_OE) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 346 | icount->overrun++; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 347 | if (newLsr & SERIAL_LSR_PE) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 348 | icount->parity++; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 349 | if (newLsr & SERIAL_LSR_FE) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 350 | icount->frame++; |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 351 | |
| 352 | return 0; |
| 353 | } |
| 354 | |
| 355 | static void ATEN2011_control_callback(struct urb *urb) |
| 356 | { |
| 357 | unsigned char *data; |
| 358 | struct ATENINTL_port *ATEN2011_port; |
| 359 | __u8 regval = 0x0; |
| 360 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 361 | switch (urb->status) { |
| 362 | case 0: |
| 363 | /* success */ |
| 364 | break; |
| 365 | case -ECONNRESET: |
| 366 | case -ENOENT: |
| 367 | case -ESHUTDOWN: |
| 368 | /* this urb is terminated, clean up */ |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 369 | dbg("%s - urb shutting down with status: %d", __func__, |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 370 | urb->status); |
| 371 | return; |
| 372 | default: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 373 | dbg("%s - nonzero urb status received: %d", __func__, |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 374 | urb->status); |
| 375 | goto exit; |
| 376 | } |
| 377 | |
| 378 | ATEN2011_port = (struct ATENINTL_port *)urb->context; |
| 379 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 380 | dbg("%s urb buffer size is %d", __func__, urb->actual_length); |
| 381 | dbg("%s ATEN2011_port->MsrLsr is %d port %d", __func__, |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 382 | ATEN2011_port->MsrLsr, ATEN2011_port->port_num); |
| 383 | data = urb->transfer_buffer; |
| 384 | regval = (__u8) data[0]; |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 385 | dbg("%s data is %x", __func__, regval); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 386 | if (ATEN2011_port->MsrLsr == 0) |
| 387 | handle_newMsr(ATEN2011_port, regval); |
| 388 | else if (ATEN2011_port->MsrLsr == 1) |
| 389 | handle_newLsr(ATEN2011_port, regval); |
| 390 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 391 | exit: |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 392 | return; |
| 393 | } |
| 394 | |
| 395 | static int ATEN2011_get_reg(struct ATENINTL_port *ATEN, __u16 Wval, __u16 reg, |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 396 | __u16 *val) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 397 | { |
| 398 | struct usb_device *dev = ATEN->port->serial->dev; |
| 399 | struct usb_ctrlrequest *dr = NULL; |
| 400 | unsigned char *buffer = NULL; |
| 401 | int ret = 0; |
| 402 | buffer = (__u8 *) ATEN->ctrl_buf; |
| 403 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 404 | dr = (void *)(buffer + 2); |
| 405 | dr->bRequestType = ATEN_RD_RTYPE; |
| 406 | dr->bRequest = ATEN_RDREQ; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 407 | dr->wValue = cpu_to_le16(Wval); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 408 | dr->wIndex = cpu_to_le16(reg); |
| 409 | dr->wLength = cpu_to_le16(2); |
| 410 | |
| 411 | usb_fill_control_urb(ATEN->control_urb, dev, usb_rcvctrlpipe(dev, 0), |
| 412 | (unsigned char *)dr, buffer, 2, |
| 413 | ATEN2011_control_callback, ATEN); |
| 414 | ATEN->control_urb->transfer_buffer_length = 2; |
| 415 | ret = usb_submit_urb(ATEN->control_urb, GFP_ATOMIC); |
| 416 | return ret; |
| 417 | } |
| 418 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 419 | static void ATEN2011_interrupt_callback(struct urb *urb) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 420 | { |
| 421 | int result; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 422 | int length; |
| 423 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 424 | struct ATENINTL_serial *ATEN2011_serial; |
| 425 | struct usb_serial *serial; |
| 426 | __u16 Data; |
| 427 | unsigned char *data; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 428 | __u8 sp[5], st; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 429 | int i; |
| 430 | __u16 wval; |
| 431 | int minor; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 432 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 433 | dbg("%s", " : Entering"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 434 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 435 | ATEN2011_serial = (struct ATENINTL_serial *)urb->context; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 436 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 437 | switch (urb->status) { |
| 438 | case 0: |
| 439 | /* success */ |
| 440 | break; |
| 441 | case -ECONNRESET: |
| 442 | case -ENOENT: |
| 443 | case -ESHUTDOWN: |
| 444 | /* this urb is terminated, clean up */ |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 445 | dbg("%s - urb shutting down with status: %d", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 446 | urb->status); |
| 447 | return; |
| 448 | default: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 449 | dbg("%s - nonzero urb status received: %d", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 450 | urb->status); |
| 451 | goto exit; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 452 | } |
| 453 | length = urb->actual_length; |
| 454 | data = urb->transfer_buffer; |
| 455 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 456 | serial = ATEN2011_serial->serial; |
| 457 | |
| 458 | /* ATENINTL get 5 bytes |
| 459 | * Byte 1 IIR Port 1 (port.number is 0) |
| 460 | * Byte 2 IIR Port 2 (port.number is 1) |
| 461 | * Byte 3 IIR Port 3 (port.number is 2) |
| 462 | * Byte 4 IIR Port 4 (port.number is 3) |
| 463 | * Byte 5 FIFO status for both */ |
| 464 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 465 | if (length && length > 5) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 466 | dbg("%s", "Wrong data !!!"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 467 | return; |
| 468 | } |
| 469 | |
| 470 | /* MATRIX */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 471 | if (ATEN2011_serial->ATEN2011_spectrum_2or4ports == 4) { |
| 472 | sp[0] = (__u8) data[0]; |
| 473 | sp[1] = (__u8) data[1]; |
| 474 | sp[2] = (__u8) data[2]; |
| 475 | sp[3] = (__u8) data[3]; |
| 476 | st = (__u8) data[4]; |
| 477 | } else { |
| 478 | sp[0] = (__u8) data[0]; |
| 479 | sp[1] = (__u8) data[2]; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 480 | /* sp[2]=(__u8)data[2]; */ |
| 481 | /* sp[3]=(__u8)data[3]; */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 482 | st = (__u8) data[4]; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 483 | |
| 484 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 485 | for (i = 0; i < serial->num_ports; i++) { |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 486 | ATEN2011_port = usb_get_serial_port_data(serial->port[i]); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 487 | minor = serial->minor; |
| 488 | if (minor == SERIAL_TTY_NO_MINOR) |
| 489 | minor = 0; |
| 490 | if ((ATEN2011_serial->ATEN2011_spectrum_2or4ports == 2) |
| 491 | && (i != 0)) |
| 492 | wval = |
| 493 | (((__u16) serial->port[i]->number - |
| 494 | (__u16) (minor)) + 2) << 8; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 495 | else |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 496 | wval = |
| 497 | (((__u16) serial->port[i]->number - |
| 498 | (__u16) (minor)) + 1) << 8; |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 499 | if (ATEN2011_port->open != 0) { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 500 | if (sp[i] & 0x01) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 501 | dbg("SP%d No Interrupt !!!", i); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 502 | } else { |
| 503 | switch (sp[i] & 0x0f) { |
| 504 | case SERIAL_IIR_RLS: |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 505 | dbg("Serial Port %d: Receiver status error or address bit detected in 9-bit mode", i); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 506 | ATEN2011_port->MsrLsr = 1; |
| 507 | ATEN2011_get_reg(ATEN2011_port, wval, |
| 508 | LINE_STATUS_REGISTER, |
| 509 | &Data); |
| 510 | break; |
| 511 | case SERIAL_IIR_MS: |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 512 | dbg("Serial Port %d: Modem status change", i); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 513 | ATEN2011_port->MsrLsr = 0; |
| 514 | ATEN2011_get_reg(ATEN2011_port, wval, |
| 515 | MODEM_STATUS_REGISTER, |
| 516 | &Data); |
| 517 | break; |
| 518 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 519 | } |
| 520 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 521 | |
| 522 | } |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 523 | exit: |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 524 | if (ATEN2011_serial->status_polling_started == 0) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 525 | return; |
| 526 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 527 | result = usb_submit_urb(urb, GFP_ATOMIC); |
| 528 | if (result) { |
| 529 | dev_err(&urb->dev->dev, |
| 530 | "%s - Error %d submitting interrupt urb\n", |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 531 | __func__, result); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 532 | } |
| 533 | |
| 534 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 535 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 536 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 537 | static void ATEN2011_bulk_in_callback(struct urb *urb) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 538 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 539 | int status; |
| 540 | unsigned char *data; |
| 541 | struct usb_serial *serial; |
| 542 | struct usb_serial_port *port; |
| 543 | struct ATENINTL_serial *ATEN2011_serial; |
| 544 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 545 | struct tty_struct *tty; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 546 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 547 | if (urb->status) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 548 | dbg("nonzero read bulk status received: %d", urb->status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 549 | return; |
| 550 | } |
| 551 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 552 | ATEN2011_port = (struct ATENINTL_port *)urb->context; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 553 | |
| 554 | port = (struct usb_serial_port *)ATEN2011_port->port; |
Greg Kroah-Hartman | f3415ee | 2009-01-30 15:31:38 -0800 | [diff] [blame] | 555 | serial = port->serial; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 556 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 557 | dbg("%s", "Entering..."); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 558 | |
| 559 | data = urb->transfer_buffer; |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 560 | ATEN2011_serial = usb_get_serial_data(serial); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 561 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 562 | if (urb->actual_length) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 563 | tty = tty_port_tty_get(&ATEN2011_port->port->port); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 564 | if (tty) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 565 | tty_buffer_request_room(tty, urb->actual_length); |
| 566 | tty_insert_flip_string(tty, data, urb->actual_length); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 567 | tty_flip_buffer_push(tty); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 568 | tty_kref_put(tty); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 569 | } |
| 570 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 571 | ATEN2011_port->icount.rx += urb->actual_length; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 572 | dbg("ATEN2011_port->icount.rx is %d:", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 573 | ATEN2011_port->icount.rx); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 574 | } |
| 575 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 576 | if (!ATEN2011_port->read_urb) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 577 | dbg("%s", "URB KILLED !!!"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 578 | return; |
| 579 | } |
| 580 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 581 | if (ATEN2011_port->read_urb->status != -EINPROGRESS) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 582 | ATEN2011_port->read_urb->dev = serial->dev; |
| 583 | |
| 584 | status = usb_submit_urb(ATEN2011_port->read_urb, GFP_ATOMIC); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 585 | if (status) |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 586 | dbg("usb_submit_urb(read bulk) failed, status = %d", status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 587 | } |
| 588 | } |
| 589 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 590 | static void ATEN2011_bulk_out_data_callback(struct urb *urb) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 591 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 592 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 593 | struct tty_struct *tty; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 594 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 595 | if (urb->status) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 596 | dbg("nonzero write bulk status received:%d", urb->status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 597 | return; |
| 598 | } |
| 599 | |
| 600 | ATEN2011_port = (struct ATENINTL_port *)urb->context; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 601 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 602 | dbg("%s", "Entering ........."); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 603 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 604 | tty = tty_port_tty_get(&ATEN2011_port->port->port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 605 | |
Alan Cox | 20aa9e9 | 2009-04-07 18:43:43 +0100 | [diff] [blame] | 606 | if (tty && ATEN2011_port->open) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 607 | /* tell the tty driver that something has changed */ |
Alan Cox | 20aa9e9 | 2009-04-07 18:43:43 +0100 | [diff] [blame] | 608 | tty_wakeup(tty); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 609 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 610 | /* schedule_work(&ATEN2011_port->port->work); */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 611 | tty_kref_put(tty); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 612 | |
| 613 | } |
| 614 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 615 | #ifdef ATENSerialProbe |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 616 | static int ATEN2011_serial_probe(struct usb_serial *serial, |
| 617 | const struct usb_device_id *id) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 618 | { |
| 619 | |
| 620 | /*need to implement the mode_reg reading and updating\ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 621 | structures usb_serial_ device_type\ |
| 622 | (i.e num_ports, num_bulkin,bulkout etc) */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 623 | /* Also we can update the changes attach */ |
| 624 | return 1; |
| 625 | } |
| 626 | #endif |
| 627 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 628 | static int ATEN2011_open(struct tty_struct *tty, struct usb_serial_port *port, |
| 629 | struct file *filp) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 630 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 631 | int response; |
| 632 | int j; |
| 633 | struct usb_serial *serial; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 634 | struct urb *urb; |
| 635 | __u16 Data; |
| 636 | int status; |
| 637 | struct ATENINTL_serial *ATEN2011_serial; |
| 638 | struct ATENINTL_port *ATEN2011_port; |
| 639 | struct ktermios tmp_termios; |
| 640 | int minor; |
Greg Kroah-Hartman | 8b4efbe | 2009-01-29 13:08:23 -0800 | [diff] [blame] | 641 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 642 | serial = port->serial; |
| 643 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 644 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 645 | |
| 646 | if (ATEN2011_port == NULL) |
| 647 | return -ENODEV; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 648 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 649 | ATEN2011_serial = usb_get_serial_data(serial); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 650 | if (ATEN2011_serial == NULL) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 651 | return -ENODEV; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 652 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 653 | /* increment the number of opened ports counter here */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 654 | ATEN2011_serial->NoOfOpenPorts++; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 655 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 656 | usb_clear_halt(serial->dev, port->write_urb->pipe); |
| 657 | usb_clear_halt(serial->dev, port->read_urb->pipe); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 658 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 659 | /* Initialising the write urb pool */ |
| 660 | for (j = 0; j < NUM_URBS; ++j) { |
| 661 | urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 662 | ATEN2011_port->write_urb_pool[j] = urb; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 663 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 664 | if (urb == NULL) { |
| 665 | err("No more urbs???"); |
| 666 | continue; |
| 667 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 668 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 669 | urb->transfer_buffer = NULL; |
| 670 | urb->transfer_buffer = |
| 671 | kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL); |
| 672 | if (!urb->transfer_buffer) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 673 | err("%s-out of memory for urb buffers.", __func__); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 674 | continue; |
| 675 | } |
| 676 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 677 | |
| 678 | /***************************************************************************** |
| 679 | * Initialize ATEN2011 -- Write Init values to corresponding Registers |
| 680 | * |
| 681 | * Register Index |
| 682 | * 1 : IER |
| 683 | * 2 : FCR |
| 684 | * 3 : LCR |
| 685 | * 4 : MCR |
| 686 | * |
| 687 | * 0x08 : SP1/2 Control Reg |
| 688 | *****************************************************************************/ |
| 689 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 690 | /* NEED to check the fallowing Block */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 691 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 692 | Data = 0x0; |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 693 | status = get_reg_sync(port, ATEN2011_port->SpRegOffset, &Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 694 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 695 | dbg("Reading Spreg failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 696 | return -1; |
| 697 | } |
| 698 | Data |= 0x80; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 699 | status = set_reg_sync(port, ATEN2011_port->SpRegOffset, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 700 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 701 | dbg("writing Spreg failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 702 | return -1; |
| 703 | } |
| 704 | |
| 705 | Data &= ~0x80; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 706 | status = set_reg_sync(port, ATEN2011_port->SpRegOffset, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 707 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 708 | dbg("writing Spreg failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 709 | return -1; |
| 710 | } |
| 711 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 712 | /* End of block to be checked */ |
| 713 | /**************************CHECK***************************/ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 714 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 715 | if (RS485mode == 0) |
| 716 | Data = 0xC0; |
| 717 | else |
| 718 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 719 | status = set_uart_reg(port, SCRATCH_PAD_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 720 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 721 | dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x", status); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 722 | return -1; |
| 723 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 724 | dbg("SCRATCH_PAD_REGISTER Writing success status%d", status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 725 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 726 | /**************************CHECK***************************/ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 727 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 728 | Data = 0x0; |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 729 | status = get_reg_sync(port, ATEN2011_port->ControlRegOffset, &Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 730 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 731 | dbg("Reading Controlreg failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 732 | return -1; |
| 733 | } |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 734 | Data |= 0x08; /* Driver done bit */ |
| 735 | Data |= 0x20; /* rx_disable */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 736 | status = 0; |
| 737 | status = |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 738 | set_reg_sync(port, ATEN2011_port->ControlRegOffset, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 739 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 740 | dbg("writing Controlreg failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 741 | return -1; |
| 742 | } |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 743 | /* |
| 744 | * do register settings here |
| 745 | * Set all regs to the device default values. |
| 746 | * First Disable all interrupts. |
| 747 | */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 748 | |
| 749 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 750 | status = set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 751 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 752 | dbg("disableing interrupts failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 753 | return -1; |
| 754 | } |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 755 | /* Set FIFO_CONTROL_REGISTER to the default value */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 756 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 757 | status = set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 758 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 759 | dbg("Writing FIFO_CONTROL_REGISTER failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 760 | return -1; |
| 761 | } |
| 762 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 763 | Data = 0xcf; /* chk */ |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 764 | status = set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 765 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 766 | dbg("Writing FIFO_CONTROL_REGISTER failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 767 | return -1; |
| 768 | } |
| 769 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 770 | Data = 0x03; /* LCR_BITS_8 */ |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 771 | status = set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 772 | ATEN2011_port->shadowLCR = Data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 773 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 774 | Data = 0x0b; /* MCR_DTR|MCR_RTS|MCR_MASTER_IE */ |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 775 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 776 | ATEN2011_port->shadowMCR = Data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 777 | |
| 778 | #ifdef Check |
| 779 | Data = 0x00; |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 780 | status = get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 781 | ATEN2011_port->shadowLCR = Data; |
| 782 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 783 | Data |= SERIAL_LCR_DLAB; /* data latch enable in LCR 0x80 */ |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 784 | status = set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 785 | |
| 786 | Data = 0x0c; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 787 | status = set_uart_reg(port, DIVISOR_LATCH_LSB, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 788 | |
| 789 | Data = 0x0; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 790 | status = set_uart_reg(port, DIVISOR_LATCH_MSB, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 791 | |
| 792 | Data = 0x00; |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 793 | status = get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 794 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 795 | /* Data = ATEN2011_port->shadowLCR; */ /* data latch disable */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 796 | Data = Data & ~SERIAL_LCR_DLAB; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 797 | status = set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 798 | ATEN2011_port->shadowLCR = Data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 799 | #endif |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 800 | /* clearing Bulkin and Bulkout Fifo */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 801 | Data = 0x0; |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 802 | status = get_reg_sync(port, ATEN2011_port->SpRegOffset, &Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 803 | |
| 804 | Data = Data | 0x0c; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 805 | status = set_reg_sync(port, ATEN2011_port->SpRegOffset, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 806 | |
| 807 | Data = Data & ~0x0c; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 808 | status = set_reg_sync(port, ATEN2011_port->SpRegOffset, Data); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 809 | /* Finally enable all interrupts */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 810 | Data = 0x0; |
| 811 | Data = 0x0c; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 812 | status = set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 813 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 814 | /* clearing rx_disable */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 815 | Data = 0x0; |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 816 | status = get_reg_sync(port, ATEN2011_port->ControlRegOffset, &Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 817 | Data = Data & ~0x20; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 818 | status = set_reg_sync(port, ATEN2011_port->ControlRegOffset, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 819 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 820 | /* rx_negate */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 821 | Data = 0x0; |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 822 | status = get_reg_sync(port, ATEN2011_port->ControlRegOffset, &Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 823 | Data = Data | 0x10; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 824 | status = 0; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 825 | status = set_reg_sync(port, ATEN2011_port->ControlRegOffset, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 826 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 827 | /* |
| 828 | * Check to see if we've set up our endpoint info yet |
| 829 | * (can't set it up in ATEN2011_startup as the structures |
| 830 | * were not set up at that time.) |
| 831 | */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 832 | if (ATEN2011_serial->NoOfOpenPorts == 1) { |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 833 | /* start the status polling here */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 834 | ATEN2011_serial->status_polling_started = 1; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 835 | /* If not yet set, Set here */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 836 | ATEN2011_serial->interrupt_in_buffer = |
| 837 | serial->port[0]->interrupt_in_buffer; |
| 838 | ATEN2011_serial->interrupt_in_endpoint = |
| 839 | serial->port[0]->interrupt_in_endpointAddress; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 840 | ATEN2011_serial->interrupt_read_urb = |
| 841 | serial->port[0]->interrupt_in_urb; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 842 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 843 | /* set up interrupt urb */ |
| 844 | usb_fill_int_urb(ATEN2011_serial->interrupt_read_urb, |
| 845 | serial->dev, |
| 846 | usb_rcvintpipe(serial->dev, |
| 847 | ATEN2011_serial-> |
| 848 | interrupt_in_endpoint), |
| 849 | ATEN2011_serial->interrupt_in_buffer, |
| 850 | ATEN2011_serial->interrupt_read_urb-> |
| 851 | transfer_buffer_length, |
| 852 | ATEN2011_interrupt_callback, ATEN2011_serial, |
| 853 | ATEN2011_serial->interrupt_read_urb->interval); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 854 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 855 | /* start interrupt read for ATEN2011 * |
| 856 | * will continue as long as ATEN2011 is connected */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 857 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 858 | response = |
| 859 | usb_submit_urb(ATEN2011_serial->interrupt_read_urb, |
| 860 | GFP_KERNEL); |
| 861 | if (response) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 862 | dbg("%s - Error %d submitting interrupt urb", |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 863 | __func__, response); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 864 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 865 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 866 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 867 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 868 | /* |
| 869 | * See if we've set up our endpoint info yet |
| 870 | * (can't set it up in ATEN2011_startup as the |
| 871 | * structures were not set up at that time.) |
| 872 | */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 873 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 874 | dbg("port number is %d", port->number); |
| 875 | dbg("serial number is %d", port->serial->minor); |
| 876 | dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress); |
| 877 | dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress); |
| 878 | dbg("Interrupt endpoint is %d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 879 | port->interrupt_in_endpointAddress); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 880 | dbg("port's number in the device is %d", ATEN2011_port->port_num); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 881 | ATEN2011_port->bulk_in_buffer = port->bulk_in_buffer; |
| 882 | ATEN2011_port->bulk_in_endpoint = port->bulk_in_endpointAddress; |
| 883 | ATEN2011_port->read_urb = port->read_urb; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 884 | ATEN2011_port->bulk_out_endpoint = port->bulk_out_endpointAddress; |
| 885 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 886 | minor = port->serial->minor; |
| 887 | if (minor == SERIAL_TTY_NO_MINOR) |
| 888 | minor = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 889 | |
| 890 | /* set up our bulk in urb */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 891 | if ((ATEN2011_serial->ATEN2011_spectrum_2or4ports == 2) |
| 892 | && (((__u16) port->number - (__u16) (minor)) != 0)) { |
| 893 | usb_fill_bulk_urb(ATEN2011_port->read_urb, serial->dev, |
| 894 | usb_rcvbulkpipe(serial->dev, |
| 895 | (port-> |
| 896 | bulk_in_endpointAddress + |
| 897 | 2)), port->bulk_in_buffer, |
| 898 | ATEN2011_port->read_urb-> |
| 899 | transfer_buffer_length, |
| 900 | ATEN2011_bulk_in_callback, ATEN2011_port); |
| 901 | } else |
| 902 | usb_fill_bulk_urb(ATEN2011_port->read_urb, |
| 903 | serial->dev, |
| 904 | usb_rcvbulkpipe(serial->dev, |
| 905 | port-> |
| 906 | bulk_in_endpointAddress), |
| 907 | port->bulk_in_buffer, |
| 908 | ATEN2011_port->read_urb-> |
| 909 | transfer_buffer_length, |
| 910 | ATEN2011_bulk_in_callback, ATEN2011_port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 911 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 912 | dbg("ATEN2011_open: bulkin endpoint is %d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 913 | port->bulk_in_endpointAddress); |
| 914 | response = usb_submit_urb(ATEN2011_port->read_urb, GFP_KERNEL); |
| 915 | if (response) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 916 | err("%s - Error %d submitting control urb", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 917 | response); |
| 918 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 919 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 920 | /* initialize our wait queues */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 921 | init_waitqueue_head(&ATEN2011_port->wait_chase); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 922 | init_waitqueue_head(&ATEN2011_port->wait_command); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 923 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 924 | /* initialize our icount structure */ |
| 925 | memset(&(ATEN2011_port->icount), 0x00, sizeof(ATEN2011_port->icount)); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 926 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 927 | /* initialize our port settings */ |
| 928 | ATEN2011_port->shadowMCR = MCR_MASTER_IE; /* Must set to enable ints! */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 929 | ATEN2011_port->chaseResponsePending = 0; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 930 | /* send a open port command */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 931 | ATEN2011_port->open = 1; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 932 | /* ATEN2011_change_port_settings(ATEN2011_port,old_termios); */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 933 | /* Setup termios */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 934 | ATEN2011_set_termios(tty, port, &tmp_termios); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 935 | ATEN2011_port->icount.tx = 0; |
| 936 | ATEN2011_port->icount.rx = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 937 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 938 | dbg("usb_serial serial:%x ATEN2011_port:%x\nATEN2011_serial:%x usb_serial_port port:%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 939 | (unsigned int)serial, (unsigned int)ATEN2011_port, |
| 940 | (unsigned int)ATEN2011_serial, (unsigned int)port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 941 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 942 | return 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 943 | |
| 944 | } |
| 945 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 946 | static int ATEN2011_chars_in_buffer(struct tty_struct *tty) |
| 947 | { |
| 948 | struct usb_serial_port *port = tty->driver_data; |
| 949 | int i; |
| 950 | int chars = 0; |
| 951 | struct ATENINTL_port *ATEN2011_port; |
| 952 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 953 | /* dbg("%s"," ATEN2011_chars_in_buffer:entering ..........."); */ |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 954 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 955 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 956 | if (ATEN2011_port == NULL) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 957 | dbg("%s", "ATEN2011_break:leaving ..........."); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 958 | return -1; |
| 959 | } |
| 960 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 961 | for (i = 0; i < NUM_URBS; ++i) |
| 962 | if (ATEN2011_port->write_urb_pool[i]->status == -EINPROGRESS) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 963 | chars += URB_TRANSFER_BUFFER_SIZE; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 964 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 965 | dbg("%s - returns %d", __func__, chars); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 966 | return chars; |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 967 | |
| 968 | } |
| 969 | |
| 970 | static void ATEN2011_block_until_tx_empty(struct tty_struct *tty, |
| 971 | struct ATENINTL_port *ATEN2011_port) |
| 972 | { |
| 973 | int timeout = HZ / 10; |
| 974 | int wait = 30; |
| 975 | int count; |
| 976 | |
| 977 | while (1) { |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 978 | count = ATEN2011_chars_in_buffer(tty); |
| 979 | |
| 980 | /* Check for Buffer status */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 981 | if (count <= 0) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 982 | return; |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 983 | |
| 984 | /* Block the thread for a while */ |
| 985 | interruptible_sleep_on_timeout(&ATEN2011_port->wait_chase, |
| 986 | timeout); |
| 987 | |
| 988 | /* No activity.. count down section */ |
| 989 | wait--; |
| 990 | if (wait == 0) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 991 | dbg("%s - TIMEOUT", __func__); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 992 | return; |
| 993 | } else { |
| 994 | /* Reset timout value back to seconds */ |
| 995 | wait = 30; |
| 996 | } |
| 997 | } |
| 998 | } |
| 999 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1000 | static void ATEN2011_close(struct tty_struct *tty, struct usb_serial_port *port, |
| 1001 | struct file *filp) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1002 | { |
| 1003 | struct usb_serial *serial; |
| 1004 | struct ATENINTL_serial *ATEN2011_serial; |
| 1005 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1006 | int no_urbs; |
| 1007 | __u16 Data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1008 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1009 | dbg("%s", "ATEN2011_close:entering..."); |
Greg Kroah-Hartman | f3415ee | 2009-01-30 15:31:38 -0800 | [diff] [blame] | 1010 | serial = port->serial; |
| 1011 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1012 | /* take the Adpater and port's private data */ |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1013 | ATEN2011_serial = usb_get_serial_data(serial); |
| 1014 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1015 | if ((ATEN2011_serial == NULL) || (ATEN2011_port == NULL)) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1016 | return; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1017 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1018 | if (serial->dev) { |
| 1019 | /* flush and block(wait) until tx is empty */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1020 | ATEN2011_block_until_tx_empty(tty, ATEN2011_port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1021 | } |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1022 | /* kill the ports URB's */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1023 | for (no_urbs = 0; no_urbs < NUM_URBS; no_urbs++) |
| 1024 | usb_kill_urb(ATEN2011_port->write_urb_pool[no_urbs]); |
| 1025 | /* Freeing Write URBs */ |
| 1026 | for (no_urbs = 0; no_urbs < NUM_URBS; ++no_urbs) { |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1027 | kfree(ATEN2011_port->write_urb_pool[no_urbs]->transfer_buffer); |
| 1028 | usb_free_urb(ATEN2011_port->write_urb_pool[no_urbs]); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1029 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1030 | /* While closing port, shutdown all bulk read, write * |
| 1031 | * and interrupt read if they exists */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1032 | if (serial->dev) { |
| 1033 | if (ATEN2011_port->write_urb) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1034 | dbg("%s", "Shutdown bulk write"); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1035 | usb_kill_urb(ATEN2011_port->write_urb); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1036 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1037 | if (ATEN2011_port->read_urb) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1038 | dbg("%s", "Shutdown bulk read"); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1039 | usb_kill_urb(ATEN2011_port->read_urb); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1040 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1041 | if ((&ATEN2011_port->control_urb)) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1042 | dbg("%s", "Shutdown control read"); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1043 | /* usb_kill_urb (ATEN2011_port->control_urb); */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1044 | |
| 1045 | } |
| 1046 | } |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1047 | /* if(ATEN2011_port->ctrl_buf != NULL) */ |
| 1048 | /* kfree(ATEN2011_port->ctrl_buf); */ |
| 1049 | /* decrement the no.of open ports counter of an individual USB-serial adapter. */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1050 | ATEN2011_serial->NoOfOpenPorts--; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1051 | dbg("NoOfOpenPorts in close%d:in port%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1052 | ATEN2011_serial->NoOfOpenPorts, port->number); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1053 | if (ATEN2011_serial->NoOfOpenPorts == 0) { |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1054 | /* stop the stus polling here */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 1055 | ATEN2011_serial->status_polling_started = 0; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1056 | if (ATEN2011_serial->interrupt_read_urb) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1057 | dbg("%s", "Shutdown interrupt_read_urb"); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1058 | /* ATEN2011_serial->interrupt_in_buffer=NULL; */ |
| 1059 | /* usb_kill_urb (ATEN2011_serial->interrupt_read_urb); */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1060 | } |
| 1061 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1062 | if (ATEN2011_port->write_urb) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1063 | /* if this urb had a transfer buffer already (old tx) free it */ |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1064 | kfree(ATEN2011_port->write_urb->transfer_buffer); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1065 | usb_free_urb(ATEN2011_port->write_urb); |
| 1066 | } |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1067 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1068 | /* clear the MCR & IER */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1069 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1070 | set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1071 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1072 | set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1073 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 1074 | ATEN2011_port->open = 0; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1075 | dbg("%s", "Leaving ............"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1076 | |
| 1077 | } |
| 1078 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 1079 | static void ATEN2011_block_until_chase_response(struct tty_struct *tty, |
| 1080 | struct ATENINTL_port |
| 1081 | *ATEN2011_port) |
| 1082 | { |
| 1083 | int timeout = 1 * HZ; |
| 1084 | int wait = 10; |
| 1085 | int count; |
| 1086 | |
| 1087 | while (1) { |
| 1088 | count = ATEN2011_chars_in_buffer(tty); |
| 1089 | |
| 1090 | /* Check for Buffer status */ |
| 1091 | if (count <= 0) { |
| 1092 | ATEN2011_port->chaseResponsePending = 0; |
| 1093 | return; |
| 1094 | } |
| 1095 | |
| 1096 | /* Block the thread for a while */ |
| 1097 | interruptible_sleep_on_timeout(&ATEN2011_port->wait_chase, |
| 1098 | timeout); |
| 1099 | /* No activity.. count down section */ |
| 1100 | wait--; |
| 1101 | if (wait == 0) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1102 | dbg("%s - TIMEOUT", __func__); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 1103 | return; |
| 1104 | } else { |
| 1105 | /* Reset timout value back to seconds */ |
| 1106 | wait = 10; |
| 1107 | } |
| 1108 | } |
| 1109 | |
| 1110 | } |
| 1111 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1112 | static void ATEN2011_break(struct tty_struct *tty, int break_state) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1113 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1114 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1115 | unsigned char data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1116 | struct usb_serial *serial; |
| 1117 | struct ATENINTL_serial *ATEN2011_serial; |
| 1118 | struct ATENINTL_port *ATEN2011_port; |
| 1119 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1120 | dbg("%s", "Entering ..........."); |
| 1121 | dbg("ATEN2011_break: Start"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1122 | |
Greg Kroah-Hartman | f3415ee | 2009-01-30 15:31:38 -0800 | [diff] [blame] | 1123 | serial = port->serial; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1124 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1125 | ATEN2011_serial = usb_get_serial_data(serial); |
| 1126 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1127 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1128 | if ((ATEN2011_serial == NULL) || (ATEN2011_port == NULL)) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1129 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1130 | |
| 1131 | /* flush and chase */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 1132 | ATEN2011_port->chaseResponsePending = 1; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1133 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1134 | if (serial->dev) { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1135 | /* flush and block until tx is empty */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1136 | ATEN2011_block_until_chase_response(tty, ATEN2011_port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1137 | } |
| 1138 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1139 | if (break_state == -1) |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1140 | data = ATEN2011_port->shadowLCR | LCR_SET_BREAK; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1141 | else |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1142 | data = ATEN2011_port->shadowLCR & ~LCR_SET_BREAK; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1143 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1144 | ATEN2011_port->shadowLCR = data; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1145 | dbg("ATEN2011_break ATEN2011_port->shadowLCR is %x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1146 | ATEN2011_port->shadowLCR); |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1147 | set_uart_reg(port, LINE_CONTROL_REGISTER, ATEN2011_port->shadowLCR); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1148 | |
| 1149 | return; |
| 1150 | } |
| 1151 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1152 | static int ATEN2011_write_room(struct tty_struct *tty) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1153 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1154 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1155 | int i; |
| 1156 | int room = 0; |
| 1157 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1158 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1159 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1160 | if (ATEN2011_port == NULL) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1161 | dbg("%s", "ATEN2011_break:leaving ..........."); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1162 | return -1; |
| 1163 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1164 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1165 | for (i = 0; i < NUM_URBS; ++i) |
| 1166 | if (ATEN2011_port->write_urb_pool[i]->status != -EINPROGRESS) |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1167 | room += URB_TRANSFER_BUFFER_SIZE; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1168 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1169 | dbg("%s - returns %d", __func__, room); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1170 | return room; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1171 | |
| 1172 | } |
| 1173 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1174 | static int ATEN2011_write(struct tty_struct *tty, struct usb_serial_port *port, |
| 1175 | const unsigned char *data, int count) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1176 | { |
| 1177 | int status; |
| 1178 | int i; |
| 1179 | int bytes_sent = 0; |
| 1180 | int transfer_size; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1181 | int minor; |
| 1182 | |
| 1183 | struct ATENINTL_port *ATEN2011_port; |
| 1184 | struct usb_serial *serial; |
| 1185 | struct ATENINTL_serial *ATEN2011_serial; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1186 | struct urb *urb; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1187 | const unsigned char *current_position = data; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1188 | unsigned char *data1; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1189 | dbg("%s", "entering ..........."); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1190 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1191 | serial = port->serial; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1192 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1193 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1194 | if (ATEN2011_port == NULL) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1195 | dbg("%s", "ATEN2011_port is NULL"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1196 | return -1; |
| 1197 | } |
| 1198 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1199 | ATEN2011_serial = usb_get_serial_data(serial); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1200 | if (ATEN2011_serial == NULL) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1201 | dbg("%s", "ATEN2011_serial is NULL"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1202 | return -1; |
| 1203 | } |
| 1204 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1205 | /* try to find a free urb in the list */ |
| 1206 | urb = NULL; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1207 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1208 | for (i = 0; i < NUM_URBS; ++i) { |
| 1209 | if (ATEN2011_port->write_urb_pool[i]->status != -EINPROGRESS) { |
| 1210 | urb = ATEN2011_port->write_urb_pool[i]; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1211 | dbg("URB:%d", i); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1212 | break; |
| 1213 | } |
| 1214 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1215 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1216 | if (urb == NULL) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1217 | dbg("%s - no more free urbs", __func__); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1218 | goto exit; |
| 1219 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1220 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1221 | if (urb->transfer_buffer == NULL) { |
| 1222 | urb->transfer_buffer = |
| 1223 | kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1224 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1225 | if (urb->transfer_buffer == NULL) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1226 | err("%s no more kernel memory...", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1227 | goto exit; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1228 | } |
| 1229 | } |
| 1230 | transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE); |
| 1231 | |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1232 | memcpy(urb->transfer_buffer, current_position, transfer_size); |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1233 | /* usb_serial_debug_data (__FILE__, __func__, transfer_size, urb->transfer_buffer); */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1234 | |
| 1235 | /* fill urb with data and submit */ |
| 1236 | minor = port->serial->minor; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1237 | if (minor == SERIAL_TTY_NO_MINOR) |
| 1238 | minor = 0; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1239 | if ((ATEN2011_serial->ATEN2011_spectrum_2or4ports == 2) |
| 1240 | && (((__u16) port->number - (__u16) (minor)) != 0)) { |
| 1241 | usb_fill_bulk_urb(urb, ATEN2011_serial->serial->dev, |
| 1242 | usb_sndbulkpipe(ATEN2011_serial->serial->dev, |
| 1243 | (port-> |
| 1244 | bulk_out_endpointAddress) + |
| 1245 | 2), urb->transfer_buffer, |
| 1246 | transfer_size, |
| 1247 | ATEN2011_bulk_out_data_callback, |
| 1248 | ATEN2011_port); |
| 1249 | } else |
| 1250 | |
| 1251 | usb_fill_bulk_urb(urb, |
| 1252 | ATEN2011_serial->serial->dev, |
| 1253 | usb_sndbulkpipe(ATEN2011_serial->serial->dev, |
| 1254 | port-> |
| 1255 | bulk_out_endpointAddress), |
| 1256 | urb->transfer_buffer, transfer_size, |
| 1257 | ATEN2011_bulk_out_data_callback, |
| 1258 | ATEN2011_port); |
| 1259 | |
| 1260 | data1 = urb->transfer_buffer; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1261 | dbg("bulkout endpoint is %d", port->bulk_out_endpointAddress); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1262 | /* for(i=0;i < urb->actual_length;i++) */ |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1263 | /* dbg("Data is %c ",data1[i]); */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1264 | |
| 1265 | /* send it down the pipe */ |
| 1266 | status = usb_submit_urb(urb, GFP_ATOMIC); |
| 1267 | |
| 1268 | if (status) { |
| 1269 | err("%s - usb_submit_urb(write bulk) failed with status = %d", |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1270 | __func__, status); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1271 | bytes_sent = status; |
| 1272 | goto exit; |
| 1273 | } |
| 1274 | bytes_sent = transfer_size; |
| 1275 | ATEN2011_port->icount.tx += transfer_size; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1276 | dbg("ATEN2011_port->icount.tx is %d:", ATEN2011_port->icount.tx); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1277 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1278 | exit: |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1279 | return bytes_sent; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1280 | } |
| 1281 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1282 | static void ATEN2011_throttle(struct tty_struct *tty) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1283 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1284 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1285 | struct ATENINTL_port *ATEN2011_port; |
| 1286 | int status; |
| 1287 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1288 | dbg("- port %d", port->number); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1289 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1290 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1291 | |
| 1292 | if (ATEN2011_port == NULL) |
| 1293 | return; |
| 1294 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1295 | if (!ATEN2011_port->open) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1296 | dbg("%s", "port not opened"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1297 | return; |
| 1298 | } |
| 1299 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1300 | dbg("%s", "Entering .......... "); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1301 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1302 | if (!tty) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1303 | dbg("%s - no tty available", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1304 | return; |
| 1305 | } |
| 1306 | |
| 1307 | /* if we are implementing XON/XOFF, send the stop character */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1308 | if (I_IXOFF(tty)) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1309 | unsigned char stop_char = STOP_CHAR(tty); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1310 | status = ATEN2011_write(tty, port, &stop_char, 1); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1311 | if (status <= 0) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1312 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1313 | } |
| 1314 | |
| 1315 | /* if we are implementing RTS/CTS, toggle that line */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1316 | if (tty->termios->c_cflag & CRTSCTS) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1317 | ATEN2011_port->shadowMCR &= ~MCR_RTS; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1318 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, |
| 1319 | ATEN2011_port->shadowMCR); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1320 | if (status < 0) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1321 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1322 | } |
| 1323 | |
| 1324 | return; |
| 1325 | } |
| 1326 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1327 | static void ATEN2011_unthrottle(struct tty_struct *tty) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1328 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1329 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1330 | int status; |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1331 | struct ATENINTL_port *ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1332 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1333 | if (ATEN2011_port == NULL) |
| 1334 | return; |
| 1335 | |
| 1336 | if (!ATEN2011_port->open) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1337 | dbg("%s - port not opened", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1338 | return; |
| 1339 | } |
| 1340 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1341 | dbg("%s", "Entering .......... "); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1342 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1343 | if (!tty) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1344 | dbg("%s - no tty available", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1345 | return; |
| 1346 | } |
| 1347 | |
| 1348 | /* if we are implementing XON/XOFF, send the start character */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1349 | if (I_IXOFF(tty)) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1350 | unsigned char start_char = START_CHAR(tty); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1351 | status = ATEN2011_write(tty, port, &start_char, 1); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1352 | if (status <= 0) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1353 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1354 | } |
| 1355 | |
| 1356 | /* if we are implementing RTS/CTS, toggle that line */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1357 | if (tty->termios->c_cflag & CRTSCTS) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1358 | ATEN2011_port->shadowMCR |= MCR_RTS; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1359 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, |
| 1360 | ATEN2011_port->shadowMCR); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1361 | if (status < 0) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1362 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1363 | } |
| 1364 | |
| 1365 | return; |
| 1366 | } |
| 1367 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1368 | static int ATEN2011_tiocmget(struct tty_struct *tty, struct file *file) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1369 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1370 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1371 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1372 | unsigned int result; |
| 1373 | __u16 msr; |
| 1374 | __u16 mcr; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1375 | /* unsigned int mcr; */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1376 | int status = 0; |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1377 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1378 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1379 | dbg("%s - port %d", __func__, port->number); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1380 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1381 | if (ATEN2011_port == NULL) |
| 1382 | return -ENODEV; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1383 | |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 1384 | status = get_uart_reg(port, MODEM_STATUS_REGISTER, &msr); |
| 1385 | status = get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1386 | /* mcr = ATEN2011_port->shadowMCR; */ |
| 1387 | /* COMMENT2: the Fallowing three line are commented for updating only MSR values */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1388 | result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) |
| 1389 | | ((mcr & MCR_RTS) ? TIOCM_RTS : 0) |
| 1390 | | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0) |
| 1391 | | ((msr & ATEN2011_MSR_CTS) ? TIOCM_CTS : 0) |
| 1392 | | ((msr & ATEN2011_MSR_CD) ? TIOCM_CAR : 0) |
| 1393 | | ((msr & ATEN2011_MSR_RI) ? TIOCM_RI : 0) |
| 1394 | | ((msr & ATEN2011_MSR_DSR) ? TIOCM_DSR : 0); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1395 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1396 | dbg("%s - 0x%04X", __func__, result); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1397 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1398 | return result; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1399 | } |
| 1400 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1401 | static int ATEN2011_tiocmset(struct tty_struct *tty, struct file *file, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1402 | unsigned int set, unsigned int clear) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1403 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1404 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1405 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1406 | unsigned int mcr; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1407 | unsigned int status; |
| 1408 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1409 | dbg("%s - port %d", __func__, port->number); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1410 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1411 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1412 | |
| 1413 | if (ATEN2011_port == NULL) |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1414 | return -ENODEV; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1415 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1416 | mcr = ATEN2011_port->shadowMCR; |
| 1417 | if (clear & TIOCM_RTS) |
| 1418 | mcr &= ~MCR_RTS; |
| 1419 | if (clear & TIOCM_DTR) |
| 1420 | mcr &= ~MCR_DTR; |
| 1421 | if (clear & TIOCM_LOOP) |
| 1422 | mcr &= ~MCR_LOOPBACK; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1423 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1424 | if (set & TIOCM_RTS) |
| 1425 | mcr |= MCR_RTS; |
| 1426 | if (set & TIOCM_DTR) |
| 1427 | mcr |= MCR_DTR; |
| 1428 | if (set & TIOCM_LOOP) |
| 1429 | mcr |= MCR_LOOPBACK; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1430 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1431 | ATEN2011_port->shadowMCR = mcr; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1432 | |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1433 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1434 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1435 | dbg("setting MODEM_CONTROL_REGISTER Failed"); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1436 | return -1; |
| 1437 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1438 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1439 | return 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1440 | } |
| 1441 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1442 | static void ATEN2011_set_termios(struct tty_struct *tty, |
| 1443 | struct usb_serial_port *port, |
| 1444 | struct ktermios *old_termios) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1445 | { |
| 1446 | int status; |
| 1447 | unsigned int cflag; |
| 1448 | struct usb_serial *serial; |
| 1449 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | 8b4efbe | 2009-01-29 13:08:23 -0800 | [diff] [blame] | 1450 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1451 | dbg("ATEN2011_set_termios: START"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1452 | |
| 1453 | serial = port->serial; |
| 1454 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1455 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1456 | |
| 1457 | if (ATEN2011_port == NULL) |
| 1458 | return; |
| 1459 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1460 | if (!ATEN2011_port->open) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1461 | dbg("%s - port not opened", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1462 | return; |
| 1463 | } |
| 1464 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1465 | dbg("%s", "setting termios - "); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1466 | |
| 1467 | cflag = tty->termios->c_cflag; |
| 1468 | |
Alan Cox | 20aa9e9 | 2009-04-07 18:43:43 +0100 | [diff] [blame] | 1469 | dbg("%s - cflag %08x iflag %08x", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1470 | tty->termios->c_cflag, RELEVANT_IFLAG(tty->termios->c_iflag)); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1471 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1472 | if (old_termios) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1473 | dbg("%s - old clfag %08x old iflag %08x", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1474 | old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag)); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1475 | } |
| 1476 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1477 | dbg("%s - port %d", __func__, port->number); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1478 | |
| 1479 | /* change the port settings to the new ones specified */ |
| 1480 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1481 | ATEN2011_change_port_settings(tty, ATEN2011_port, old_termios); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1482 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1483 | if (!ATEN2011_port->read_urb) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1484 | dbg("%s", "URB KILLED !!!!!"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1485 | return; |
| 1486 | } |
| 1487 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1488 | if (ATEN2011_port->read_urb->status != -EINPROGRESS) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1489 | ATEN2011_port->read_urb->dev = serial->dev; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1490 | status = usb_submit_urb(ATEN2011_port->read_urb, GFP_ATOMIC); |
| 1491 | if (status) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1492 | dbg |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1493 | (" usb_submit_urb(read bulk) failed, status = %d", |
| 1494 | status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1495 | } |
| 1496 | } |
| 1497 | return; |
| 1498 | } |
| 1499 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1500 | static int get_lsr_info(struct tty_struct *tty, |
| 1501 | struct ATENINTL_port *ATEN2011_port, |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1502 | unsigned int __user *value) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1503 | { |
| 1504 | int count; |
| 1505 | unsigned int result = 0; |
| 1506 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1507 | count = ATEN2011_chars_in_buffer(tty); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1508 | if (count == 0) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1509 | dbg("%s -- Empty", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1510 | result = TIOCSER_TEMT; |
| 1511 | } |
| 1512 | |
| 1513 | if (copy_to_user(value, &result, sizeof(int))) |
| 1514 | return -EFAULT; |
| 1515 | return 0; |
| 1516 | } |
| 1517 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1518 | static int get_number_bytes_avail(struct tty_struct *tty, |
| 1519 | struct ATENINTL_port *ATEN2011_port, |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1520 | unsigned int __user *value) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1521 | { |
| 1522 | unsigned int result = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1523 | |
| 1524 | if (!tty) |
| 1525 | return -ENOIOCTLCMD; |
| 1526 | |
| 1527 | result = tty->read_cnt; |
| 1528 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1529 | dbg("%s(%d) = %d", __func__, ATEN2011_port->port->number, result); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1530 | if (copy_to_user(value, &result, sizeof(int))) |
| 1531 | return -EFAULT; |
| 1532 | |
| 1533 | return -ENOIOCTLCMD; |
| 1534 | } |
| 1535 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1536 | static int set_modem_info(struct ATENINTL_port *ATEN2011_port, unsigned int cmd, |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1537 | unsigned int __user *value) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1538 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1539 | unsigned int mcr; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1540 | unsigned int arg; |
| 1541 | __u16 Data; |
| 1542 | int status; |
| 1543 | struct usb_serial_port *port; |
| 1544 | |
| 1545 | if (ATEN2011_port == NULL) |
| 1546 | return -1; |
| 1547 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1548 | port = (struct usb_serial_port *)ATEN2011_port->port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1549 | |
| 1550 | mcr = ATEN2011_port->shadowMCR; |
| 1551 | |
| 1552 | if (copy_from_user(&arg, value, sizeof(int))) |
| 1553 | return -EFAULT; |
| 1554 | |
| 1555 | switch (cmd) { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1556 | case TIOCMBIS: |
| 1557 | if (arg & TIOCM_RTS) |
| 1558 | mcr |= MCR_RTS; |
| 1559 | if (arg & TIOCM_DTR) |
| 1560 | mcr |= MCR_RTS; |
| 1561 | if (arg & TIOCM_LOOP) |
| 1562 | mcr |= MCR_LOOPBACK; |
| 1563 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1564 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1565 | case TIOCMBIC: |
| 1566 | if (arg & TIOCM_RTS) |
| 1567 | mcr &= ~MCR_RTS; |
| 1568 | if (arg & TIOCM_DTR) |
| 1569 | mcr &= ~MCR_RTS; |
| 1570 | if (arg & TIOCM_LOOP) |
| 1571 | mcr &= ~MCR_LOOPBACK; |
| 1572 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1573 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1574 | case TIOCMSET: |
| 1575 | /* turn off the RTS and DTR and LOOPBACK |
| 1576 | * and then only turn on what was asked to */ |
| 1577 | mcr &= ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK); |
| 1578 | mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0); |
| 1579 | mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0); |
| 1580 | mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0); |
| 1581 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1582 | } |
| 1583 | |
| 1584 | ATEN2011_port->shadowMCR = mcr; |
| 1585 | |
| 1586 | Data = ATEN2011_port->shadowMCR; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1587 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1588 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1589 | dbg("setting MODEM_CONTROL_REGISTER Failed"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1590 | return -1; |
| 1591 | } |
| 1592 | |
| 1593 | return 0; |
| 1594 | } |
| 1595 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1596 | static int get_modem_info(struct ATENINTL_port *ATEN2011_port, |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1597 | unsigned int __user *value) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1598 | { |
| 1599 | unsigned int result = 0; |
| 1600 | __u16 msr; |
| 1601 | unsigned int mcr = ATEN2011_port->shadowMCR; |
Greg Kroah-Hartman | 12cbe0b | 2009-01-30 15:36:09 -0800 | [diff] [blame] | 1602 | int status; |
| 1603 | |
| 1604 | status = get_uart_reg(ATEN2011_port->port, MODEM_STATUS_REGISTER, &msr); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1605 | result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */ |
| 1606 | |((mcr & MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */ |
| 1607 | |((msr & ATEN2011_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */ |
| 1608 | |((msr & ATEN2011_MSR_CD) ? TIOCM_CAR : 0) /* 0x040 */ |
| 1609 | |((msr & ATEN2011_MSR_RI) ? TIOCM_RI : 0) /* 0x080 */ |
| 1610 | |((msr & ATEN2011_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1611 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1612 | dbg("%s -- %x", __func__, result); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1613 | |
| 1614 | if (copy_to_user(value, &result, sizeof(int))) |
| 1615 | return -EFAULT; |
| 1616 | return 0; |
| 1617 | } |
| 1618 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1619 | static int get_serial_info(struct ATENINTL_port *ATEN2011_port, |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1620 | struct serial_struct __user *retinfo) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1621 | { |
| 1622 | struct serial_struct tmp; |
| 1623 | |
| 1624 | if (ATEN2011_port == NULL) |
| 1625 | return -1; |
| 1626 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1627 | if (!retinfo) |
| 1628 | return -EFAULT; |
| 1629 | |
| 1630 | memset(&tmp, 0, sizeof(tmp)); |
| 1631 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1632 | tmp.type = PORT_16550A; |
| 1633 | tmp.line = ATEN2011_port->port->serial->minor; |
| 1634 | if (tmp.line == SERIAL_TTY_NO_MINOR) |
| 1635 | tmp.line = 0; |
| 1636 | tmp.port = ATEN2011_port->port->number; |
| 1637 | tmp.irq = 0; |
| 1638 | tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ; |
| 1639 | tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE; |
| 1640 | tmp.baud_base = 9600; |
| 1641 | tmp.close_delay = 5 * HZ; |
| 1642 | tmp.closing_wait = 30 * HZ; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1643 | |
| 1644 | if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) |
| 1645 | return -EFAULT; |
| 1646 | return 0; |
| 1647 | } |
| 1648 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1649 | static int ATEN2011_ioctl(struct tty_struct *tty, struct file *file, |
| 1650 | unsigned int cmd, unsigned long arg) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1651 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1652 | struct usb_serial_port *port = tty->driver_data; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1653 | struct ATENINTL_port *ATEN2011_port; |
| 1654 | struct async_icount cnow; |
| 1655 | struct async_icount cprev; |
| 1656 | struct serial_icounter_struct icount; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1657 | int ATENret = 0; |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1658 | unsigned int __user *user_arg = (unsigned int __user *)arg; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1659 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 1660 | ATEN2011_port = usb_get_serial_port_data(port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1661 | |
| 1662 | if (ATEN2011_port == NULL) |
| 1663 | return -1; |
| 1664 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1665 | dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1666 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1667 | switch (cmd) { |
| 1668 | /* return number of bytes available */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1669 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1670 | case TIOCINQ: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1671 | dbg("%s (%d) TIOCINQ", __func__, port->number); |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1672 | return get_number_bytes_avail(tty, ATEN2011_port, user_arg); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1673 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1674 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1675 | case TIOCOUTQ: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1676 | dbg("%s (%d) TIOCOUTQ", __func__, port->number); |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1677 | return put_user(ATEN2011_chars_in_buffer(tty), user_arg); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1678 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1679 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1680 | case TIOCSERGETLSR: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1681 | dbg("%s (%d) TIOCSERGETLSR", __func__, port->number); |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1682 | return get_lsr_info(tty, ATEN2011_port, user_arg); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1683 | return 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1684 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1685 | case TIOCMBIS: |
| 1686 | case TIOCMBIC: |
| 1687 | case TIOCMSET: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1688 | dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1689 | port->number); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1690 | ATENret = set_modem_info(ATEN2011_port, cmd, user_arg); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1691 | return ATENret; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1692 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1693 | case TIOCMGET: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1694 | dbg("%s (%d) TIOCMGET", __func__, port->number); |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1695 | return get_modem_info(ATEN2011_port, user_arg); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1696 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1697 | case TIOCGSERIAL: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1698 | dbg("%s (%d) TIOCGSERIAL", __func__, port->number); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1699 | return get_serial_info(ATEN2011_port, |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1700 | (struct serial_struct __user *)arg); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1701 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1702 | case TIOCSSERIAL: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1703 | dbg("%s (%d) TIOCSSERIAL", __func__, port->number); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1704 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1705 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1706 | case TIOCMIWAIT: |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1707 | dbg("%s (%d) TIOCMIWAIT", __func__, port->number); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1708 | cprev = ATEN2011_port->icount; |
| 1709 | while (1) { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1710 | /* see if a signal did it */ |
| 1711 | if (signal_pending(current)) |
| 1712 | return -ERESTARTSYS; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1713 | cnow = ATEN2011_port->icount; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1714 | if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && |
| 1715 | cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) |
| 1716 | return -EIO; /* no change => error */ |
| 1717 | if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || |
| 1718 | ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || |
| 1719 | ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || |
| 1720 | ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { |
| 1721 | return 0; |
| 1722 | } |
| 1723 | cprev = cnow; |
| 1724 | } |
| 1725 | /* NOTREACHED */ |
| 1726 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1727 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1728 | case TIOCGICOUNT: |
| 1729 | cnow = ATEN2011_port->icount; |
| 1730 | icount.cts = cnow.cts; |
| 1731 | icount.dsr = cnow.dsr; |
| 1732 | icount.rng = cnow.rng; |
| 1733 | icount.dcd = cnow.dcd; |
| 1734 | icount.rx = cnow.rx; |
| 1735 | icount.tx = cnow.tx; |
| 1736 | icount.frame = cnow.frame; |
| 1737 | icount.overrun = cnow.overrun; |
| 1738 | icount.parity = cnow.parity; |
| 1739 | icount.brk = cnow.brk; |
| 1740 | icount.buf_overrun = cnow.buf_overrun; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1741 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1742 | dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1743 | port->number, icount.rx, icount.tx); |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 1744 | if (copy_to_user((void __user *)arg, &icount, sizeof(icount))) |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1745 | return -EFAULT; |
| 1746 | return 0; |
| 1747 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1748 | default: |
| 1749 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1750 | } |
| 1751 | |
| 1752 | return -ENOIOCTLCMD; |
| 1753 | } |
| 1754 | |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 1755 | static int ATEN2011_calc_baud_rate_divisor(int baudRate, int *divisor, |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1756 | __u16 *clk_sel_val) |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 1757 | { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1758 | dbg("%s - %d", __func__, baudRate); |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 1759 | |
| 1760 | if (baudRate <= 115200) { |
| 1761 | *divisor = 115200 / baudRate; |
| 1762 | *clk_sel_val = 0x0; |
| 1763 | } |
| 1764 | if ((baudRate > 115200) && (baudRate <= 230400)) { |
| 1765 | *divisor = 230400 / baudRate; |
| 1766 | *clk_sel_val = 0x10; |
| 1767 | } else if ((baudRate > 230400) && (baudRate <= 403200)) { |
| 1768 | *divisor = 403200 / baudRate; |
| 1769 | *clk_sel_val = 0x20; |
| 1770 | } else if ((baudRate > 403200) && (baudRate <= 460800)) { |
| 1771 | *divisor = 460800 / baudRate; |
| 1772 | *clk_sel_val = 0x30; |
| 1773 | } else if ((baudRate > 460800) && (baudRate <= 806400)) { |
| 1774 | *divisor = 806400 / baudRate; |
| 1775 | *clk_sel_val = 0x40; |
| 1776 | } else if ((baudRate > 806400) && (baudRate <= 921600)) { |
| 1777 | *divisor = 921600 / baudRate; |
| 1778 | *clk_sel_val = 0x50; |
| 1779 | } else if ((baudRate > 921600) && (baudRate <= 1572864)) { |
| 1780 | *divisor = 1572864 / baudRate; |
| 1781 | *clk_sel_val = 0x60; |
| 1782 | } else if ((baudRate > 1572864) && (baudRate <= 3145728)) { |
| 1783 | *divisor = 3145728 / baudRate; |
| 1784 | *clk_sel_val = 0x70; |
| 1785 | } |
| 1786 | return 0; |
| 1787 | } |
| 1788 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1789 | static int ATEN2011_send_cmd_write_baud_rate(struct ATENINTL_port |
| 1790 | *ATEN2011_port, int baudRate) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1791 | { |
| 1792 | int divisor = 0; |
| 1793 | int status; |
| 1794 | __u16 Data; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1795 | unsigned char number; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1796 | __u16 clk_sel_val; |
| 1797 | struct usb_serial_port *port; |
| 1798 | int minor; |
| 1799 | |
| 1800 | if (ATEN2011_port == NULL) |
| 1801 | return -1; |
| 1802 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1803 | port = (struct usb_serial_port *)ATEN2011_port->port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1804 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1805 | dbg("%s", "Entering .......... "); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1806 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1807 | minor = ATEN2011_port->port->serial->minor; |
| 1808 | if (minor == SERIAL_TTY_NO_MINOR) |
| 1809 | minor = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1810 | number = ATEN2011_port->port->number - minor; |
| 1811 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1812 | dbg("%s - port = %d, baud = %d", __func__, |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1813 | ATEN2011_port->port->number, baudRate); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1814 | /* reset clk_uart_sel in spregOffset */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1815 | if (baudRate > 115200) { |
| 1816 | #ifdef HW_flow_control |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1817 | /* |
| 1818 | * NOTE: need to see the pther register to modify |
| 1819 | * setting h/w flow control bit to 1; |
| 1820 | */ |
| 1821 | /* Data = ATEN2011_port->shadowMCR; */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1822 | Data = 0x2b; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1823 | ATEN2011_port->shadowMCR = Data; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1824 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1825 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1826 | dbg("Writing spreg failed in set_serial_baud"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1827 | return -1; |
| 1828 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1829 | #endif |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1830 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1831 | } else { |
| 1832 | #ifdef HW_flow_control |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1833 | /* setting h/w flow control bit to 0; */ |
| 1834 | /* Data = ATEN2011_port->shadowMCR; */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1835 | Data = 0xb; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1836 | ATEN2011_port->shadowMCR = Data; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1837 | status = set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1838 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1839 | dbg("Writing spreg failed in set_serial_baud"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1840 | return -1; |
| 1841 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1842 | #endif |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1843 | |
| 1844 | } |
| 1845 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1846 | if (1) /* baudRate <= 115200) */ { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1847 | clk_sel_val = 0x0; |
| 1848 | Data = 0x0; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1849 | status = |
| 1850 | ATEN2011_calc_baud_rate_divisor(baudRate, &divisor, |
| 1851 | &clk_sel_val); |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 1852 | status = get_reg_sync(port, ATEN2011_port->SpRegOffset, &Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1853 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1854 | dbg("reading spreg failed in set_serial_baud"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1855 | return -1; |
| 1856 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1857 | Data = (Data & 0x8f) | clk_sel_val; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 1858 | status = set_reg_sync(port, ATEN2011_port->SpRegOffset, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1859 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1860 | dbg("Writing spreg failed in set_serial_baud"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1861 | return -1; |
| 1862 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1863 | /* Calculate the Divisor */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1864 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1865 | if (status) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1866 | err("%s - bad baud rate", __func__); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1867 | dbg("%s", "bad baud rate"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1868 | return status; |
| 1869 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1870 | /* Enable access to divisor latch */ |
| 1871 | Data = ATEN2011_port->shadowLCR | SERIAL_LCR_DLAB; |
| 1872 | ATEN2011_port->shadowLCR = Data; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1873 | set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1874 | |
| 1875 | /* Write the divisor */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 1876 | Data = (unsigned char)(divisor & 0xff); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1877 | dbg("set_serial_baud Value to write DLL is %x", Data); |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1878 | set_uart_reg(port, DIVISOR_LATCH_LSB, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1879 | |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 1880 | Data = (unsigned char)((divisor & 0xff00) >> 8); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1881 | dbg("set_serial_baud Value to write DLM is %x", Data); |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1882 | set_uart_reg(port, DIVISOR_LATCH_MSB, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1883 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1884 | /* Disable access to divisor latch */ |
| 1885 | Data = ATEN2011_port->shadowLCR & ~SERIAL_LCR_DLAB; |
| 1886 | ATEN2011_port->shadowLCR = Data; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1887 | set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1888 | |
| 1889 | } |
| 1890 | |
| 1891 | return status; |
| 1892 | } |
| 1893 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1894 | static void ATEN2011_change_port_settings(struct tty_struct *tty, |
| 1895 | struct ATENINTL_port *ATEN2011_port, |
| 1896 | struct ktermios *old_termios) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1897 | { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1898 | int baud; |
| 1899 | unsigned cflag; |
| 1900 | unsigned iflag; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1901 | __u8 lData; |
| 1902 | __u8 lParity; |
| 1903 | __u8 lStop; |
| 1904 | int status; |
| 1905 | __u16 Data; |
| 1906 | struct usb_serial_port *port; |
| 1907 | struct usb_serial *serial; |
| 1908 | |
| 1909 | if (ATEN2011_port == NULL) |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1910 | return; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1911 | |
| 1912 | port = (struct usb_serial_port *)ATEN2011_port->port; |
| 1913 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1914 | serial = port->serial; |
| 1915 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1916 | dbg("%s - port %d", __func__, ATEN2011_port->port->number); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1917 | |
Greg Kroah-Hartman | c725e43 | 2009-01-30 15:29:52 -0800 | [diff] [blame] | 1918 | if (!ATEN2011_port->open) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1919 | dbg("%s - port not opened", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1920 | return; |
| 1921 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1922 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1923 | if ((!tty) || (!tty->termios)) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1924 | dbg("%s - no tty structures", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1925 | return; |
| 1926 | } |
| 1927 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1928 | dbg("%s", "Entering .......... "); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1929 | |
| 1930 | lData = LCR_BITS_8; |
| 1931 | lStop = LCR_STOP_1; |
| 1932 | lParity = LCR_PAR_NONE; |
| 1933 | |
| 1934 | cflag = tty->termios->c_cflag; |
| 1935 | iflag = tty->termios->c_iflag; |
| 1936 | |
| 1937 | /* Change the number of bits */ |
| 1938 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1939 | /* COMMENT1: the below Line"if(cflag & CSIZE)" is added for the errors we get for serial loop data test i.e serial_loopback.pl -v */ |
| 1940 | /* if(cflag & CSIZE) */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1941 | { |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1942 | switch (cflag & CSIZE) { |
| 1943 | case CS5: |
| 1944 | lData = LCR_BITS_5; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1945 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1946 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1947 | case CS6: |
| 1948 | lData = LCR_BITS_6; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1949 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1950 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1951 | case CS7: |
| 1952 | lData = LCR_BITS_7; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1953 | break; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1954 | default: |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1955 | case CS8: |
| 1956 | lData = LCR_BITS_8; |
| 1957 | break; |
| 1958 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1959 | } |
| 1960 | /* Change the Parity bit */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1961 | if (cflag & PARENB) { |
| 1962 | if (cflag & PARODD) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1963 | lParity = LCR_PAR_ODD; |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1964 | dbg("%s - parity = odd", __func__); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1965 | } else { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1966 | lParity = LCR_PAR_EVEN; |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1967 | dbg("%s - parity = even", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1968 | } |
| 1969 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1970 | } else { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1971 | dbg("%s - parity = none", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1972 | } |
| 1973 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 1974 | if (cflag & CMSPAR) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1975 | lParity = lParity | 0x20; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1976 | |
| 1977 | /* Change the Stop bit */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1978 | if (cflag & CSTOPB) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1979 | lStop = LCR_STOP_2; |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1980 | dbg("%s - stop bits = 2", __func__); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1981 | } else { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1982 | lStop = LCR_STOP_1; |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 1983 | dbg("%s - stop bits = 1", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1984 | } |
| 1985 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1986 | /* Update the LCR with the correct value */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1987 | ATEN2011_port->shadowLCR &= |
| 1988 | ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1989 | ATEN2011_port->shadowLCR |= (lData | lParity | lStop); |
| 1990 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 1991 | dbg |
| 1992 | ("ATEN2011_change_port_settings ATEN2011_port->shadowLCR is %x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 1993 | ATEN2011_port->shadowLCR); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1994 | /* Disable Interrupts */ |
| 1995 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1996 | set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 1997 | |
| 1998 | Data = 0x00; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 1999 | set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2000 | |
| 2001 | Data = 0xcf; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 2002 | set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2003 | |
| 2004 | /* Send the updated LCR value to the ATEN2011 */ |
| 2005 | Data = ATEN2011_port->shadowLCR; |
| 2006 | |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 2007 | set_uart_reg(port, LINE_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2008 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2009 | Data = 0x00b; |
| 2010 | ATEN2011_port->shadowMCR = Data; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 2011 | set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2012 | Data = 0x00b; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 2013 | set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2014 | |
| 2015 | /* set up the MCR register and send it to the ATEN2011 */ |
| 2016 | |
| 2017 | ATEN2011_port->shadowMCR = MCR_MASTER_IE; |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 2018 | if (cflag & CBAUD) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2019 | ATEN2011_port->shadowMCR |= (MCR_DTR | MCR_RTS); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2020 | |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 2021 | if (cflag & CRTSCTS) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2022 | ATEN2011_port->shadowMCR |= (MCR_XON_ANY); |
Greg Kroah-Hartman | 8532b09 | 2009-02-03 21:36:46 -0800 | [diff] [blame] | 2023 | else |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2024 | ATEN2011_port->shadowMCR &= ~(MCR_XON_ANY); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2025 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2026 | Data = ATEN2011_port->shadowMCR; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 2027 | set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2028 | |
| 2029 | /* Determine divisor based on baud rate */ |
| 2030 | baud = tty_get_baud_rate(tty); |
| 2031 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2032 | if (!baud) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2033 | /* pick a default, any default... */ |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2034 | dbg("%s", "Picked default baud..."); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2035 | baud = 9600; |
| 2036 | } |
| 2037 | |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 2038 | dbg("%s - baud rate = %d", __func__, baud); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2039 | status = ATEN2011_send_cmd_write_baud_rate(ATEN2011_port, baud); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2040 | |
| 2041 | /* Enable Interrupts */ |
| 2042 | Data = 0x0c; |
Greg Kroah-Hartman | e514adb | 2009-01-30 15:35:50 -0800 | [diff] [blame] | 2043 | set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2044 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2045 | if (ATEN2011_port->read_urb->status != -EINPROGRESS) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2046 | ATEN2011_port->read_urb->dev = serial->dev; |
| 2047 | |
| 2048 | status = usb_submit_urb(ATEN2011_port->read_urb, GFP_ATOMIC); |
| 2049 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2050 | if (status) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2051 | dbg |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2052 | (" usb_submit_urb(read bulk) failed, status = %d", |
| 2053 | status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2054 | } |
| 2055 | } |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2056 | dbg |
| 2057 | ("ATEN2011_change_port_settings ATEN2011_port->shadowLCR is End %x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2058 | ATEN2011_port->shadowLCR); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2059 | |
| 2060 | return; |
| 2061 | } |
| 2062 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2063 | static int ATEN2011_calc_num_ports(struct usb_serial *serial) |
| 2064 | { |
| 2065 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2066 | __u16 Data = 0x00; |
| 2067 | int ret = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2068 | int ATEN2011_2or4ports; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2069 | ret = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), |
| 2070 | ATEN_RDREQ, ATEN_RD_RTYPE, 0, GPIO_REGISTER, |
| 2071 | &Data, VENDOR_READ_LENGTH, ATEN_WDR_TIMEOUT); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2072 | |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2073 | /* ghostgum: here is where the problem appears to bet */ |
| 2074 | /* Which of the following are needed? */ |
| 2075 | /* Greg used the serial->type->num_ports=2 */ |
| 2076 | /* But the code in the ATEN2011_open relies on serial->num_ports=2 */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2077 | if ((Data & 0x01) == 0) { |
| 2078 | ATEN2011_2or4ports = 2; |
| 2079 | serial->type->num_ports = 2; |
| 2080 | serial->num_ports = 2; |
| 2081 | } |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2082 | /* else if(serial->interface->cur_altsetting->desc.bNumEndpoints == 9) */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2083 | else { |
| 2084 | ATEN2011_2or4ports = 4; |
| 2085 | serial->type->num_ports = 4; |
| 2086 | serial->num_ports = 4; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2087 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2088 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2089 | |
| 2090 | return ATEN2011_2or4ports; |
| 2091 | } |
| 2092 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2093 | static int ATEN2011_startup(struct usb_serial *serial) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2094 | { |
| 2095 | struct ATENINTL_serial *ATEN2011_serial; |
| 2096 | struct ATENINTL_port *ATEN2011_port; |
| 2097 | struct usb_device *dev; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2098 | int i, status; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2099 | int minor; |
| 2100 | |
| 2101 | __u16 Data; |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2102 | dbg("%s", " ATEN2011_startup :entering.........."); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2103 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2104 | if (!serial) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2105 | dbg("%s", "Invalid Handler"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2106 | return -1; |
| 2107 | } |
| 2108 | |
| 2109 | dev = serial->dev; |
| 2110 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2111 | dbg("%s", "Entering..."); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2112 | |
| 2113 | /* create our private serial structure */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2114 | ATEN2011_serial = kzalloc(sizeof(struct ATENINTL_serial), GFP_KERNEL); |
| 2115 | if (ATEN2011_serial == NULL) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 2116 | err("%s - Out of memory", __func__); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2117 | return -ENOMEM; |
| 2118 | } |
| 2119 | |
| 2120 | /* resetting the private structure field values to zero */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2121 | memset(ATEN2011_serial, 0, sizeof(struct ATENINTL_serial)); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2122 | |
| 2123 | ATEN2011_serial->serial = serial; |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2124 | /* initilize status polling flag to 0 */ |
Greg Kroah-Hartman | a636409 | 2009-01-29 16:57:23 -0800 | [diff] [blame] | 2125 | ATEN2011_serial->status_polling_started = 0; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2126 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2127 | usb_set_serial_data(serial, ATEN2011_serial); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2128 | ATEN2011_serial->ATEN2011_spectrum_2or4ports = |
| 2129 | ATEN2011_calc_num_ports(serial); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2130 | /* we set up the pointers to the endpoints in the ATEN2011_open * |
| 2131 | * function, as the structures aren't created yet. */ |
| 2132 | |
| 2133 | /* set up port private structures */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2134 | for (i = 0; i < serial->num_ports; ++i) { |
| 2135 | ATEN2011_port = |
| 2136 | kmalloc(sizeof(struct ATENINTL_port), GFP_KERNEL); |
| 2137 | if (ATEN2011_port == NULL) { |
Greg Kroah-Hartman | 9d70054 | 2009-02-03 21:35:55 -0800 | [diff] [blame] | 2138 | err("%s - Out of memory", __func__); |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2139 | usb_set_serial_data(serial, NULL); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2140 | kfree(ATEN2011_serial); |
| 2141 | return -ENOMEM; |
| 2142 | } |
| 2143 | memset(ATEN2011_port, 0, sizeof(struct ATENINTL_port)); |
| 2144 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2145 | /* |
| 2146 | * Initialize all port interrupt end point to port 0 |
| 2147 | * int endpoint. Our device has only one interrupt end point |
| 2148 | * comman to all port |
| 2149 | */ |
| 2150 | /* serial->port[i]->interrupt_in_endpointAddress = serial->port[0]->interrupt_in_endpointAddress; */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2151 | |
| 2152 | ATEN2011_port->port = serial->port[i]; |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2153 | usb_set_serial_port_data(serial->port[i], ATEN2011_port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2154 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2155 | minor = serial->port[i]->serial->minor; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2156 | if (minor == SERIAL_TTY_NO_MINOR) |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2157 | minor = 0; |
| 2158 | ATEN2011_port->port_num = |
| 2159 | ((serial->port[i]->number - minor) + 1); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2160 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2161 | if (ATEN2011_port->port_num == 1) { |
| 2162 | ATEN2011_port->SpRegOffset = 0x0; |
| 2163 | ATEN2011_port->ControlRegOffset = 0x1; |
| 2164 | ATEN2011_port->DcrRegOffset = 0x4; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2165 | } else if ((ATEN2011_port->port_num == 2) |
| 2166 | && (ATEN2011_serial->ATEN2011_spectrum_2or4ports == |
| 2167 | 4)) { |
| 2168 | ATEN2011_port->SpRegOffset = 0x8; |
| 2169 | ATEN2011_port->ControlRegOffset = 0x9; |
| 2170 | ATEN2011_port->DcrRegOffset = 0x16; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2171 | } else if ((ATEN2011_port->port_num == 2) |
| 2172 | && (ATEN2011_serial->ATEN2011_spectrum_2or4ports == |
| 2173 | 2)) { |
| 2174 | ATEN2011_port->SpRegOffset = 0xa; |
| 2175 | ATEN2011_port->ControlRegOffset = 0xb; |
| 2176 | ATEN2011_port->DcrRegOffset = 0x19; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2177 | } else if ((ATEN2011_port->port_num == 3) |
| 2178 | && (ATEN2011_serial->ATEN2011_spectrum_2or4ports == |
| 2179 | 4)) { |
| 2180 | ATEN2011_port->SpRegOffset = 0xa; |
| 2181 | ATEN2011_port->ControlRegOffset = 0xb; |
| 2182 | ATEN2011_port->DcrRegOffset = 0x19; |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2183 | } else if ((ATEN2011_port->port_num == 4) |
| 2184 | && (ATEN2011_serial->ATEN2011_spectrum_2or4ports == |
| 2185 | 4)) { |
| 2186 | ATEN2011_port->SpRegOffset = 0xc; |
| 2187 | ATEN2011_port->ControlRegOffset = 0xd; |
| 2188 | ATEN2011_port->DcrRegOffset = 0x1c; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2189 | } |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2190 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2191 | usb_set_serial_port_data(serial->port[i], ATEN2011_port); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2192 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2193 | /* enable rx_disable bit in control register */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2194 | |
Greg Kroah-Hartman | e9abe30 | 2009-01-30 15:35:31 -0800 | [diff] [blame] | 2195 | status = get_reg_sync(serial->port[i], |
| 2196 | ATEN2011_port->ControlRegOffset, &Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2197 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2198 | dbg("Reading ControlReg failed status-0x%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2199 | status); |
| 2200 | break; |
| 2201 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2202 | dbg |
| 2203 | ("ControlReg Reading success val is %x, status%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2204 | Data, status); |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2205 | Data |= 0x08; /* setting driver done bit */ |
| 2206 | Data |= 0x04; /* sp1_bit to have cts change reflect in modem status reg */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2207 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2208 | /* Data |= 0x20; */ /* rx_disable bit */ |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2209 | status = set_reg_sync(serial->port[i], |
| 2210 | ATEN2011_port->ControlRegOffset, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2211 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2212 | dbg |
| 2213 | ("Writing ControlReg failed(rx_disable) status-0x%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2214 | status); |
| 2215 | break; |
| 2216 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2217 | dbg |
| 2218 | ("ControlReg Writing success(rx_disable) status%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2219 | status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2220 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2221 | /* |
| 2222 | * Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2 |
| 2223 | * and 0x24 in DCR3 |
| 2224 | */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2225 | Data = 0x01; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2226 | status = set_reg_sync(serial->port[i], |
| 2227 | (__u16)(ATEN2011_port->DcrRegOffset + 0), |
| 2228 | Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2229 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2230 | dbg("Writing DCR0 failed status-0x%x", status); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2231 | break; |
| 2232 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2233 | dbg("DCR0 Writing success status%d", status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2234 | |
| 2235 | Data = 0x05; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2236 | status = set_reg_sync(serial->port[i], |
| 2237 | (__u16)(ATEN2011_port->DcrRegOffset + 1), |
| 2238 | Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2239 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2240 | dbg("Writing DCR1 failed status-0x%x", status); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2241 | break; |
| 2242 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2243 | dbg("DCR1 Writing success status%d", status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2244 | |
| 2245 | Data = 0x24; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2246 | status = set_reg_sync(serial->port[i], |
| 2247 | (__u16)(ATEN2011_port->DcrRegOffset + 2), |
| 2248 | Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2249 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2250 | dbg("Writing DCR2 failed status-0x%x", status); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2251 | break; |
| 2252 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2253 | dbg("DCR2 Writing success status%d", status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2254 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2255 | /* write values in clkstart0x0 and clkmulti 0x20 */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2256 | Data = 0x0; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2257 | status = set_reg_sync(serial->port[i], CLK_START_VALUE_REGISTER, |
| 2258 | Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2259 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2260 | dbg |
| 2261 | ("Writing CLK_START_VALUE_REGISTER failed status-0x%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2262 | status); |
| 2263 | break; |
| 2264 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2265 | dbg |
| 2266 | ("CLK_START_VALUE_REGISTER Writing success status%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2267 | status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2268 | |
| 2269 | Data = 0x20; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2270 | status = set_reg_sync(serial->port[i], CLK_MULTI_REGISTER, |
| 2271 | Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2272 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2273 | dbg |
| 2274 | ("Writing CLK_MULTI_REGISTER failed status-0x%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2275 | status); |
| 2276 | break; |
| 2277 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2278 | dbg("CLK_MULTI_REGISTER Writing success status%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2279 | status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2280 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2281 | /* Zero Length flag register */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2282 | if ((ATEN2011_port->port_num != 1) |
| 2283 | && (ATEN2011_serial->ATEN2011_spectrum_2or4ports == 2)) { |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2284 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2285 | Data = 0xff; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2286 | status = set_reg_sync(serial->port[i], |
| 2287 | (__u16)(ZLP_REG1 + ((__u16)ATEN2011_port->port_num)), |
| 2288 | Data); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2289 | dbg("ZLIP offset%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2290 | (__u16) (ZLP_REG1 + |
| 2291 | ((__u16) ATEN2011_port->port_num))); |
| 2292 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2293 | dbg |
| 2294 | ("Writing ZLP_REG%d failed status-0x%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2295 | i + 2, status); |
| 2296 | break; |
| 2297 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2298 | dbg("ZLP_REG%d Writing success status%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2299 | i + 2, status); |
| 2300 | } else { |
| 2301 | Data = 0xff; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2302 | status = set_reg_sync(serial->port[i], |
| 2303 | (__u16)(ZLP_REG1 + ((__u16)ATEN2011_port->port_num) - 0x1), |
| 2304 | Data); |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2305 | dbg("ZLIP offset%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2306 | (__u16) (ZLP_REG1 + |
| 2307 | ((__u16) ATEN2011_port->port_num) - |
| 2308 | 0x1)); |
| 2309 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2310 | dbg |
| 2311 | ("Writing ZLP_REG%d failed status-0x%x", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2312 | i + 1, status); |
| 2313 | break; |
| 2314 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2315 | dbg("ZLP_REG%d Writing success status%d", |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2316 | i + 1, status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2317 | |
| 2318 | } |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2319 | ATEN2011_port->control_urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 2320 | ATEN2011_port->ctrl_buf = kmalloc(16, GFP_KERNEL); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2321 | |
| 2322 | } |
| 2323 | |
Greg Kroah-Hartman | 87ed9bd | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2324 | /* Zero Length flag enable */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2325 | Data = 0x0f; |
Greg Kroah-Hartman | 8433b6a | 2009-01-30 15:32:18 -0800 | [diff] [blame] | 2326 | status = set_reg_sync(serial->port[0], ZLP_REG5, Data); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2327 | if (status < 0) { |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2328 | dbg("Writing ZLP_REG5 failed status-0x%x", status); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2329 | return -1; |
| 2330 | } else |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2331 | dbg("ZLP_REG5 Writing success status%d", status); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2332 | |
| 2333 | /* setting configuration feature to one */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2334 | usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
Greg Kroah-Hartman | 907aff4 | 2009-01-29 17:17:48 -0800 | [diff] [blame] | 2335 | (__u8) 0x03, 0x00, 0x01, 0x00, NULL, 0x00, 5 * HZ); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2336 | return 0; |
| 2337 | } |
| 2338 | |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 2339 | static void ATEN2011_release(struct usb_serial *serial) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2340 | { |
| 2341 | int i; |
| 2342 | struct ATENINTL_port *ATEN2011_port; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2343 | |
Greg Kroah-Hartman | 9e3697a | 2009-02-03 16:06:19 -0800 | [diff] [blame] | 2344 | /* check for the ports to be closed,close the ports and disconnect */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2345 | |
| 2346 | /* free private structure allocated for serial port * |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2347 | * stop reads and writes on all ports */ |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2348 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2349 | for (i = 0; i < serial->num_ports; ++i) { |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2350 | ATEN2011_port = usb_get_serial_port_data(serial->port[i]); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2351 | kfree(ATEN2011_port->ctrl_buf); |
| 2352 | usb_kill_urb(ATEN2011_port->control_urb); |
| 2353 | kfree(ATEN2011_port); |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2354 | usb_set_serial_port_data(serial->port[i], NULL); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2355 | } |
| 2356 | |
| 2357 | /* free private structure allocated for serial device */ |
| 2358 | |
Greg Kroah-Hartman | c3e06f2 | 2009-01-30 15:37:00 -0800 | [diff] [blame] | 2359 | kfree(usb_get_serial_data(serial)); |
| 2360 | usb_set_serial_data(serial, NULL); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2361 | } |
| 2362 | |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2363 | static struct usb_serial_driver aten_serial_driver = { |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 2364 | .driver = { |
| 2365 | .owner = THIS_MODULE, |
| 2366 | .name = "aten2011", |
| 2367 | }, |
| 2368 | .description = DRIVER_DESC, |
| 2369 | .id_table = id_table, |
| 2370 | .open = ATEN2011_open, |
| 2371 | .close = ATEN2011_close, |
| 2372 | .write = ATEN2011_write, |
| 2373 | .write_room = ATEN2011_write_room, |
| 2374 | .chars_in_buffer = ATEN2011_chars_in_buffer, |
| 2375 | .throttle = ATEN2011_throttle, |
| 2376 | .unthrottle = ATEN2011_unthrottle, |
| 2377 | .calc_num_ports = ATEN2011_calc_num_ports, |
| 2378 | |
| 2379 | .ioctl = ATEN2011_ioctl, |
| 2380 | .set_termios = ATEN2011_set_termios, |
| 2381 | .break_ctl = ATEN2011_break, |
| 2382 | .tiocmget = ATEN2011_tiocmget, |
| 2383 | .tiocmset = ATEN2011_tiocmset, |
| 2384 | .attach = ATEN2011_startup, |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 2385 | .release = ATEN2011_release, |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 2386 | .read_bulk_callback = ATEN2011_bulk_in_callback, |
| 2387 | .read_int_callback = ATEN2011_interrupt_callback, |
| 2388 | }; |
| 2389 | |
| 2390 | static struct usb_driver aten_driver = { |
| 2391 | .name = "aten2011", |
| 2392 | .probe = usb_serial_probe, |
| 2393 | .disconnect = usb_serial_disconnect, |
| 2394 | .id_table = id_table, |
| 2395 | }; |
| 2396 | |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2397 | static int __init aten_init(void) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2398 | { |
| 2399 | int retval; |
| 2400 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2401 | /* Register with the usb serial */ |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2402 | retval = usb_serial_register(&aten_serial_driver); |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2403 | if (retval) |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2404 | return retval; |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2405 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2406 | printk(KERN_INFO KBUILD_MODNAME ":" |
| 2407 | DRIVER_DESC " " DRIVER_VERSION "\n"); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2408 | |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2409 | /* Register with the usb */ |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 2410 | retval = usb_register(&aten_driver); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2411 | if (retval) |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2412 | usb_serial_deregister(&aten_serial_driver); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2413 | |
| 2414 | return retval; |
| 2415 | } |
| 2416 | |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2417 | static void __exit aten_exit(void) |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2418 | { |
Greg Kroah-Hartman | a7fefd1 | 2009-01-29 17:10:43 -0800 | [diff] [blame] | 2419 | usb_deregister(&aten_driver); |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2420 | usb_serial_deregister(&aten_serial_driver); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2421 | } |
| 2422 | |
Greg Kroah-Hartman | 085c090 | 2009-01-30 15:30:48 -0800 | [diff] [blame] | 2423 | module_init(aten_init); |
| 2424 | module_exit(aten_exit); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2425 | |
| 2426 | /* Module information */ |
Greg Kroah-Hartman | d93f87c | 2009-01-29 12:54:01 -0800 | [diff] [blame] | 2427 | MODULE_DESCRIPTION(DRIVER_DESC); |
Greg Kroah-Hartman | e6d69d9 | 2009-01-27 23:28:27 -0800 | [diff] [blame] | 2428 | MODULE_LICENSE("GPL"); |
| 2429 | |
| 2430 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |