自学教程：C++ tty_encode_baud_rate函数代码示例

/* * Etherbone must be told that a new stream has begun before data arrives. * This is necessary to restart the negotiation of Wishbone bus parameters. * Similarly, when the stream ends, Etherbone must be told so that the cycle * line can be driven low in the case that userspace failed to do so. */static int usb_gsi_openclose(struct usb_serial_port *port, int value){	struct usb_device *dev = port->serial->dev;	return usb_control_msg(		dev,		usb_sndctrlpipe(dev, 0), /* Send to EP0OUT */		GSI_VENDOR_OPENCLOSE,		USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,		value, /* wValue = device is open(1) or closed(0) */		port->serial->interface->cur_altsetting->desc.bInterfaceNumber,		NULL, 0,  /* There is no data stage */		5000); /* Timeout till operation fails */}#if API <= 1static void wishbone_serial_set_termios(struct usb_serial_port *port, struct ktermios *old_termios)#else /* API >= 2 */static void wishbone_serial_init_termios(struct tty_struct *tty)#endif{#if API <= 1	struct ktermios *termios = port->tty->termios;#elif API <= 6	struct ktermios *termios = tty->termios;#else /* API >= 7 */	struct ktermios *termios = &tty->termios;#endif	/*	 * The empeg-car player wants these particular tty settings.	 * You could, for example, change the baud rate, however the	 * player only supports 115200 (currently), so there is really	 * no point in support for changes to the tty settings.	 * (at least for now)	 *	 * The default requirements for this device are:	 */	termios->c_iflag		&= ~(IGNBRK	/* disable ignore break */		| BRKINT	/* disable break causes interrupt */		| PARMRK	/* disable mark parity errors */		| ISTRIP	/* disable clear high bit of input characters */		| INLCR		/* disable translate NL to CR */		| IGNCR		/* disable ignore CR */		| ICRNL		/* disable translate CR to NL */		| IXON);	/* disable enable XON/XOFF flow control */	termios->c_oflag		&= ~OPOST;	/* disable postprocess output characters */	termios->c_lflag		&= ~(ECHO	/* disable echo input characters */		| ECHONL	/* disable echo new line */		| ICANON	/* disable erase, kill, werase, and rprnt special characters */		| ISIG		/* disable interrupt, quit, and suspend special characters */		| IEXTEN);	/* disable non-POSIX special characters */	termios->c_cflag		&= ~(CSIZE	/* no size */		| PARENB	/* disable parity bit */		| CBAUD);	/* clear current baud rate */	termios->c_cflag		|= CS8;		/* character size 8 bits */#if API <= 1	port->tty->low_latency = 1;	tty_encode_baud_rate(port->tty, 115200, 115200);#else /* API >= 2 */	tty_encode_baud_rate(tty, 115200, 115200);#endif}

/* * CP2101 supports the following baud rates: * *	300, 600, 1200, 1800, 2400, 4800, 7200, 9600, 14400, 19200, 28800, *	38400, 56000, 57600, 115200, 128000, 230400, 460800, 921600 * * CP2102 and CP2103 support the following additional rates: * *	4000, 16000, 51200, 64000, 76800, 153600, 250000, 256000, 500000, *	576000 * * The device will map a requested rate to a supported one, but the result * of requests for rates greater than 1053257 is undefined (see AN205). * * CP2104, CP2105 and CP2110 support most rates up to 2M, 921k and 1M baud, * respectively, with an error less than 1%. The actual rates are determined * by * *	div = round(freq / (2 x prescale x request)) *	actual = freq / (2 x prescale x div) * * For CP2104 and CP2105 freq is 48Mhz and prescale is 4 for request <= 365bps * or 1 otherwise. * For CP2110 freq is 24Mhz and prescale is 4 for request <= 300bps or 1 * otherwise. */static void cp210x_change_speed(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	u32 baud;	baud = tty->termios->c_ospeed;	/* This maps the requested rate to a rate valid on cp2102 or cp2103,	 * or to an arbitrary rate in [1M,2M].	 *	 * NOTE: B0 is not implemented.	 */	baud = cp210x_quantise_baudrate(baud);	dbg("%s - setting baud rate to %u", __func__, baud);	if (cp210x_set_config(port, CP210X_SET_BAUDRATE, &baud,							sizeof(baud))) {		dev_warn(&port->dev, "failed to set baud rate to %u/n", baud);		if (old_termios)			baud = old_termios->c_ospeed;		else			baud = 9600;	}	tty_encode_baud_rate(tty, baud, baud);}

static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old){	struct kobil_private * priv;	int result;	unsigned short urb_val = 0;	int c_cflag = port->tty->termios->c_cflag;	speed_t speed;	void * settings;	priv = usb_get_serial_port_data(port);	if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)		// This device doesn't support ioctl calls		return;	switch (speed = tty_get_baud_rate(port->tty)) {		case 1200:			urb_val = SUSBCR_SBR_1200;			break;		default:			speed = 9600;		case 9600:			urb_val = SUSBCR_SBR_9600;			break;	}	urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits : SUSBCR_SPASB_1StopBit;	settings = kzalloc(50, GFP_KERNEL);	if (! settings)		return;	sprintf(settings, "%d ", speed);	if (c_cflag & PARENB) {		if  (c_cflag & PARODD) {			urb_val |= SUSBCR_SPASB_OddParity;			strcat(settings, "Odd Parity");		} else {			urb_val |= SUSBCR_SPASB_EvenParity;			strcat(settings, "Even Parity");		}	} else {		urb_val |= SUSBCR_SPASB_NoParity;		strcat(settings, "No Parity");	}	port->tty->termios->c_cflag &= ~CMSPAR;	tty_encode_baud_rate(port->tty, speed, speed);	result = usb_control_msg( port->serial->dev,				  usb_rcvctrlpipe(port->serial->dev, 0 ),				  SUSBCRequest_SetBaudRateParityAndStopBits,				  USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,				  urb_val,				  0,				  settings,				  0,				  KOBIL_TIMEOUT		);	kfree(settings);}

