/* 3. Convert baudrate to device-specific divisor */	if (!baud) baud = 9600;		switch(priv->chip_type) {	case SIO: /* SIO chip */		chip_name = "SIO";		switch(baud) {		case 300: div_value = ftdi_sio_b300; break;		case 600: div_value = ftdi_sio_b600; break;		case 1200: div_value = ftdi_sio_b1200; break;		case 2400: div_value = ftdi_sio_b2400; break;		case 4800: div_value = ftdi_sio_b4800; break;		case 9600: div_value = ftdi_sio_b9600; break;		case 19200: div_value = ftdi_sio_b19200; break;		case 38400: div_value = ftdi_sio_b38400; break;		case 57600: div_value = ftdi_sio_b57600;  break;		case 115200: div_value = ftdi_sio_b115200; break;		} /* baud */		if (div_value == 0) {  			dbg("%s - Baudrate (%d) requested is not supported", __FUNCTION__,  baud);			div_value = ftdi_sio_b9600;			div_okay = 0;		}		break;	case FT8U232AM: /* 8U232AM chip */		chip_name = "FT8U232AM";		if (baud <= 3000000) {			div_value = ftdi_232am_baud_to_divisor(baud);		} else {	                dbg("%s - Baud rate too high!", __FUNCTION__);			div_value = ftdi_232am_baud_to_divisor(9600);			div_okay = 0;		}		break;	case FT232BM: /* FT232BM chip */	case FT2232C: /* FT2232C chip */	case FT232R: /* FT232R chip */		if (priv->chip_type == FT232R) {			chip_name = "FT232R";		} else if (priv->chip_type == FT2232C) {			chip_name = "FT2232C";		} else {			chip_name = "FT232BM";		}		if (baud <= 3000000) {			div_value = ftdi_232bm_baud_to_divisor(baud);		} else {	                dbg("%s - Baud rate too high!", __FUNCTION__);			div_value = ftdi_232bm_baud_to_divisor(9600);			div_okay = 0;		}		break;	} /* priv->chip_type */	if (div_okay) {		dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",			__FUNCTION__, baud, (unsigned long)div_value, chip_name);	}	return(div_value);}static int get_serial_info(struct usb_serial_port * port, struct serial_struct * retinfo){	struct ftdi_private * priv = (struct ftdi_private*) port->private;	struct serial_struct tmp;	if (!retinfo)		return -EFAULT;	memset(&tmp, 0, sizeof(tmp));	tmp.flags = priv->flags;	tmp.baud_base = priv->baud_base;	tmp.custom_divisor = priv->custom_divisor;	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))		return -EFAULT;	return 0;} /* get_serial_info */static int set_serial_info(struct usb_serial_port * port, struct serial_struct * newinfo){ /* set_serial_info */	struct ftdi_private * priv = (struct ftdi_private *) port->private;	struct serial_struct new_serial;	struct ftdi_private old_priv;	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))		return -EFAULT;	old_priv = * priv;	/* Do error checking and permission checking */	if (!capable(CAP_SYS_ADMIN)) {		if (((new_serial.flags & ~ASYNC_USR_MASK) !=		     (priv->flags & ~ASYNC_USR_MASK)))			return -EPERM;		priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |			       (new_serial.flags & ASYNC_USR_MASK));		priv->custom_divisor = new_serial.custom_divisor;		goto check_and_exit;	}	if ((new_serial.baud_base != priv->baud_base) &&	    (new_serial.baud_base < 9600))		return -EINVAL;	/* Make the changes - these are privileged changes! */	priv->flags = ((priv->flags & ~ASYNC_FLAGS) |	               (new_serial.flags & ASYNC_FLAGS));		priv->custom_divisor = new_serial.custom_divisor;	port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;check_and_exit:	if ((old_priv.flags & ASYNC_SPD_MASK) !=	     (priv->flags & ASYNC_SPD_MASK)) {		if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)			port->tty->alt_speed = 57600;		else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)			port->tty->alt_speed = 115200;		else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)			port->tty->alt_speed = 230400;		else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)			port->tty->alt_speed = 460800;		else			port->tty->alt_speed = 0;	}	if (((old_priv.flags & ASYNC_SPD_MASK) !=	     (priv->flags & ASYNC_SPD_MASK)) ||	    (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&	     (old_priv.custom_divisor != priv->custom_divisor))) {		change_speed(port);	}		return (0);} /* set_serial_info *//* * *************************************************************************** * FTDI driver specific functions * *************************************************************************** *//* Common startup subroutine *//* Called from ftdi_SIO_startup, etc. */static int ftdi_common_startup (struct usb_serial *serial){	struct usb_serial_port *port = &serial->port[0];	struct ftdi_private *priv;	int i ;	struct urb *urb; 		dbg("%s",__FUNCTION__);	priv = kmalloc(sizeof(struct ftdi_private), GFP_KERNEL);	if (!priv){		err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));		return -ENOMEM;	}	memset(priv, 0, sizeof(*priv));	        init_waitqueue_head(&priv->delta_msr_wait);	/* This will push the characters through immediately rather	   than queue a task to deliver them */	priv->flags = ASYNC_LOW_LATENCY;	/* Increase the size of read buffers */	if (port->bulk_in_buffer) {		kfree (port->bulk_in_buffer);	}	port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL);	if (!port->bulk_in_buffer) {		kfree (priv);		return -ENOMEM;	}	if (port->read_urb) {		port->read_urb->transfer_buffer = port->bulk_in_buffer;		port->read_urb->transfer_buffer_length = BUFSZ;	}	/* Free port's existing write urb and transfer buffer. */	if (port->write_urb) {		usb_free_urb (port->write_urb);		port->write_urb = NULL;	}	if (port->bulk_out_buffer) {		kfree (port->bulk_out_buffer);		port->bulk_out_buffer = NULL;	}	/* create our write urb pool and transfer buffers */ 	spin_lock_init (&priv->write_urb_pool_lock);	for (i = 0; i < NUM_URBS; ++i) {		urb = usb_alloc_urb(0);		priv->write_urb_pool[i] = urb;		if (urb == NULL) {			err("Unable to create new urb in urb pool");			break;		}		urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);		if (!urb->transfer_buffer) {			err("%s - out of memory for urb buffers.", 			    __FUNCTION__);			continue;		}	}	/* Need at least one write urb in the pool */	if (i == 0) {		kfree (priv);		return -ENOMEM;	}	port->private = priv;		return (0);}/* Startup for the SIO chip *//* Called from usbserial:serial_probe */static int ftdi_SIO_startup (struct usb_serial *serial){	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	err = ftdi_common_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->chip_type = SIO;	priv->baud_base = 12000000 / 16;	priv->write_offset = 1;		return (0);}/* Startup for the 8U232AM chip *//* Called from usbserial:serial_probe */static int ftdi_8U232AM_startup (struct usb_serial *serial){ /* ftdi_8U232AM_startup */	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	err = ftdi_common_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->chip_type = FT8U232AM;	priv->baud_base = 48000000 / 2; /* Would be / 16, but FTDI supports 0.125, 0.25 and 0.5 divisor fractions! */		return (0);} /* ftdi_8U232AM_startup *//* Startup for the FT232BM chip *//* Called from usbserial:serial_probe */static int ftdi_FT232BM_startup (struct usb_serial *serial){ /* ftdi_FT232BM_startup */	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	err = ftdi_common_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->chip_type = FT232BM;	priv->baud_base = 48000000 / 2; /* Would be / 16, but FT232BM supports multiple of 0.125 divisor fractions! */		return (0);} /* ftdi_FT232BM_startup *//* Startup for the FT2232C chip *//* Called from usbserial:serial_probe */static int ftdi_FT2232C_startup (struct usb_serial *serial){ /* ftdi_FT2232C_startup */	struct ftdi_private *priv;	int err;	int inter;	dbg("%s",__FUNCTION__);	err = ftdi_common_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->chip_type = FT2232C;	inter = serial->interface->altsetting->bInterfaceNumber;	if(inter) {		priv->interface = INTERFACE_B;	}	else  {		priv->interface = INTERFACE_A;	}	priv->baud_base = 48000000 / 2; /* Would be / 16, but FT232BM supports multiple of 0.125 divisor fractions! */		return (0);} /* ftdi_FT2232C_startup *//* Startup for the FT232R chip *//* Called from usbserial:serial_probe */static int ftdi_FT232R_startup (struct usb_serial *serial){ /* ftdi_FT232R_startup */	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	err = ftdi_common_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->chip_type = FT232R;	priv->baud_base = 48000000 / 2; /* Would be / 16, but FT232BM supports multiple of 0.125 divisor fractions! */		return (0);} /* ftdi_FT232R_startup *//* Startup for the USB-UIRT device, which requires hardwired baudrate (38400 gets mapped to 312500) *//* Called from usbserial:serial_probe */static int ftdi_USB_UIRT_startup (struct usb_serial *serial){ /* ftdi_USB_UIRT_startup */	struct ftdi_private *priv;	int err;	dbg("%s",__FUNCTION__);	err = ftdi_8U232AM_startup(serial);	if (err){		return (err);	}	priv = serial->port->private;	priv->flags |= ASYNC_SPD_CUST;	priv->custom_divisor = 77;	priv->force_baud = B38400;		return (0);} /* ftdi_USB_UIRT_startup *//* Startup for the HE-TIRA1 device, which requires hardwired