* baudrate (38400 gets mapped to 100000) */static int ftdi_HE_TIRA1_startup (struct usb_serial *serial){ /* ftdi_HE_TIRA1_startup */	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	err = ftdi_FT232BM_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->flags |= ASYNC_SPD_CUST;	priv->custom_divisor = 240;	priv->force_baud = B38400;	priv->force_rtscts = 1;		return (0);} /* ftdi_HE_TIRA1_startup *//* Startup for user specified 8U232AM (or 232BM) device */static int ftdi_userdev_startup (struct usb_serial *serial){	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	/* XXX Assume it's a FT8U232AM.  An FT232BM device can be used, but	 * it will behave like a FT8U232AM.  -- IJA */	err = ftdi_8U232AM_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->baud_base = baud_base; 		return (0);}/* ftdi_shutdown is called from usbserial:usb_serial_disconnect  *   it is called when the usb device is disconnected * *   usbserial:usb_serial_disconnect *      calls __serial_close for each open of the port *      shutdown is called then (ie ftdi_shutdown) */static void ftdi_shutdown (struct usb_serial *serial){ /* ftdi_shutdown */		struct usb_serial_port *port = &serial->port[0];		struct ftdi_private *priv = serial->port->private; 	int i;	unsigned long flags; 	dbg("%s", __FUNCTION__);	/* all open ports are closed at this point          *    (by usbserial.c:__serial_close, which calls ftdi_close)  	 */		/* Only execute this if this is the final open port for this device */	if (port->open_count == 0){		spin_lock_irqsave (&priv->write_urb_pool_lock, flags);		for (i = 0; i < NUM_URBS && priv->write_urb_pool[i]; ++i) {			/* FIXME - uncomment the following usb_unlink_urb call when			 * the host controllers get fixed to set urb->dev = NULL after			 * the urb is finished.  Otherwise this call oopses. */			/* usb_unlink_urb(priv->write_urb_pool[i]); */			if (priv->write_urb_pool[i]->transfer_buffer) {				kfree(priv->write_urb_pool[i]->transfer_buffer);				priv->write_urb_pool[i]->transfer_buffer = NULL;			}			usb_free_urb (priv->write_urb_pool[i]);			priv->write_urb_pool[i] = NULL;		}		spin_unlock_irqrestore (&priv->write_urb_pool_lock, flags);		/* usb_disconnect shuts down the port->read_urb so don't do it here */		/* as was done previously */	}	if (serial->port->private){		kfree(serial->port->private);		serial->port->private = NULL;	}} /* ftdi_shutdown */static int  ftdi_open (struct usb_serial_port *port, struct file *filp){ /* ftdi_open */	struct termios tmp_termios;	struct usb_serial *serial = port->serial;	struct ftdi_private *priv = port->private;		int result = 0;	char buf[1]; /* Needed for the usb_control_msg I think */	dbg("%s", __FUNCTION__);	port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;	/* No error checking for this (will get errors later anyway) */	/* See ftdi_sio.h for description of what is reset */	usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),			FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE, 			FTDI_SIO_RESET_SIO, 			priv->interface, buf, 0, WDR_TIMEOUT);	/* Termios defaults are set by usb_serial_init. We don't change	   port->tty->termios - this would loose speed settings, etc.	   This is same behaviour as serial.c/rs_open() - Kuba */	/* ftdi_set_termios  will send usb control messages */	ftdi_set_termios(port, &tmp_termios);	/* FIXME: Flow control might be enabled, so it should be checked -	   we have no control of defaults! */	/* Turn on RTS and DTR since we are not flow controlling by default */	if (set_dtr(port, HIGH) < 0) {		err("%s Error from DTR HIGH urb", __FUNCTION__);	}	if (set_rts(port, HIGH) < 0){		err("%s Error from RTS HIGH urb", __FUNCTION__);	}	/* Start reading from the device */	FILL_BULK_URB(port->read_urb, serial->dev, 		      usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),		      port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,		      ftdi_read_bulk_callback, port);	result = usb_submit_urb(port->read_urb);	if (result)		err("%s - failed submitting read urb, error %d", __FUNCTION__, result);	return result;} /* ftdi_open *//*  * usbserial:__serial_close  only calls ftdi_close if the point is open * *   This only gets called when it is the last close *    *    */static void ftdi_close (struct usb_serial_port *port, struct file *filp){ /* ftdi_close */	struct usb_serial *serial;	unsigned int c_cflag = port->tty->termios->c_cflag;	struct ftdi_private *priv = (struct ftdi_private *)port->private;	char buf[1];	int err;	dbg("%s", __FUNCTION__);	serial = get_usb_serial ( port, __FUNCTION__);	if (!serial)		return;	if (serial->dev) {		if (c_cflag & HUPCL){			/* Disable flow control */			if (usb_control_msg(serial->dev, 					    usb_sndctrlpipe(serial->dev, 0),					    FTDI_SIO_SET_FLOW_CTRL_REQUEST,					    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,					    0, priv->interface, buf, 0, WDR_TIMEOUT) < 0) {				err("error from flowcontrol urb");			}	    			/* drop DTR */			if (set_dtr(port, LOW) < 0){				err("Error from DTR LOW urb");			}			/* drop RTS */			if (set_rts(port, LOW) < 0) {				err("Error from RTS LOW urb");			}		} /* Note change no line is hupcl is off */		/* shutdown our bulk read */		if (port->read_urb) {			err = usb_unlink_urb (port->read_urb);			if (err < 0 && err != -ENODEV)				err("Error unlinking urb (%d)", err);		}		/* unlink the running write urbs */	} /* if (serial->dev) */} /* ftdi_close */  /* The SIO requires the first byte to have: *  B0 1 *  B1 0 *  B2..7 length of message excluding byte 0 * * The new devices do not require this byte */static int ftdi_write (struct usb_serial_port *port, int from_user,			   const unsigned char *buf, int count){ /* ftdi_write */	struct usb_serial *serial = get_usb_serial ( port, __FUNCTION__);	struct ftdi_private *priv = (struct ftdi_private *)port->private;	unsigned char *first_byte;	int data_offset ;       /* will be 1 for the SIO and 0 otherwise */	int result;	int user_bytes_sent = 0 ;   /* amount of user data sent */	/* Variables for urb pool management */	unsigned char *current_position = (unsigned char *)buf;	int i; 	struct urb *urb; /* pointer to urb from urb pool */	unsigned long flags;	/* end of urb pool management */			dbg("%s port %d, %d bytes", __FUNCTION__, port->number, count);	if (count == 0) {		dbg("write request of 0 bytes");		goto exit;	}		data_offset = priv->write_offset;        dbg("data_offset set to %d",data_offset);	while (count > 0) {		/* urb_byte_count = user_byte_count + data_offset */		int urb_byte_count;  /* Number of bytes of URB data   */		int user_byte_count; /* Number of bytes of user data */		/* Find a free urb in the list */		urb = NULL;		spin_lock_irqsave (&(priv->write_urb_pool_lock), flags) ; 		for (i = 0 ; i < NUM_URBS && priv->write_urb_pool[i]; i++) {			if (priv->write_urb_pool[i] -> status != -EINPROGRESS) {				urb = priv->write_urb_pool[i];				/* Must make sure another write doesn't grab this */				urb->status = -EINPROGRESS;				break;			}		}		spin_unlock_irqrestore (&priv->write_urb_pool_lock, flags);		if (urb == NULL) {			dbg("%s - no more free urbs", __FUNCTION__);			goto exit;		}		/* Allocate memory for the urb if necessary */		if (urb->transfer_buffer == NULL) {			urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);			if (urb->transfer_buffer == NULL) {				err("%s ran out of kernel memory for urb ...", __FUNCTION__);				goto exit;			}		}				/* The original sio needs the first byte to contain the bytecount 		 * so the urb may be one byte bigger than the user data 		 */		urb_byte_count = min (count + data_offset, URB_TRANSFER_BUFFER_SIZE);		user_byte_count = urb_byte_count - data_offset; 		/* Copy in the data to send */		if (from_user) {			if (copy_from_user(urb->transfer_buffer + data_offset,					   current_position, user_byte_count )){				return -EFAULT;			}		} else {			memcpy(urb->transfer_buffer + data_offset,			       current_position, user_byte_count );		}  		first_byte = urb->transfer_buffer;		if (data_offset > 0){			/* Write the control byte at the front of the packet*/			*first_byte = 1 | ((user_byte_count) << 2) ; 			dbg("%s Bytes: %d, First Byte: 0x%02x", __FUNCTION__,count, first_byte[0]);		}				usb_serial_debug_data (__FILE__, __FUNCTION__, urb_byte_count, first_byte);				/* fill the buffer and send it */		FILL_BULK_URB(urb, serial->dev, 			      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),			      urb->transfer_buffer, urb_byte_count,			      ftdi_write_bulk_callback, port);		urb->transfer_flags |= USB_QUEUE_BULK;				/* uhci stack errors if it status set to -EINPROGRESS on */		/* urb submission, so clear status before submission.    */		spin_lock_irqsave (&(priv->write_urb_pool_lock), flags) ; 		urb->status = 0;		result = usb_submit_urb(urb);		if (result) {			spin_unlock_irqrestore (&priv->write_urb_pool_lock, flags);			err("%s - failed submitting write urb, error %d", __FUNCTION__, result);			user_bytes_sent = result;			goto exit;		}		spin_unlock_irqrestore (&priv->write_urb_pool_lock, flags);		/* house keeping */		current_position += user_byte_count;		user_bytes_sent += user_byte_count;		count -= user_byte_count;			} /* while  count > 0 */ exit:	dbg("%s write returning: %d", __FUNCTION__, user_bytes_sent);	return user_bytes_sent;} /* ftdi_write *//* This function may get called when the device is closed */static void ftdi_write_bulk_callback (struct urb *urb){	struct usb_serial_port *port = (struct usb_serial_port *)urb->context;	if (port_paranoia_check (port, __FUNCTION__))		return;		dbg("%s - port %d", __FUNCTION__, port->number);		if (urb->status) {		dbg("nonzero write bulk status received: %d", urb->status);		return;	} 	if (port->open_count > 0)