static void kobil_set_termios(struct tty_struct *tty,			struct usb_serial_port *port, struct ktermios *old){	struct kobil_private *priv;	int result;	unsigned short urb_val = 0;	int c_cflag = tty->termios->c_cflag;	speed_t speed;	priv = usb_get_serial_port_data(port);	if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||			priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {		/*                                         */		*tty->termios = *old;		return;	}	speed = tty_get_baud_rate(tty);	switch (speed) {	case 1200:		urb_val = SUSBCR_SBR_1200;		break;	default:		speed = 9600;	case 9600:		urb_val = SUSBCR_SBR_9600;		break;	}	urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits :							SUSBCR_SPASB_1StopBit;	if (c_cflag & PARENB) {		if  (c_cflag & PARODD)			urb_val |= SUSBCR_SPASB_OddParity;		else			urb_val |= SUSBCR_SPASB_EvenParity;	} else		urb_val |= SUSBCR_SPASB_NoParity;	tty->termios->c_cflag &= ~CMSPAR;	tty_encode_baud_rate(tty, speed, speed);	result = usb_control_msg(port->serial->dev,		  usb_rcvctrlpipe(port->serial->dev, 0),		  SUSBCRequest_SetBaudRateParityAndStopBits,		  USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,		  urb_val,		  0,		  NULL,		  0,		  KOBIL_TIMEOUT		);}

static void empeg_set_termios (struct usb_serial_port *port, struct ktermios *old_termios){	struct ktermios *termios = port->tty->termios;	dbg("%s - port %d", __FUNCTION__, port->number);	/*         * The empeg-car player wants these particular tty settings.         * You could, for example, change the baud rate, however the         * player only supports 115200 (currently), so there is really         * no point in support for changes to the tty settings.         * (at least for now)         *         * The default requirements for this device are:         */	termios->c_iflag		&= ~(IGNBRK	/* disable ignore break */		| BRKINT	/* disable break causes interrupt */		| PARMRK	/* disable mark parity errors */		| ISTRIP	/* disable clear high bit of input characters */		| INLCR		/* disable translate NL to CR */		| IGNCR		/* disable ignore CR */		| ICRNL		/* disable translate CR to NL */		| IXON);	/* disable enable XON/XOFF flow control */	termios->c_oflag		&= ~OPOST;	/* disable postprocess output characters */	termios->c_lflag		&= ~(ECHO	/* disable echo input characters */		| ECHONL	/* disable echo new line */		| ICANON	/* disable erase, kill, werase, and rprnt special characters */		| ISIG		/* disable interrupt, quit, and suspend special characters */		| IEXTEN);	/* disable non-POSIX special characters */	termios->c_cflag		&= ~(CSIZE	/* no size */		| PARENB	/* disable parity bit */		| CBAUD);	/* clear current baud rate */	termios->c_cflag		|= CS8;		/* character size 8 bits */	/*	 * Force low_latency on; otherwise the pushes are scheduled;	 * this is bad as it opens up the possibility of dropping bytes	 * on the floor.  We don't want to drop bytes on the floor. :)	 */	port->tty->low_latency = 1;	tty_encode_baud_rate(port->tty, 115200, 115200);}

/* * cp210x_get_termios * Reads the baud rate, data bits, parity, stop bits and flow control mode * from the device, corrects any unsupported values, and configures the * termios structure to reflect the state of the device */static void cp210x_get_termios(struct tty_struct *tty,	struct usb_serial_port *port){	unsigned int baud;	if (tty) {		cp210x_get_termios_port(tty->driver_data,			&tty->termios->c_cflag, &baud);		tty_encode_baud_rate(tty, baud, baud);	}	else {		unsigned int cflag;		cflag = 0;		cp210x_get_termios_port(port, &cflag, &baud);	}}

static void ev3_uart_change_bitrate(struct work_struct *work){	struct ev3_uart_port_data *port = container_of(work,				struct ev3_uart_port_data, change_bitrate_work);	struct ktermios old_termios = port->tty->termios;	tty_wait_until_sent(port->tty, 0);	down_write(&port->tty->termios_rwsem);	tty_encode_baud_rate(port->tty, port->new_baud_rate, port->new_baud_rate);	if (port->tty->ops->set_termios)		port->tty->ops->set_termios(port->tty, &old_termios);	up_write(&port->tty->termios_rwsem);	if (port->info_done) {		hrtimer_start(&port->keep_alive_timer, ktime_set(0, 1000000),			      HRTIMER_MODE_REL);		/* restore the previous user-selected mode */		if (port->sensor.mode != port->requested_mode)			ev3_uart_set_mode(port->tty, port->requested_mode);	}}

static void legoev3_uart_change_bitrate(struct work_struct *work){	struct delayed_work *dwork = to_delayed_work(work);	struct legoev3_uart_port_data *port =		container_of(dwork, struct legoev3_uart_port_data,			     change_bitrate_work);	struct ktermios old_termios = *port->tty->termios;	tty_wait_until_sent(port->tty, 0);	mutex_lock(&port->tty->termios_mutex);	tty_encode_baud_rate(port->tty, port->new_baud_rate, port->new_baud_rate);	if (port->tty->ops->set_termios)		port->tty->ops->set_termios(port->tty, &old_termios);	mutex_unlock(&port->tty->termios_mutex);	if (port->info_done) {		hrtimer_start(&port->keep_alive_timer,			ktime_set(0, LEGOEV3_UART_DATA_KEEP_ALIVE_TIMEOUT / 2				     * 1000000),			HRTIMER_MODE_REL);	}}

/* Old_termios contains the original termios settings and * tty->termios contains the new setting to be used. */static void ch341_set_termios(struct usb_serial_port *port,			      struct ktermios *old_termios){	struct ch341_private *priv = usb_get_serial_port_data(port);	struct tty_struct *tty = port->tty;	unsigned baud_rate;	dbg("ch341_set_termios()");	baud_rate = tty_get_baud_rate(tty);	switch (baud_rate) {	case 2400:	case 4800:	case 9600:	case 19200:	case 38400:	case 115200:		priv->baud_rate = baud_rate;		break;	default:		dbg("Rate %d not supported, using %d",			baud_rate, DEFAULT_BAUD_RATE);		priv->baud_rate = DEFAULT_BAUD_RATE;	}	ch341_set_baudrate(port->serial->dev, priv);	/* Unimplemented:	 * (cflag & CSIZE) : data bits [5, 8]	 * (cflag & PARENB) : parity {NONE, EVEN, ODD}	 * (cflag & CSTOPB) : stop bits [1, 2]	 */	 /* Copy back the old hardware settings */	 tty_termios_copy_hw(tty->termios, old_termios);	 /* And re-encode with the new baud */	 tty_encode_baud_rate(tty, baud_rate, baud_rate);}

