From 72ba94ec61d1ceb9b80e317f72548b1e88e539f4 Mon Sep 17 00:00:00 2001 From: Richard Ash Date: Wed, 29 Jul 2009 17:12:18 +0100 Subject: [PATCH] Staging: quatech_usb2: implement open functionality Part two of the driver implementation has finally got done. It implements the rest of open and the callback for reads from the box. I seem to have finally found a structure that can be made to work, with a single set of URBs for bulk read and write for the whole device, which are used by all the ports. I've rationalised a few things, but there will still be a lot of clean-up needed. This one definitely can panic the kernel when a port is opened for reading, but I'm off on holiday so I thought I'd post where I have got to so far. I haven't tried to debug why it panics with a null pointer dereference yet. Signed-off-by: Richard Ash Signed-off-by: Greg Kroah-Hartman --- drivers/staging/quatech_usb2/quatech_usb2.c | 584 +++++++++++++++++--- 1 file changed, 515 insertions(+), 69 deletions(-) diff --git a/drivers/staging/quatech_usb2/quatech_usb2.c b/drivers/staging/quatech_usb2/quatech_usb2.c index 3544e7005404..0eaea2e7ce8a 100644 --- a/drivers/staging/quatech_usb2/quatech_usb2.c +++ b/drivers/staging/quatech_usb2/quatech_usb2.c @@ -38,6 +38,7 @@ static int debug; #define QU2BOXPWRON 0x8000 /* magic number to turn FPGA power on */ #define QU2BOX232 0x40 /* RS232 mode on MEI devices */ #define QU2BOXSPD9600 0x60 /* set speed to 9600 baud */ +#define FIFO_DEPTH 1024 /* size of hardware fifos */ /* directions for USB transfers */ #define USBD_TRANSFER_DIRECTION_IN 0xc0 #define USBD_TRANSFER_DIRECTION_OUT 0x40 @@ -84,6 +85,12 @@ static int debug; #define SERIAL_LSR_FE 0x08 #define SERIAL_LSR_BI 0x10 +/* handy macros for doing escape sequence parsing on data reads */ +#define THISCHAR ((unsigned char *)(urb->transfer_buffer))[i] +#define NEXTCHAR ((unsigned char *)(urb->transfer_buffer))[i + 1] +#define THIRDCHAR ((unsigned char *)(urb->transfer_buffer))[i + 2] +#define FOURTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 3] +#define FIFTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 4] static struct usb_device_id quausb2_id_table[] = { {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)}, @@ -99,8 +106,6 @@ static struct usb_device_id quausb2_id_table[] = { MODULE_DEVICE_TABLE(usb, quausb2_id_table); /* custom structures we need go here */ - - static struct usb_driver quausb2_usb_driver = { .name = "quatech-usb2-serial", .probe = usb_serial_probe, @@ -109,10 +114,35 @@ static struct usb_driver quausb2_usb_driver = { .no_dynamic_id = 1, }; -/* structure in which to keep all the messy stuff that this driver needs - * alongside the usb_serial_port structure */ +/** structure in which to keep all the messy stuff that this driver needs + * alongside the usb_serial_port structure + * @param read_urb_busy Flag indicating that port->read_urb is in use + * @param close_pending flag indicating that this port is in the process of + * being closed. + * @param shadowLSR Last received state of the line status register, holds the + * value of the line status flags from the port + * @param shadowMSR Last received state of the modem status register, holds + * the value of the modem status received from the port + * @param xmit_pending_bytes Number of bytes waiting to be sent out of + * the serial port + * @param xmit_fifo_room_bytes free space available in the transmit fifo + * for this port on the box + * @param rcv_flush Flag indicating that a receive flush has been requested by + * the hardware. + * @param xmit_flush Flag indicating that a transmit flush has been requested by + * the hardware. + */ struct quatech2_port { int magic; + bool read_urb_busy; + bool close_pending; + __u8 shadowLSR; + __u8 shadowMSR; + int xmit_pending_bytes; + int xmit_fifo_room_bytes; + char rcv_flush; + char xmit_flush; + char active; /* someone has this device open */ unsigned char *xfer_to_tty_buffer; wait_queue_head_t wait; @@ -120,20 +150,27 @@ struct quatech2_port { struct semaphore sem; /* locks this structure */ __u8 shadowLCR; /* last LCR value received */ __u8 shadowMCR; /* last MCR value received */ - __u8 shadowMSR; /* last MSR value received */ - __u8 shadowLSR; /* last LSR value received */ - char open_ports; /* ports open on whole device */ char RxHolding; - char Rcv_Flush; - char Xmit_Flush; - char closePending; char fifo_empty_flag; - int xmit_pending_bytes; - int xmit_fifo_room_bytes; struct semaphore pend_xmit_sem; /* locks this structure */ spinlock_t lock; }; +/** + * Structure to hold device-wide internal status information + * @param ReadBulkStopped The last bulk read attempt ended in tears + * @param open_ports The number of serial ports currently in use on the box + * @param current_port Pointer to the serial port structure of the port which + * the read stream is currently directed to. Escape sequences in the read + * stream will change this around as data arrives from different ports on the + * box + */ +struct quatech2_dev { + bool ReadBulkStopped; + char open_ports; + struct usb_serial_port *current_port; +}; + /* structure which holds line and modem status flags */ struct qt2_status_data { __u8 line_status; @@ -152,12 +189,30 @@ static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port *port); static inline void qt2_set_port_private(struct usb_serial_port *port, struct quatech2_port *data); +static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial + *serial); +static inline void qt2_set_dev_private(struct usb_serial *serial, + struct quatech2_dev *data); static int qt2_openboxchannel(struct usb_serial *serial, __u16 Uart_Number, struct qt2_status_data *pDeviceData); static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number); static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, unsigned short divisor, unsigned char LCR); +static void qt2_read_bulk_callback(struct urb *urb); +static void qt2_process_line_status(struct usb_serial_port *port, + unsigned char LineStatus); +static void qt2_process_modem_status(struct usb_serial_port *port, + unsigned char ModemStatus); +static void qt2_process_xmit_empty(struct usb_serial_port *port, + unsigned char fourth_char, unsigned char fifth_char); +static void qt2_process_port_change(struct usb_serial_port *port, + unsigned char New_Current_Port); +static void qt2_process_rcv_flush(struct usb_serial_port *port); +static void qt2_process_xmit_flush(struct usb_serial_port *port); +static void qt2_process_rx_char(struct usb_serial_port *port, + unsigned char data); + /* implementation functions, roughly in order of use, are here */ static int qt2_calc_num_ports(struct usb_serial *serial) { @@ -195,12 +250,13 @@ static int qt2_calc_num_ports(struct usb_serial *serial) static int qt2_attach(struct usb_serial *serial) { struct usb_serial_port *port; - struct quatech2_port *qt2_port; + struct quatech2_port *qt2_port; /* port-specific private data pointer */ + struct quatech2_dev *qt2_dev; /* dev-specific private data pointer */ int i; - /* stuff for printing endpoint addresses, not needed for - * production */ + /* stuff for storing endpoint addresses now */ struct usb_endpoint_descriptor *endpoint; struct usb_host_interface *iface_desc; + struct usb_serial_port *port0; /* first port structure on device */ /* check how many endpoints there are on the device, for * sanity's sake */ @@ -212,12 +268,42 @@ static int qt2_attach(struct usb_serial *serial) return -ENODEV; } iface_desc = serial->interface->cur_altsetting; + + /* Set up per-device private data, storing extra data alongside + * struct usb_serial */ + qt2_dev = kzalloc(sizeof(*qt2_dev), GFP_KERNEL); + if (!qt2_dev) { + dbg("%s: kmalloc for quatech2_dev failed!", + __func__); + return -ENOMEM; + } + qt2_dev->open_ports = 0; /* no ports open */ + qt2_set_dev_private(serial, qt2_dev); /* store private data */ + + /* Now setup per port private data, which replaces all the things + * that quatech added to standard kernel structures in their driver */ + for (i = 0; i < serial->num_ports; i++) { + port = serial->port[i]; + qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL); + if (!qt2_port) { + dbg("%s: kmalloc for quatech2_port (%d) failed!.", + __func__, i); + return -ENOMEM; + } + spin_lock_init(&qt2_port->lock); + usb_set_serial_port_data(port, qt2_port); + } + + /* gain access to port[0]'s structure because we want to store + * device-level stuff in it */ + if (serial_paranoia_check(serial, __func__)) + return -ENODEV; + port0 = serial->port[0]; /* get the first port's device structure */ + /* print endpoint addresses so we can check them later * by hand */ - for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) - { + for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { endpoint = &iface_desc->endpoint[i].desc; - if ((endpoint->bEndpointAddress & 0x80) && ((endpoint->bmAttributes & 3) == 0x02)) { /* we found a bulk in endpoint */ @@ -226,33 +312,13 @@ static int qt2_attach(struct usb_serial *serial) } if (((endpoint->bEndpointAddress & 0x80) == 0x00) && - ((endpoint->bmAttributes & 3) == 0x02)) - { + ((endpoint->bmAttributes & 3) == 0x02)) { /* we found a bulk out endpoint */ dbg("found bulk out at 0x%x", endpoint->bEndpointAddress); } } /* end printing endpoint addresses */ - /* Now setup per port private data, which replaces all the things - * that quatech added to standard kernel structures in their driver */ - for (i = 0; i < serial->num_ports; i++) { - port = serial->port[i]; - qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL); - if (!qt2_port) { - dbg("%s: kmalloc for quatech2_port (%d) failed!.", - __func__, i); - return -ENOMEM; - } - spin_lock_init(&qt2_port->lock); - if (i == 0) - qt2_port->open_ports = 0; /* no ports */ - else - qt2_port->open_ports = -1; /* unused */ - - usb_set_serial_port_data(port, qt2_port); - - } /* switch on power to the hardware */ if (qt2_boxpoweron(serial) < 0) { dbg("qt2_boxpoweron() failed"); @@ -274,8 +340,11 @@ startup_error: port = serial->port[i]; qt2_port = qt2_get_port_private(port); kfree(qt2_port); - usb_set_serial_port_data(port, NULL); + qt2_set_port_private(port, NULL); } + qt2_dev = qt2_get_dev_private(serial); + kfree(qt2_dev); + qt2_set_dev_private(serial, NULL); dbg("Exit fail %s\n", __func__); return -EIO; @@ -317,30 +386,40 @@ int qt2_open(struct tty_struct *tty, struct usb_serial_port *port0; /* first port structure on device */ struct quatech2_port *port_extra; /* extra data for this port */ struct quatech2_port *port0_extra; /* extra data for first port */ + struct quatech2_dev *dev_extra; /* extra data for the device */ struct qt2_status_data ChannelData; unsigned short default_divisor = QU2BOXSPD9600; unsigned char default_LCR = SERIAL_8_DATA; int status; + int result; if (port_paranoia_check(port, __func__)) return -ENODEV; - dbg("%s - port %d\n", __func__, port->number); + dbg("%s(): port %d", __func__, port->number); serial = port->serial; /* get the parent device structure */ - if (serial_paranoia_check(serial, __func__)) + if (serial_paranoia_check(serial, __func__)) { + dbg("usb_serial struct failed sanity check"); return -ENODEV; + } + dev_extra = qt2_get_dev_private(serial); + /* get the device private data */ port0 = serial->port[0]; /* get the first port's device structure */ - + if (port_paranoia_check(port, __func__)) { + dbg("port0 usb_serial_port struct failed sanity check"); + return -ENODEV; + } port_extra = qt2_get_port_private(port); port0_extra = qt2_get_port_private(port0); - if (port_extra == NULL || port0_extra == NULL) + if (port_extra == NULL || port0_extra == NULL) { + dbg("failed to get private data for port and port0"); return -ENODEV; + } usb_clear_halt(serial->dev, port->write_urb->pipe); usb_clear_halt(serial->dev, port->read_urb->pipe); - port0_extra->open_ports++; /* FIXME: are these needed? Does it even do anything useful? */ /* get the modem and line status values from the UART */ @@ -374,39 +453,58 @@ int qt2_open(struct tty_struct *tty, dbg("qt2_conf_uart() completed on channel %d", port->number); - dbg("port number is %d", port->number); - dbg("serial number is %d", port->serial->minor); - - /* We need to set up endpoints here. We only - * have one pair of endpoints per device, so in fact - * we only need to set up endpoints on the first time - * round, not subsequent ones. - * When we do a write to a port, we will use the same endpoint + /* + * At this point we will need some end points to make further progress. + * Handlily, the correct endpoint addresses have been filled out into + * the usb_serial_port structure for us by the driver core, so we + * already have access to them. + * As there is only one bulk in and one bulk out end-point, these are in + * port[0]'s structure, and the rest are uninitialised. Handily, + * when we do a write to a port, we will use the same endpoint * regardless of the port, with a 5-byte header added on to - * tell the box which port it should eventually come out of, - * so the same endpoint information needs to be visible to - * write calls regardless of which port is being written. - * To this end we actually keep the relevant endpoints - * in port 0's structure, because that's always there - * and avoids providing our own duplicate members in some - * user data structure for the same purpose. - * URBs will be allocated and freed dynamically as the are - * used, so are not touched here. + * tell the box which port it should eventually come out of, so we only + * need the one set of endpoints. + * Finally we need a bulk in URB to use for background reads from the + * device, which will deal with uplink data from the box to host. */ - if (port0_extra->open_ports == 1) { - /* this is first port to be opened */ + dbg("port number is %d", port->number); + dbg("serial number is %d", port->serial->minor); + dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress); + dbg("port0 bulk out endpoint is %#.2x", + port0->bulk_out_endpointAddress); + + if (dev_extra->open_ports == 0) { + /* this is first port to be opened, so need some URBs */ + /* initialise read_urb for bulk in transfers */ + usb_fill_bulk_urb(port0->read_urb, serial->dev, + usb_rcvbulkpipe(serial->dev, + port0->bulk_in_endpointAddress), + port0->bulk_in_buffer, + port0->bulk_in_size, + qt2_read_bulk_callback, serial); + dbg("port0 bulk in URB intialised"); + + /* submit URB, i.e. start reading from device (async) */ + dev_extra->ReadBulkStopped = false; + port_extra->read_urb_busy = true; + result = usb_submit_urb(port->read_urb, GFP_KERNEL); + if (result) { + dev_err(&port->dev, + "%s - Error %d submitting bulk in urb\n", + __func__, result); + port_extra->read_urb_busy = false; + } } - dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress); - dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress); - dbg("Interrupt endpoint is %d", port->interrupt_in_endpointAddress); - /* initialize our wait queues */ init_waitqueue_head(&port_extra->wait); /* remember to store port_extra and port0 back again at end !*/ qt2_set_port_private(port, port_extra); qt2_set_port_private(serial->port[0], port0_extra); + qt2_set_dev_private(serial, dev_extra); + + dev_extra->open_ports++; /* one more port opened */ return 0; } @@ -486,11 +584,22 @@ static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port } static inline void qt2_set_port_private(struct usb_serial_port *port, - struct quatech2_port *data) + struct quatech2_port *data) { usb_set_serial_port_data(port, (void *)data); } +static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial + *serial) +{ + return (struct quatech2_dev *)usb_get_serial_data(serial); +} +static inline void qt2_set_dev_private(struct usb_serial *serial, + struct quatech2_dev *data) +{ + usb_set_serial_data(serial, (void *)data); +} + static int qt2_openboxchannel(struct usb_serial *serial, __u16 Uart_Number, struct qt2_status_data *status) { @@ -534,6 +643,343 @@ static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, return result; } +/** @brief Callback for asynchronous submission of URBs on bulk in + * endpoints + * + * Registered in qt2_open_port(), used to deal with incomming data + * from the box. + */ +static void qt2_read_bulk_callback(struct urb *urb) +{ + /* Get the device pointer (struct usb_serial) back out of the URB */ + struct usb_serial *serial = urb->context; + /* get the extra struct for the device */ + struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); + /* Get first port structure from the device */ + struct usb_serial_port *port0 = serial->port[0]; + /* Get the currently active port structure from serial struct */ + struct usb_serial_port *active = dev_extra->current_port; + /* get the extra struct for port 0 */ + struct quatech2_port *port0_extra = qt2_get_port_private(port0); + /* and for the currently active port */ + struct quatech2_port *active_extra = qt2_get_port_private(active); + /* When we finally get to doing some tty stuff, we will need this */ + struct tty_struct *tty_st; + unsigned int RxCount; /* the length of the data to process */ + unsigned int i; /* loop counter over the data to process */ + int result; /* return value cache variable */ + bool escapeflag; /* flag set to true if this loop iteration is + * parsing an escape sequence, rather than + * ordinary data */ + + + dbg("%s(): callback running", __func__); + + if (urb->status) { + /* read didn't go well */ + dev_extra->ReadBulkStopped = true; + dbg("%s(): nonzero write bulk status received: %d", + __func__, urb->status); + return; + } + + /* inline port_sofrint() here */ + if (port_paranoia_check(port0, __func__) != 0) { + dbg("%s - port_paranoia_check on port0 failed, exiting\n", +__func__); + return; + } + if (port_paranoia_check(active, __func__) != 0) { + dbg("%s - port_paranoia_check on current_port " + "failed, exiting", __func__); + return; + } + +/* This single callback function has to do for all the ports on + * the device. Data being read up the USB can contain certain + * escape sequences which are used to communicate out-of-band + * information from the serial port in-band over the USB. + * These escapes include sending modem and flow control line + * status, and switching the port. The concept of a "Current Port" + * is used, which is where data is going until a port change + * escape seqence is received. This Current Port is kept between + * callbacks so that when this function enters we know which the + * currently active port is and can get to work right away without + * the box having to send repeat escape sequences (anyway, how + * would it know to do so?). + */ + + if (active_extra->close_pending == true) { + /* We are closing , stop reading */ + dbg("%s - (active->close_pending == true", __func__); + if (dev_extra->open_ports <= 0) { + /* If this is the only port left open - stop the + * bulk read */ + dev_extra->ReadBulkStopped = true; + dbg("%s - (ReadBulkStopped == true;", __func__); + return; + } + } + + /* + * RxHolding is asserted by throttle, if we assert it, we're not + * receiving any more characters and let the box handle the flow + * control + */ + if ((port0_extra->RxHolding == true) && + (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) { + /* single port device, input is already stopped, so we don't + * need any more input data */ + dev_extra->ReadBulkStopped = true; + return; + } + /* finally, we are in a situation where we might consider the data + * that is contained within the URB, and what to do about it. + * This is likely to involved communicating up to the TTY layer, so + * we will need to get hold of the tty for the port we are currently + * dealing with */ + + /* active is a usb_serial_port. It has a member port which is a + * tty_port. From this we get a tty_struct pointer which is what we + * actually wanted, and keep it on tty_st */ + tty_st = tty_port_tty_get(&active->port); + if (!tty_st) { + dbg("%s - bad tty pointer - exiting", __func__); + return; + } + dbg("%s(): active port %d, tty_st =0x%p\n", __func__, active->number, + tty_st); + RxCount = urb->actual_length; /* grab length of data handy */ + + if (RxCount) { + /* skip all this if no data to process */ + for (i = 0; i < RxCount ; ++i) { + /* Look ahead code here -works on several bytes at onc*/ + if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b) + && (NEXTCHAR == 0x1b)) { + /* we are in an escape sequence, type + * determined by the 3rd char */ + escapeflag = false; + switch (THIRDCHAR) { + case 0x00: + /* Line status change 4th byte must + * follow */ + if (i > (RxCount - 4)) { + dbg("Illegal escape sequences " + "in received data"); + break; + } + qt2_process_line_status(active, + FOURTHCHAR); + i += 3; + escapeflag = true; + break; + case 0x01: + /* Modem status status change 4th byte + * must follow */ + if (i > (RxCount - 4)) { + dbg("Illegal escape sequences " + "in received data"); + break; + } + qt2_process_modem_status(active, + FOURTHCHAR); + i += 3; + escapeflag = true; + break; + case 0x02: + /* xmit hold empty 4th byte + * must follow */ + if (i > (RxCount - 4)) { + dbg("Illegal escape sequences " + "in received data"); + break; + } + qt2_process_xmit_empty(active, + FOURTHCHAR, + FIFTHCHAR); + i += 4; + escapeflag = true; + break; + case 0x03: + /* Port number change 4th byte + * must follow */ + if (i > (RxCount - 4)) { + dbg("Illegal escape sequences " + "in received data"); + break; + } + /* Port change. If port open push + * current data up to tty layer */ + if (dev_extra->open_ports > 0) + tty_flip_buffer_push(tty_st); + + dbg("Port Change: new port = %d", + FOURTHCHAR); + qt2_process_port_change(active, + FOURTHCHAR); + i += 3; + escapeflag = true; + /* having changed port, the pointers for + * the currently active port are all out + * of date and need updating */ + active = dev_extra->current_port; + active_extra = + qt2_get_port_private(active); + tty_st = tty_port_tty_get( + &active->port); + break; + case 0x04: + /* Recv flush 3rd byte must + * follow */ + if (i > (RxCount - 3)) { + dbg("Illegal escape sequences " + "in received data"); + break; + } + qt2_process_rcv_flush(active); + i += 2; + escapeflag = true; + break; + case 0x05: + /* xmit flush 3rd byte must follow */ + if (i > (RxCount - 3)) { + dbg("Illegal escape sequences " + "in received data"); + break; + } + qt2_process_xmit_flush(active); + i += 2; + escapeflag = true; + break; + case 0xff: + dbg("No status sequence"); + qt2_process_rx_char(active, THISCHAR); + qt2_process_rx_char(active, NEXTCHAR); + i += 2; + break; + default: + qt2_process_rx_char(active, THISCHAR); + i += 1; + break; + } /*end switch*/ + if (escapeflag == true) + continue; + /* if we did an escape char, we don't need + * to mess around pushing data through the + * tty layer, and can go round again */ + } /*endif*/ + if (tty_st && urb->actual_length) { + tty_buffer_request_room(tty_st, 1); + tty_insert_flip_string(tty_st, + &((unsigned char *)(urb->transfer_buffer) + )[i], + 1); + } + } /*endfor*/ + tty_flip_buffer_push(tty_st); + } /*endif*/ + + /* at this point we have complete dealing with the data for this + * callback. All we have to do now is to start the async read process + * back off again. */ + + usb_fill_bulk_urb(port0->read_urb, serial->dev, + usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress), + port0->bulk_in_buffer, port0->bulk_in_size, + qt2_read_bulk_callback, serial); + result = usb_submit_urb(port0->read_urb, GFP_ATOMIC); + if (result) { + dbg("%s(): failed resubmitting read urb, error %d", + __func__, result); + } else { + if (tty_st && RxCount) { + /* if some inbound data was processed, then + * we need to push that through the tty layer + */ + tty_flip_buffer_push(tty_st); + tty_schedule_flip(tty_st); + } + } + + /* cribbed from serqt_usb2 driver, but not sure which work needs + * scheduling - port0 or currently active port? */ + /* schedule_work(&port->work); */ + + return; +} +static void qt2_process_line_status(struct usb_serial_port *port, + unsigned char LineStatus) +{ + /* obtain the private structure for the port */ + struct quatech2_port *port_extra = qt2_get_port_private(port); + port_extra->shadowLSR = LineStatus & (SERIAL_LSR_OE | SERIAL_LSR_PE | + SERIAL_LSR_FE | SERIAL_LSR_BI); +} +static void qt2_process_modem_status(struct usb_serial_port *port, + unsigned char ModemStatus) +{ + /* obtain the private structure for the port */ + struct quatech2_port *port_extra = qt2_get_port_private(port); + port_extra->shadowMSR = ModemStatus; + /* ?? */ + wake_up_interruptible(&port_extra->wait); +} + +static void qt2_process_xmit_empty(struct usb_serial_port *port, + unsigned char fourth_char, unsigned char fifth_char) +{ + int byte_count; + /* obtain the private structure for the port */ + struct quatech2_port *port_extra = qt2_get_port_private(port); + + byte_count = (int)(fifth_char * 16); + byte_count += (int)fourth_char; + port_extra->xmit_pending_bytes -= (int)byte_count; + port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; +} + +static void qt2_process_port_change(struct usb_serial_port *port, + unsigned char New_Current_Port) +{ + /* obtain the parent usb serial device structure */ + struct usb_serial *serial = port->serial; + /* obtain the private structure for the device */ + struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); + dev_extra->current_port = serial->port[New_Current_Port]; + /* what should I do with this? commented out in upstream + * driver */ + /*schedule_work(&port->work);*/ +} + +static void qt2_process_rcv_flush(struct usb_serial_port *port) +{ + /* obtain the private structure for the port */ + struct quatech2_port *port_extra = qt2_get_port_private(port); + port_extra->rcv_flush = true; +} +static void qt2_process_xmit_flush(struct usb_serial_port *port) +{ + /* obtain the private structure for the port */ + struct quatech2_port *port_extra = qt2_get_port_private(port); + port_extra->xmit_flush = true; +} + +static void qt2_process_rx_char(struct usb_serial_port *port, + unsigned char data) +{ + /* get the tty_struct for this port */ + struct tty_struct *tty = tty_port_tty_get(&(port->port)); + /* get the URB with the data in to push */ + struct urb *urb = port->serial->port[0]->read_urb; + + if (tty && urb->actual_length) { + tty_buffer_request_room(tty, 1); + tty_insert_flip_string(tty, &data, 1); + /* should this be commented out here? */ + /*tty_flip_buffer_push(tty);*/ + } +} /* * last things in file: stuff to register this driver into the generic * USB serial framework. -- 2.39.5