static void firm_setup_port(struct tty_struct *tty){	struct usb_serial_port *port = tty->driver_data;	struct whiteheat_port_settings port_settings;	unsigned int cflag = tty->termios->c_cflag;	port_settings.port = port->number + 1;	/* get the byte size */	switch (cflag & CSIZE) {	case CS5:	port_settings.bits = 5;   break;	case CS6:	port_settings.bits = 6;   break;	case CS7:	port_settings.bits = 7;   break;	default:	case CS8:	port_settings.bits = 8;   break;	}	dbg("%s - data bits = %d", __func__, port_settings.bits);	/* determine the parity */	if (cflag & PARENB)		if (cflag & CMSPAR)			if (cflag & PARODD)				port_settings.parity = WHITEHEAT_PAR_MARK;			else				port_settings.parity = WHITEHEAT_PAR_SPACE;		else			if (cflag & PARODD)				port_settings.parity = WHITEHEAT_PAR_ODD;			else				port_settings.parity = WHITEHEAT_PAR_EVEN;	else		port_settings.parity = WHITEHEAT_PAR_NONE;	dbg("%s - parity = %c", __func__, port_settings.parity);	/* figure out the stop bits requested */	if (cflag & CSTOPB)		port_settings.stop = 2;	else		port_settings.stop = 1;	dbg("%s - stop bits = %d", __func__, port_settings.stop);	/* figure out the flow control settings */	if (cflag & CRTSCTS)		port_settings.hflow = (WHITEHEAT_HFLOW_CTS |						WHITEHEAT_HFLOW_RTS);	else		port_settings.hflow = WHITEHEAT_HFLOW_NONE;	dbg("%s - hardware flow control = %s %s %s %s", __func__,	    (port_settings.hflow & WHITEHEAT_HFLOW_CTS) ? "CTS" : "",	    (port_settings.hflow & WHITEHEAT_HFLOW_RTS) ? "RTS" : "",	    (port_settings.hflow & WHITEHEAT_HFLOW_DSR) ? "DSR" : "",	    (port_settings.hflow & WHITEHEAT_HFLOW_DTR) ? "DTR" : "");	/* determine software flow control */	if (I_IXOFF(tty))		port_settings.sflow = WHITEHEAT_SFLOW_RXTX;	else		port_settings.sflow = WHITEHEAT_SFLOW_NONE;	dbg("%s - software flow control = %c", __func__, port_settings.sflow);	port_settings.xon = START_CHAR(tty);	port_settings.xoff = STOP_CHAR(tty);	dbg("%s - XON = %2x, XOFF = %2x",			__func__, port_settings.xon, port_settings.xoff);	/* get the baud rate wanted */	port_settings.baud = tty_get_baud_rate(tty);	dbg("%s - baud rate = %d", __func__, port_settings.baud);	/* fixme: should set validated settings */	tty_encode_baud_rate(tty, port_settings.baud, port_settings.baud);	/* handle any settings that aren't specified in the tty structure */	port_settings.lloop = 0;	/* now send the message to the device */	firm_send_command(port, WHITEHEAT_SETUP_PORT,			(__u8 *)&port_settings, sizeof(port_settings));}

static void ir_set_termios(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	struct urb *urb;	unsigned char *transfer_buffer;	int result;	speed_t baud;	int ir_baud;	dbg("%s - port %d", __func__, port->number);	baud = tty_get_baud_rate(tty);	/*	 * FIXME, we should compare the baud request against the	 * capability stated in the IR header that we got in the	 * startup function.	 */	switch (baud) {	case 2400:		ir_baud = USB_IRDA_BR_2400;		break;	case 9600:		ir_baud = USB_IRDA_BR_9600;		break;	case 19200:		ir_baud = USB_IRDA_BR_19200;		break;	case 38400:		ir_baud = USB_IRDA_BR_38400;		break;	case 57600:		ir_baud = USB_IRDA_BR_57600;		break;	case 115200:		ir_baud = USB_IRDA_BR_115200;		break;	case 576000:		ir_baud = USB_IRDA_BR_576000;		break;	case 1152000:		ir_baud = USB_IRDA_BR_1152000;		break;	case 4000000:		ir_baud = USB_IRDA_BR_4000000;		break;	default:		ir_baud = USB_IRDA_BR_9600;		baud = 9600;	}	if (xbof == -1)		ir_xbof = ir_xbof_change(ir_add_bof);	else		ir_xbof = ir_xbof_change(xbof) ;	/* Only speed changes are supported */	tty_termios_copy_hw(tty->termios, old_termios);	tty_encode_baud_rate(tty, baud, baud);	/*	 * send the baud change out on an "empty" data packet	 */	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		dev_err(&port->dev, "%s - no more urbs/n", __func__);		return;	}	transfer_buffer = kmalloc(1, GFP_KERNEL);	if (!transfer_buffer) {		dev_err(&port->dev, "%s - out of memory/n", __func__);		goto err_buf;	}	*transfer_buffer = ir_xbof | ir_baud;	usb_fill_bulk_urb(		urb,		port->serial->dev,		usb_sndbulkpipe(port->serial->dev,			port->bulk_out_endpointAddress),		transfer_buffer,		1,		ir_set_termios_callback,		port);	urb->transfer_flags = URB_ZERO_PACKET;	result = usb_submit_urb(urb, GFP_KERNEL);	if (result) {		dev_err(&port->dev, "%s - failed to submit urb: %d/n",							__func__, result);		goto err_subm;	}	usb_free_urb(urb);	return;err_subm://.........这里部分代码省略.........

static void cp2101_set_termios(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	unsigned int cflag, old_cflag;	unsigned int baud = 0, bits;	unsigned int modem_ctl[4];	dbg("%s - port %d", __func__, port->number);	if (!tty)		return;	tty->termios->c_cflag &= ~CMSPAR;	cflag = tty->termios->c_cflag;	old_cflag = old_termios->c_cflag;	baud = tty_get_baud_rate(tty);	/* If the baud rate is to be updated*/	if (baud != tty_termios_baud_rate(old_termios)) {		switch (baud) {		case 0:		case 600:		case 1200:		case 1800:		case 2400:		case 4800:		case 7200:		case 9600:		case 14400:		case 19200:		case 28800:		case 38400:		case 55854:		case 57600:		case 115200:		case 127117:		case 230400:		case 460800:		case 921600:		case 3686400:			break;		default:			baud = 9600;			break;		}		if (baud) {			dbg("%s - Setting baud rate to %d baud", __func__,					baud);			if (cp2101_set_config_single(port, CP2101_BAUDRATE,						(BAUD_RATE_GEN_FREQ / baud))) {				dev_err(&port->dev, "Baud rate requested not "						"supported by device/n");				baud = tty_termios_baud_rate(old_termios);			}		}	}	/* Report back the resulting baud rate */	tty_encode_baud_rate(tty, baud, baud);	/* If the number of data bits is to be updated */	if ((cflag & CSIZE) != (old_cflag & CSIZE)) {		cp2101_get_config(port, CP2101_BITS, &bits, 2);		bits &= ~BITS_DATA_MASK;		switch (cflag & CSIZE) {		case CS5:			bits |= BITS_DATA_5;			dbg("%s - data bits = 5", __func__);			break;		case CS6:			bits |= BITS_DATA_6;			dbg("%s - data bits = 6", __func__);			break;		case CS7:			bits |= BITS_DATA_7;			dbg("%s - data bits = 7", __func__);			break;		case CS8:			bits |= BITS_DATA_8;			dbg("%s - data bits = 8", __func__);			break;		/*case CS9:			bits |= BITS_DATA_9;			dbg("%s - data bits = 9", __func__);			break;*/		default:			dev_err(&port->dev, "cp2101 driver does not "					"support the number of bits requested,"					" using 8 bit mode/n");				bits |= BITS_DATA_8;				break;		}		if (cp2101_set_config(port, CP2101_BITS, &bits, 2))			dev_err(&port->dev, "Number of data bits requested "					"not supported by device/n");	}	if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {		cp2101_get_config(port, CP2101_BITS, &bits, 2);		bits &= ~BITS_PARITY_MASK;//.........这里部分代码省略.........

static void klsi_105_set_termios(struct tty_struct *tty,				 struct usb_serial_port *port,				 struct ktermios *old_termios){	struct klsi_105_private *priv = usb_get_serial_port_data(port);	unsigned int iflag = tty->termios->c_iflag;	unsigned int old_iflag = old_termios->c_iflag;	unsigned int cflag = tty->termios->c_cflag;	unsigned int old_cflag = old_termios->c_cflag;	struct klsi_105_port_settings *cfg;	unsigned long flags;	speed_t baud;	cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);	if (!cfg) {		dev_err(&port->dev, "%s - out of memory for config buffer./n",				__func__);		return;	}	/* lock while we are modifying the settings */	spin_lock_irqsave(&priv->lock, flags);	/*	 * Update baud rate	 */	baud = tty_get_baud_rate(tty);	if ((cflag & CBAUD) != (old_cflag & CBAUD)) {		/* reassert DTR and (maybe) RTS on transition from B0 */		if ((old_cflag & CBAUD) == B0) {			dbg("%s: baud was B0", __func__);#if 0			priv->control_state |= TIOCM_DTR;			/* don't set RTS if using hardware flow control */			if (!(old_cflag & CRTSCTS))				priv->control_state |= TIOCM_RTS;			mct_u232_set_modem_ctrl(serial, priv->control_state);#endif		}	}	switch (baud) {	case 0: /* handled below */		break;	case 1200:		priv->cfg.baudrate = kl5kusb105a_sio_b1200;		break;	case 2400:		priv->cfg.baudrate = kl5kusb105a_sio_b2400;		break;	case 4800:		priv->cfg.baudrate = kl5kusb105a_sio_b4800;		break;	case 9600:		priv->cfg.baudrate = kl5kusb105a_sio_b9600;		break;	case 19200:		priv->cfg.baudrate = kl5kusb105a_sio_b19200;		break;	case 38400:		priv->cfg.baudrate = kl5kusb105a_sio_b38400;		break;	case 57600:		priv->cfg.baudrate = kl5kusb105a_sio_b57600;		break;	case 115200:		priv->cfg.baudrate = kl5kusb105a_sio_b115200;		break;	default:		dbg("KLSI USB->Serial converter:"		    " unsupported baudrate request, using default of 9600");			priv->cfg.baudrate = kl5kusb105a_sio_b9600;		baud = 9600;		break;	}	if ((cflag & CBAUD) == B0) {		dbg("%s: baud is B0", __func__);		/* Drop RTS and DTR */		/* maybe this should be simulated by sending read		 * disable and read enable messages?		 */		;#if 0		priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);		mct_u232_set_modem_ctrl(serial, priv->control_state);#endif	}	tty_encode_baud_rate(tty, baud, baud);	if ((cflag & CSIZE) != (old_cflag & CSIZE)) {		/* set the number of data bits */		switch (cflag & CSIZE) {		case CS5:			dbg("%s - 5 bits/byte not supported", __func__);			spin_unlock_irqrestore(&priv->lock, flags);			goto err;		case CS6:			dbg("%s - 6 bits/byte not supported", __func__);			spin_unlock_irqrestore(&priv->lock, flags);			goto err;//.........这里部分代码省略.........

static void cp210x_set_termios(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	unsigned int cflag, old_cflag;	unsigned int baud = 0, bits;	unsigned int modem_ctl[4];	dbg("%s - port %d", __func__, port->number);	if (!tty)		return;	tty->termios->c_cflag &= ~CMSPAR;	cflag = tty->termios->c_cflag;	old_cflag = old_termios->c_cflag;	baud = cp210x_quantise_baudrate(tty_get_baud_rate(tty));	/* If the baud rate is to be updated*/	if (baud != tty_termios_baud_rate(old_termios) && baud != 0) {		dbg("%s - Setting baud rate to %d baud", __func__,				baud);		if (cp210x_set_config_single(port, CP210X_SET_BAUDDIV,					((BAUD_RATE_GEN_FREQ + baud/2) / baud))) {			dbg("Baud rate requested not supported by device");			baud = tty_termios_baud_rate(old_termios);		}	}	/* Report back the resulting baud rate */	tty_encode_baud_rate(tty, baud, baud);	/* If the number of data bits is to be updated */	if ((cflag & CSIZE) != (old_cflag & CSIZE)) {		cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);		bits &= ~BITS_DATA_MASK;		switch (cflag & CSIZE) {		case CS5:			bits |= BITS_DATA_5;			dbg("%s - data bits = 5", __func__);			break;		case CS6:			bits |= BITS_DATA_6;			dbg("%s - data bits = 6", __func__);			break;		case CS7:			bits |= BITS_DATA_7;			dbg("%s - data bits = 7", __func__);			break;		case CS8:			bits |= BITS_DATA_8;			dbg("%s - data bits = 8", __func__);			break;		/*case CS9:			bits |= BITS_DATA_9;			dbg("%s - data bits = 9", __func__);			break;*/		default:			dbg("cp210x driver does not "					"support the number of bits requested,"					" using 8 bit mode/n");				bits |= BITS_DATA_8;				break;		}		if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))			dbg("Number of data bits requested "					"not supported by device/n");	}	if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {		cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);		bits &= ~BITS_PARITY_MASK;		if (cflag & PARENB) {			if (cflag & PARODD) {				bits |= BITS_PARITY_ODD;				dbg("%s - parity = ODD", __func__);			} else {				bits |= BITS_PARITY_EVEN;				dbg("%s - parity = EVEN", __func__);			}		}		if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))			dbg("Parity mode not supported "					"by device/n");	}	if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {		cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);		bits &= ~BITS_STOP_MASK;		if (cflag & CSTOPB) {			bits |= BITS_STOP_2;			dbg("%s - stop bits = 2", __func__);		} else {			bits |= BITS_STOP_1;			dbg("%s - stop bits = 1", __func__);		}		if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))			dbg("Number of stop bits requested "					"not supported by device/n");	}	if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {//.........这里部分代码省略.........

static void belkin_sa_set_termios(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	struct usb_serial *serial = port->serial;	struct belkin_sa_private *priv = usb_get_serial_port_data(port);	unsigned int iflag;	unsigned int cflag;	unsigned int old_iflag = 0;	unsigned int old_cflag = 0;	__u16 urb_value = 0; /* Will hold the new flags */	unsigned long flags;	unsigned long control_state;	int bad_flow_control;	speed_t baud;	struct ktermios *termios = tty->termios;	iflag = termios->c_iflag;	cflag = termios->c_cflag;	termios->c_cflag &= ~CMSPAR;	/* get a local copy of the current port settings */	spin_lock_irqsave(&priv->lock, flags);	control_state = priv->control_state;	bad_flow_control = priv->bad_flow_control;	spin_unlock_irqrestore(&priv->lock, flags);	old_iflag = old_termios->c_iflag;	old_cflag = old_termios->c_cflag;	/* Set the baud rate */	if ((cflag & CBAUD) != (old_cflag & CBAUD)) {		/* reassert DTR and (maybe) RTS on transition from B0 */		if ((old_cflag & CBAUD) == B0) {			control_state |= (TIOCM_DTR|TIOCM_RTS);			if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)				dev_err(&port->dev, "Set DTR error/n");			/* don't set RTS if using hardware flow control */			if (!(old_cflag & CRTSCTS))				if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST								, 1) < 0)					dev_err(&port->dev, "Set RTS error/n");		}	}	baud = tty_get_baud_rate(tty);	if (baud) {		urb_value = BELKIN_SA_BAUD(baud);		/* Clip to maximum speed */		if (urb_value == 0)			urb_value = 1;		/* Turn it back into a resulting real baud rate */		baud = BELKIN_SA_BAUD(urb_value);		/* Report the actual baud rate back to the caller */		tty_encode_baud_rate(tty, baud, baud);		if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)			dev_err(&port->dev, "Set baudrate error/n");	} else {		/* Disable flow control */		if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,						BELKIN_SA_FLOW_NONE) < 0)			dev_err(&port->dev, "Disable flowcontrol error/n");		/* Drop RTS and DTR */		control_state &= ~(TIOCM_DTR | TIOCM_RTS);		if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)			dev_err(&port->dev, "DTR LOW error/n");		if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)			dev_err(&port->dev, "RTS LOW error/n");	}	/* set the parity */	if ((cflag ^ old_cflag) & (PARENB | PARODD)) {		if (cflag & PARENB)			urb_value = (cflag & PARODD) ?  BELKIN_SA_PARITY_ODD						: BELKIN_SA_PARITY_EVEN;		else			urb_value = BELKIN_SA_PARITY_NONE;		if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)			dev_err(&port->dev, "Set parity error/n");	}	/* set the number of data bits */	if ((cflag & CSIZE) != (old_cflag & CSIZE)) {		switch (cflag & CSIZE) {		case CS5:			urb_value = BELKIN_SA_DATA_BITS(5);			break;		case CS6:			urb_value = BELKIN_SA_DATA_BITS(6);			break;		case CS7:			urb_value = BELKIN_SA_DATA_BITS(7);			break;		case CS8:			urb_value = BELKIN_SA_DATA_BITS(8);			break;		default: dbg("CSIZE was not CS5-CS8, using default of 8");			urb_value = BELKIN_SA_DATA_BITS(8);			break;//.........这里部分代码省略.........

//.........这里部分代码省略.........	 */	baud = uart_get_baud_rate(port, termios, old, 50, port->uartclk / 16);	quot = uart_get_divisor(port, baud);	spin_lock_irqsave(&sport->port.lock, flags);	sport->port.read_status_mask = 0;	if (termios->c_iflag & INPCK)		sport->port.read_status_mask |= (URXD_FRMERR | URXD_PRERR);	if (termios->c_iflag & (BRKINT | PARMRK))		sport->port.read_status_mask |= URXD_BRK;	/*	 * Characters to ignore	 */	sport->port.ignore_status_mask = 0;	if (termios->c_iflag & IGNPAR)		sport->port.ignore_status_mask |= URXD_PRERR;	if (termios->c_iflag & IGNBRK) {		sport->port.ignore_status_mask |= URXD_BRK;		/*		 * If we're ignoring parity and break indicators,		 * ignore overruns too (for real raw support).		 */		if (termios->c_iflag & IGNPAR)			sport->port.ignore_status_mask |= URXD_OVRRUN;	}	del_timer_sync(&sport->timer);	/*	 * Update the per-port timeout.	 */	uart_update_timeout(port, termios->c_cflag, baud);	/*	 * disable interrupts and drain transmitter	 */	old_ucr1 = readl(sport->port.membase + UCR1);	writel(old_ucr1 & ~(UCR1_TXMPTYEN | UCR1_RRDYEN | UCR1_RTSDEN),			sport->port.membase + UCR1);	while ( !(readl(sport->port.membase + USR2) & USR2_TXDC))		barrier();	/* then, disable everything */	old_txrxen = readl(sport->port.membase + UCR2);	writel(old_txrxen & ~( UCR2_TXEN | UCR2_RXEN),			sport->port.membase + UCR2);	old_txrxen &= (UCR2_TXEN | UCR2_RXEN);	if (USE_IRDA(sport)) {		/*		 * use maximum available submodule frequency to		 * avoid missing short pulses due to low sampling rate		 */		div = 1;	} else {		div = sport->port.uartclk / (baud * 16);		if (div > 7)			div = 7;		if (!div)			div = 1;	}	rational_best_approximation(16 * div * baud, sport->port.uartclk,		1 << 16, 1 << 16, &num, &denom);	if (port->state && port->state->port.tty) {		tdiv64 = sport->port.uartclk;		tdiv64 *= num;		do_div(tdiv64, denom * 16 * div);		tty_encode_baud_rate(sport->port.state->port.tty,				(speed_t)tdiv64, (speed_t)tdiv64);	}	num -= 1;	denom -= 1;	ufcr = readl(sport->port.membase + UFCR);	ufcr = (ufcr & (~UFCR_RFDIV)) | UFCR_RFDIV_REG(div);	writel(ufcr, sport->port.membase + UFCR);	writel(num, sport->port.membase + UBIR);	writel(denom, sport->port.membase + UBMR);	if (!cpu_is_mx1())		writel(sport->port.uartclk / div / 1000,				sport->port.membase + MX2_ONEMS);	writel(old_ucr1, sport->port.membase + UCR1);	/* set the parity, stop bits and data size */	writel(ucr2 | old_txrxen, sport->port.membase + UCR2);	if (UART_ENABLE_MS(&sport->port, termios->c_cflag))		imx_enable_ms(&sport->port);	spin_unlock_irqrestore(&sport->port.lock, flags);}

static void ark3116_set_termios(struct tty_struct *tty,				struct usb_serial_port *port,				struct ktermios *old_termios){	struct usb_serial *serial = port->serial;	struct ktermios *termios = tty->termios;	unsigned int cflag = termios->c_cflag;	int baud;	int ark3116_baud;	char *buf;	char config;	config = 0;	dbg("%s - port %d", __func__, port->number);	cflag = termios->c_cflag;	termios->c_cflag &= ~(CMSPAR|CRTSCTS);	buf = kmalloc(1, GFP_KERNEL);	if (!buf) {		dbg("error kmalloc");		*termios = *old_termios;		return;	}	/* set data bit count (8/7/6/5) */	if (cflag & CSIZE) {		switch (cflag & CSIZE) {		case CS5:			config |= 0x00;			dbg("setting CS5");			break;		case CS6:			config |= 0x01;			dbg("setting CS6");			break;		case CS7:			config |= 0x02;			dbg("setting CS7");			break;		default:			dbg("CSIZE was set but not CS5-CS8, using CS8!");			/* fall through */		case CS8:			config |= 0x03;			dbg("setting CS8");			break;		}	}	/* set parity (NONE/EVEN/ODD) */	if (cflag & PARENB) {		if (cflag & PARODD) {			config |= 0x08;			dbg("setting parity to ODD");		} else {			config |= 0x18;			dbg("setting parity to EVEN");		}	} else {		dbg("setting parity to NONE");	}	/* set stop bit (1/2) */	if (cflag & CSTOPB) {		config |= 0x04;		dbg("setting 2 stop bits");	} else {		dbg("setting 1 stop bit");	}	/* set baudrate */	baud = tty_get_baud_rate(tty);	switch (baud) {	case 75:	case 150:	case 300:	case 600:	case 1200:	case 1800:	case 2400:	case 4800:	case 9600:	case 19200:	case 38400:	case 57600:	case 115200:	case 230400:	case 460800:		/* Report the resulting rate back to the caller */		tty_encode_baud_rate(tty, baud, baud);		break;	/* set 9600 as default (if given baudrate is invalid for example) */	default:		tty_encode_baud_rate(tty, 9600, 9600);	case 0:		baud = 9600;//.........这里部分代码省略.........

static void pl2303_encode_baudrate(struct tty_struct *tty,					struct usb_serial_port *port,					u8 buf[4]){	const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,	                         4800, 7200, 9600, 14400, 19200, 28800, 38400,	                         57600, 115200, 230400, 460800, 500000, 614400,	                         921600, 1228800, 2457600, 3000000, 6000000 };	struct usb_serial *serial = port->serial;	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);	int baud;	int i;	/*	 * NOTE: Only the values defined in baud_sup are supported!	 *       => if unsupported values are set, the PL2303 seems to use	 *          9600 baud (at least my PL2303X always does)	 */	baud = tty_get_baud_rate(tty);	dev_dbg(&port->dev, "baud requested = %d/n", baud);	if (!baud)		return;	/* Set baudrate to nearest supported value */	for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {		if (baud_sup[i] > baud)			break;	}	if (i == ARRAY_SIZE(baud_sup))		baud = baud_sup[i - 1];	else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))		baud = baud_sup[i - 1];	else		baud = baud_sup[i];	/* type_0, type_1 only support up to 1228800 baud */	if (spriv->type != HX)		baud = min_t(int, baud, 1228800);	if (baud <= 115200) {		put_unaligned_le32(baud, buf);	} else {		/*		 * Apparently the formula for higher speeds is:		 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]		 */		unsigned tmp = 12000000 * 32 / baud;		buf[3] = 0x80;		buf[2] = 0;		buf[1] = (tmp >= 256);		while (tmp >= 256) {			tmp >>= 2;			buf[1] <<= 1;		}		buf[0] = tmp;	}	/* Save resulting baud rate */	tty_encode_baud_rate(tty, baud, baud);	dev_dbg(&port->dev, "baud set = %d/n", baud);}

/* * cp2101_get_termios * Reads the baud rate, data bits, parity, stop bits and flow control mode * from the device, corrects any unsupported values, and configures the * termios structure to reflect the state of the device */static void cp2101_get_termios (struct tty_struct *tty){	struct usb_serial_port *port = tty->driver_data;	unsigned int cflag, modem_ctl[4];	unsigned int baud;	unsigned int bits;	dbg("%s - port %d", __func__, port->number);	cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);	/* Convert to baudrate */	if (baud)		baud = BAUD_RATE_GEN_FREQ / baud;	dbg("%s - baud rate = %d", __func__, baud);	tty_encode_baud_rate(tty, baud, baud);	cflag = tty->termios->c_cflag;	cp2101_get_config(port, CP2101_BITS, &bits, 2);	cflag &= ~CSIZE;	switch (bits & BITS_DATA_MASK) {	case BITS_DATA_5:		dbg("%s - data bits = 5", __func__);		cflag |= CS5;		break;	case BITS_DATA_6:		dbg("%s - data bits = 6", __func__);		cflag |= CS6;		break;	case BITS_DATA_7:		dbg("%s - data bits = 7", __func__);		cflag |= CS7;		break;	case BITS_DATA_8:		dbg("%s - data bits = 8", __func__);		cflag |= CS8;		break;	case BITS_DATA_9:		dbg("%s - data bits = 9 (not supported, using 8 data bits)",								__func__);		cflag |= CS8;		bits &= ~BITS_DATA_MASK;		bits |= BITS_DATA_8;		cp2101_set_config(port, CP2101_BITS, &bits, 2);		break;	default:		dbg("%s - Unknown number of data bits, using 8", __func__);		cflag |= CS8;		bits &= ~BITS_DATA_MASK;		bits |= BITS_DATA_8;		cp2101_set_config(port, CP2101_BITS, &bits, 2);		break;	}	switch (bits & BITS_PARITY_MASK) {	case BITS_PARITY_NONE:		dbg("%s - parity = NONE", __func__);		cflag &= ~PARENB;		break;	case BITS_PARITY_ODD:		dbg("%s - parity = ODD", __func__);		cflag |= (PARENB|PARODD);		break;	case BITS_PARITY_EVEN:		dbg("%s - parity = EVEN", __func__);		cflag &= ~PARODD;		cflag |= PARENB;		break;	case BITS_PARITY_MARK:		dbg("%s - parity = MARK (not supported, disabling parity)",				__func__);		cflag &= ~PARENB;		bits &= ~BITS_PARITY_MASK;		cp2101_set_config(port, CP2101_BITS, &bits, 2);		break;	case BITS_PARITY_SPACE:		dbg("%s - parity = SPACE (not supported, disabling parity)",				__func__);		cflag &= ~PARENB;		bits &= ~BITS_PARITY_MASK;		cp2101_set_config(port, CP2101_BITS, &bits, 2);		break;	default:		dbg("%s - Unknown parity mode, disabling parity", __func__);		cflag &= ~PARENB;		bits &= ~BITS_PARITY_MASK;		cp2101_set_config(port, CP2101_BITS, &bits, 2);		break;	}	cflag &= ~CSTOPB;	switch (bits & BITS_STOP_MASK) {	case BITS_STOP_1://.........这里部分代码省略.........

static void ir_set_termios(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	unsigned char *transfer_buffer;	int result;	speed_t baud;	int ir_baud;	dbg("%s - port %d", __func__, port->number);	baud = tty_get_baud_rate(tty);	/*	 * FIXME, we should compare the baud request against the	 * capability stated in the IR header that we got in the	 * startup function.	 */	switch (baud) {	case 2400:		ir_baud = USB_IRDA_BR_2400;		break;	case 9600:		ir_baud = USB_IRDA_BR_9600;		break;	case 19200:		ir_baud = USB_IRDA_BR_19200;		break;	case 38400:		ir_baud = USB_IRDA_BR_38400;		break;	case 57600:		ir_baud = USB_IRDA_BR_57600;		break;	case 115200:		ir_baud = USB_IRDA_BR_115200;		break;	case 576000:		ir_baud = USB_IRDA_BR_576000;		break;	case 1152000:		ir_baud = USB_IRDA_BR_1152000;		break;	case 4000000:		ir_baud = USB_IRDA_BR_4000000;		break;	default:		ir_baud = USB_IRDA_BR_9600;		baud = 9600;	}	if (xbof == -1)		ir_xbof = ir_xbof_change(ir_add_bof);	else		ir_xbof = ir_xbof_change(xbof) ;	/* FIXME need to check to see if our write urb is busy right	 * now, or use a urb pool.	 *	 * send the baud change out on an "empty" data packet	 */	transfer_buffer = port->write_urb->transfer_buffer;	*transfer_buffer = ir_xbof | ir_baud;	usb_fill_bulk_urb(		port->write_urb,		port->serial->dev,		usb_sndbulkpipe(port->serial->dev,			port->bulk_out_endpointAddress),		port->write_urb->transfer_buffer,		1,		ir_write_bulk_callback,		port);	port->write_urb->transfer_flags = URB_ZERO_PACKET;	result = usb_submit_urb(port->write_urb, GFP_KERNEL);	if (result)		dev_err(&port->dev,				"%s - failed submitting write urb, error %d/n",				__func__, result);	/* Only speed changes are supported */	tty_termios_copy_hw(tty->termios, old_termios);	tty_encode_baud_rate(tty, baud, baud);}

static int mct_u232_set_baud_rate(struct tty_struct *tty,	struct usb_serial *serial, struct usb_serial_port *port, speed_t value){	unsigned int divisor;	int rc;	unsigned char *buf;	unsigned char cts_enable_byte = 0;	speed_t speed;	buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);	if (buf == NULL)		return -ENOMEM;	divisor = mct_u232_calculate_baud_rate(serial, value, &speed);	put_unaligned_le32(cpu_to_le32(divisor), buf);	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),				MCT_U232_SET_BAUD_RATE_REQUEST,				MCT_U232_SET_REQUEST_TYPE,				0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,				WDR_TIMEOUT);	if (rc < 0)	/*FIXME: What value speed results */		dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)/n",			value, rc);	else		tty_encode_baud_rate(tty, speed, speed);	dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);	/* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which	   always sends two extra USB 'device request' messages after the	   'baud rate change' message.  The actual functionality of the	   request codes in these messages is not fully understood but these	   particular codes are never seen in any operation besides a baud	   rate change.  Both of these messages send a single byte of data.	   In the first message, the value of this byte is always zero.	   The second message has been determined experimentally to control	   whether data will be transmitted to a device which is not asserting	   the 'CTS' signal.  If the second message's data byte is zero, data	   will be transmitted even if 'CTS' is not asserted (i.e. no hardware	   flow control).  if the second message's data byte is nonzero (a	   value of 1 is used by this driver), data will not be transmitted to	   a device which is not asserting 'CTS'.	*/	buf[0] = 0;	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),				MCT_U232_SET_UNKNOWN1_REQUEST,				MCT_U232_SET_REQUEST_TYPE,				0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,				WDR_TIMEOUT);	if (rc < 0)		dev_err(&port->dev, "Sending USB device request code %d "			"failed (error = %d)/n", MCT_U232_SET_UNKNOWN1_REQUEST,			rc);	if (port && C_CRTSCTS(tty))	   cts_enable_byte = 1;	dbg("set_baud_rate: send second control message, data = %02X",							cts_enable_byte);	buf[0] = cts_enable_byte;	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),			MCT_U232_SET_CTS_REQUEST,			MCT_U232_SET_REQUEST_TYPE,			0, 0, buf, MCT_U232_SET_CTS_SIZE,			WDR_TIMEOUT);	if (rc < 0)		dev_err(&port->dev, "Sending USB device request code %d "			"failed (error = %d)/n", MCT_U232_SET_CTS_REQUEST, rc);	kfree(buf);	return rc;} /* mct_u232_set_baud_rate */

static void belkin_sa_set_termios(struct tty_struct *tty,		struct usb_serial_port *port, struct ktermios *old_termios){	struct usb_serial *serial = port->serial;	struct belkin_sa_private *priv = usb_get_serial_port_data(port);	unsigned int iflag;	unsigned int cflag;	unsigned int old_iflag = 0;	unsigned int old_cflag = 0;	__u16 urb_value = 0; 	unsigned long flags;	unsigned long control_state;	int bad_flow_control;	speed_t baud;	struct ktermios *termios = tty->termios;	iflag = termios->c_iflag;	cflag = termios->c_cflag;	termios->c_cflag &= ~CMSPAR;		spin_lock_irqsave(&priv->lock, flags);	control_state = priv->control_state;	bad_flow_control = priv->bad_flow_control;	spin_unlock_irqrestore(&priv->lock, flags);	old_iflag = old_termios->c_iflag;	old_cflag = old_termios->c_cflag;		if ((cflag & CBAUD) != (old_cflag & CBAUD)) {				if ((old_cflag & CBAUD) == B0) {			control_state |= (TIOCM_DTR|TIOCM_RTS);			if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)				dev_err(&port->dev, "Set DTR error/n");						if (!(old_cflag & CRTSCTS))				if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST								, 1) < 0)					dev_err(&port->dev, "Set RTS error/n");		}	}	baud = tty_get_baud_rate(tty);	if (baud) {		urb_value = BELKIN_SA_BAUD(baud);				if (urb_value == 0)			urb_value = 1;				baud = BELKIN_SA_BAUD(urb_value);				tty_encode_baud_rate(tty, baud, baud);		if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)			dev_err(&port->dev, "Set baudrate error/n");	} else {				if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,						BELKIN_SA_FLOW_NONE) < 0)			dev_err(&port->dev, "Disable flowcontrol error/n");				control_state &= ~(TIOCM_DTR | TIOCM_RTS);		if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)			dev_err(&port->dev, "DTR LOW error/n");		if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)			dev_err(&port->dev, "RTS LOW error/n");	}		if ((cflag ^ old_cflag) & (PARENB | PARODD)) {		if (cflag & PARENB)			urb_value = (cflag & PARODD) ?  BELKIN_SA_PARITY_ODD						: BELKIN_SA_PARITY_EVEN;		else			urb_value = BELKIN_SA_PARITY_NONE;		if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)			dev_err(&port->dev, "Set parity error/n");	}		if ((cflag & CSIZE) != (old_cflag & CSIZE)) {		switch (cflag & CSIZE) {		case CS5:			urb_value = BELKIN_SA_DATA_BITS(5);			break;		case CS6:			urb_value = BELKIN_SA_DATA_BITS(6);			break;		case CS7:			urb_value = BELKIN_SA_DATA_BITS(7);			break;		case CS8:			urb_value = BELKIN_SA_DATA_BITS(8);			break;		default: dbg("CSIZE was not CS5-CS8, using default of 8");			urb_value = BELKIN_SA_DATA_BITS(8);			break;//.........这里部分代码省略.........