/* * 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 } #if API <= 1 static int wishbone_serial_open(struct usb_serial_port *port, struct file *filp) #else /* API >= 2 */ static int wishbone_serial_open(struct tty_struct *tty, struct usb_serial_port *port) #endif { int retval; retval = usb_gsi_openclose(port, 1); if (retval) { dev_err(&port->serial->dev->dev, "Could not mark device as open (%d)\n", retval); return retval; } #if API <= 1 wishbone_serial_set_termios(port, NULL); #endif #if API <= 1 retval = usb_serial_generic_open(port, filp); #else /* API >= 2 */ retval = usb_serial_generic_open(tty, port); #endif if (retval) usb_gsi_openclose(port, 0); return retval; }
int GobiOpen( struct tty_struct * pTTY, struct usb_serial_port * pPort ) #endif { const char startMessage[] = "$GPS_START"; int nResult; int bytesWrote; DBG( "\n" ); // Test parameters if ( (pPort == NULL) || (pPort->serial == NULL) || (pPort->serial->dev == NULL) || (pPort->serial->interface == NULL) || (pPort->serial->interface->cur_altsetting == NULL) ) { DBG( "invalid parameter\n" ); return -EINVAL; } // Is this the GPS port? if (pPort->serial->interface->cur_altsetting->desc.bInterfaceNumber == 3) { // Send startMessage, 1s timeout nResult = usb_bulk_msg( pPort->serial->dev, usb_sndbulkpipe( pPort->serial->dev, pPort->bulk_out_endpointAddress ), (void *)&startMessage[0], sizeof( startMessage ), &bytesWrote, 1000 ); if (nResult != 0) { DBG( "error %d sending startMessage\n", nResult ); return nResult; } if (bytesWrote != sizeof( startMessage )) { DBG( "invalid write size %d, %d\n", bytesWrote, sizeof( startMessage ) ); return -EIO; } } // Pass to usb_serial_generic_open #if (LINUX_VERSION_CODE <= KERNEL_VERSION( 2,6,26 )) return usb_serial_generic_open( pPort, pFilp ); #elif (LINUX_VERSION_CODE <= KERNEL_VERSION( 2,6,31 )) return usb_serial_generic_open( pTTY, pPort, pFilp ); #else // > 2.6.31 return usb_serial_generic_open( pTTY, pPort ); #endif }
/* open this device, set default parameters */ static int ch341_open(struct usb_serial_port *port, struct file *filp) { struct usb_serial *serial = port->serial; struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]); int r; dbg("ch341_open()"); priv->baud_rate = DEFAULT_BAUD_RATE; priv->dtr = 1; priv->rts = 1; r = ch341_configure(serial->dev, priv); if (r) goto out; r = ch341_set_handshake(serial->dev, priv); if (r) goto out; r = ch341_set_baudrate(serial->dev, priv); if (r) goto out; r = usb_serial_generic_open(port, filp); out: return r; }
static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; struct pl2303_serial_private *spriv = usb_get_serial_data(serial); int result; if (spriv->type != HX) { usb_clear_halt(serial->dev, port->write_urb->pipe); usb_clear_halt(serial->dev, port->read_urb->pipe); } else { /* reset upstream data pipes */ pl2303_vendor_write(8, 0, serial); pl2303_vendor_write(9, 0, serial); } /* Setup termios */ if (tty) pl2303_set_termios(tty, port, NULL); result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); if (result) { dev_err(&port->dev, "%s - failed submitting interrupt urb," " error %d\n", __func__, result); return result; } result = usb_serial_generic_open(tty, port); if (result) { usb_kill_urb(port->interrupt_in_urb); return result; } return 0; }
static int ipaq_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; int result = 0; int retries = connect_retries; dbg("%s - port %d", __func__, port->number); msleep(1000*initial_wait); /* */ while (retries--) { result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 0x22, 0x21, 0x1, 0, NULL, 0, 100); if (!result) break; msleep(1000); } if (!retries && result) { dev_err(&port->dev, "%s - failed doing control urb, error %d\n", __func__, result); return result; } return usb_serial_generic_open(tty, port); }
static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port) { struct ktermios tmp_termios; int result; /* Setup termios */ if (tty) f81232_set_termios(tty, port, &tmp_termios); dbg("%s - submitting interrupt urb", __func__); result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); if (result) { dev_err(&port->dev, "%s - failed submitting interrupt urb," " error %d\n", __func__, result); return result; } result = usb_serial_generic_open(tty, port); if (result) { usb_kill_urb(port->interrupt_in_urb); return result; } port->port.drain_delay = 256; return 0; }
/* open this device, set default parameters */ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]); int r; priv->baud_rate = DEFAULT_BAUD_RATE; r = ch341_configure(serial->dev, priv); if (r) goto out; r = ch341_set_handshake(serial->dev, priv->line_control); if (r) goto out; r = ch341_set_baudrate(serial->dev, priv); if (r) goto out; dbg("%s - submitting interrupt urb", __func__); r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); if (r) { dev_err(&port->dev, "%s - failed submitting interrupt urb," " error %d\n", __func__, r); ch341_close(port); goto out; } r = usb_serial_generic_open(tty, port); out: return r; }
/* open this device, set default parameters */ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; struct ch341_private *priv = usb_get_serial_port_data(port); int r; r = ch341_configure(serial->dev, priv); if (r) goto out; if (tty) ch341_set_termios(tty, port, NULL); dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__); r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); if (r) { dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n", __func__, r); goto out; } r = usb_serial_generic_open(tty, port); out: return r; }
static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port) { struct opticon_private *priv = usb_get_serial_port_data(port); unsigned long flags; int res; spin_lock_irqsave(&priv->lock, flags); priv->rts = false; spin_unlock_irqrestore(&priv->lock, flags); /* Clear RTS line */ send_control_msg(port, CONTROL_RTS, 0); /* clear the halt status of the enpoint */ usb_clear_halt(port->serial->dev, port->read_urb->pipe); res = usb_serial_generic_open(tty, port); if (!res) return res; /* Request CTS line state, sometimes during opening the current * CTS state can be missed. */ send_control_msg(port, RESEND_CTS_STATE, 1); return res; }
static int ipaq_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; int result = 0; int retries = connect_retries; msleep(1000*initial_wait); /* * Send out control message observed in win98 sniffs. Not sure what * it does, but from empirical observations, it seems that the device * will start the chat sequence once one of these messages gets * through. Since this has a reasonably high failure rate, we retry * several times. */ while (retries--) { result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 0x22, 0x21, 0x1, 0, NULL, 0, 100); if (!result) break; msleep(1000); } if (!retries && result) { dev_err(&port->dev, "%s - failed doing control urb, error %d\n", __func__, result); return result; } return usb_serial_generic_open(tty, port); }
static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; struct usb_serial_port *wport; wport = serial->port[1]; tty_port_tty_set(&wport->port, tty); return usb_serial_generic_open(tty, port); }
static int ir_open(struct tty_struct *tty, struct usb_serial_port *port) { int i; dbg("%s - port %d", __func__, port->number); for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) port->write_urbs[i]->transfer_flags = URB_ZERO_PACKET; /* Start reading from the device */ return usb_serial_generic_open(tty, port); }
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port) { struct ktermios tmp_termios; struct usb_serial *serial = port->serial; char *buf; int result = 0; dbg("%s - port %d", __func__, port->number); buf = kmalloc(1, GFP_KERNEL); if (!buf) { dbg("error kmalloc -> out of mem?"); return -ENOMEM; } result = usb_serial_generic_open(tty, port); if (result) goto err_out; /* open */ ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf); ARK3116_SND(serial, 112, 0xFE, 0x40, 0x0082, 0x0003); ARK3116_SND(serial, 113, 0xFE, 0x40, 0x001A, 0x0000); ARK3116_SND(serial, 114, 0xFE, 0x40, 0x0000, 0x0001); ARK3116_SND(serial, 115, 0xFE, 0x40, 0x0002, 0x0003); ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf); ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004); ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf); ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004); ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf); ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004); ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf); ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004); /* returns different values (control lines?!) */ ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf); /* initialise termios */ if (tty) ark3116_set_termios(tty, port, &tmp_termios); err_out: kfree(buf); return result; }
static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port) { dbg("%s - port %d", __func__, port->number); if (cp210x_set_config_single(port, CP210X_IFC_ENABLE, UART_ENABLE)) { dev_err(&port->dev, "%s - Unable to enable UART\n", __func__); return -EPROTO; } /* Configure the termios structure */ cp210x_get_termios(tty, port); /* The baud rate must be initialised on cp2104 */ if (tty) cp210x_change_speed(tty, port, NULL); return usb_serial_generic_open(tty, port); }
static int belkin_sa_open(struct tty_struct *tty, struct usb_serial_port *port) { int retval; dbg("%s port %d", __func__, port->number); retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); if (retval) { dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); return retval; } retval = usb_serial_generic_open(tty, port); if (retval) usb_kill_urb(port->interrupt_in_urb); return retval; }
static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port) { int result; dbg("%s - port %d", __func__, port->number); if (cp210x_set_config_single(port, CP210X_IFC_ENABLE, UART_ENABLE)) { dev_err(&port->dev, "%s - Unable to enable UART\n", __func__); return -EPROTO; } result = usb_serial_generic_open(tty, port); if (result) return result; /* Configure the termios structure */ cp210x_get_termios(tty, port); return 0; }
static int ssu100_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_device *dev = port->serial->dev; struct ssu100_port_private *priv = usb_get_serial_port_data(port); u8 *data; int result; unsigned long flags; dbg("%s - port %d", __func__, port->number); data = kzalloc(2, GFP_KERNEL); if (!data) return -ENOMEM; result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), QT_OPEN_CLOSE_CHANNEL, QT_TRANSFER_IN, 0x01, 0, data, 2, 300); if (result < 0) { dbg("%s - open failed %i", __func__, result); kfree(data); return result; } spin_lock_irqsave(&priv->status_lock, flags); priv->shadowLSR = data[0]; priv->shadowMSR = data[1]; spin_unlock_irqrestore(&priv->status_lock, flags); kfree(data); /* set to 9600 */ result = ssu100_control_msg(dev, QT_GET_SET_UART, 0x30, 0x0300); if (result < 0) dbg("%s - set uart failed", __func__); if (tty) ssu100_set_termios(tty, port, tty->termios); return usb_serial_generic_open(tty, port); }
static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial = port->serial; struct spcp8x5_private *priv = usb_get_serial_port_data(port); int ret; usb_clear_halt(serial->dev, port->write_urb->pipe); usb_clear_halt(serial->dev, port->read_urb->pipe); ret = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 0x09, 0x00, 0x01, 0x00, NULL, 0x00, 100); if (ret) return ret; spcp8x5_set_ctrl_line(port, priv->line_control); if (tty) spcp8x5_set_termios(tty, port, NULL); return usb_serial_generic_open(tty, port); }
static int whiteheat_open(struct tty_struct *tty, struct usb_serial_port *port) { int retval; retval = start_command_port(port->serial); if (retval) goto exit; /* send an open port command */ retval = firm_open(port); if (retval) { stop_command_port(port->serial); goto exit; } retval = firm_purge(port, WHITEHEAT_PURGE_RX | WHITEHEAT_PURGE_TX); if (retval) { firm_close(port); stop_command_port(port->serial); goto exit; } if (tty) firm_setup_port(tty); /* Work around HCD bugs */ usb_clear_halt(port->serial->dev, port->read_urb->pipe); usb_clear_halt(port->serial->dev, port->write_urb->pipe); retval = usb_serial_generic_open(tty, port); if (retval) { firm_close(port); stop_command_port(port->serial); goto exit; } exit: return retval; }
/* open the serial port. do some usb system call. set termios and get the line * status of the device. */ static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port) { struct ktermios tmp_termios; struct usb_serial *serial = port->serial; struct spcp8x5_private *priv = usb_get_serial_port_data(port); int ret; unsigned long flags; u8 status = 0x30; /* status 0x30 means DSR and CTS = 1 other CDC RI and delta = 0 */ usb_clear_halt(serial->dev, port->write_urb->pipe); usb_clear_halt(serial->dev, port->read_urb->pipe); ret = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 0x09, 0x00, 0x01, 0x00, NULL, 0x00, 100); if (ret) return ret; spcp8x5_set_ctrlLine(serial->dev, priv->line_control , priv->type); /* Setup termios */ if (tty) spcp8x5_set_termios(tty, port, &tmp_termios); spcp8x5_get_msr(serial->dev, &status, priv->type); /* may be we should update uart status here but now we did not do */ spin_lock_irqsave(&priv->lock, flags); priv->line_status = status & 0xf0 ; spin_unlock_irqrestore(&priv->lock, flags); port->port.drain_delay = 256; return usb_serial_generic_open(tty, port); }
/* * The parsing of the command line works exactly like the * serial.c code, except that the specifier is "ttyUSB" instead * of "ttyS". */ static int usb_console_setup(struct console *co, char *options) { struct usbcons_info *info = &usbcons_info; int baud = 9600; int bits = 8; int parity = 'n'; int doflow = 0; int cflag = CREAD | HUPCL | CLOCAL; char *s; struct usb_serial *serial; struct usb_serial_port *port; int retval; struct tty_struct *tty = NULL; struct ktermios dummy; dbg("%s", __func__); if (options) { baud = simple_strtoul(options, NULL, 10); s = options; while (*s >= '0' && *s <= '9') s++; if (*s) parity = *s++; if (*s) bits = *s++ - '0'; if (*s) doflow = (*s++ == 'r'); } /* Sane default */ if (baud == 0) baud = 9600; switch (bits) { case 7: cflag |= CS7; break; default: case 8: cflag |= CS8; break; } switch (parity) { case 'o': case 'O': cflag |= PARODD; break; case 'e': case 'E': cflag |= PARENB; break; } co->cflag = cflag; /* * no need to check the index here: if the index is wrong, console * code won't call us */ serial = usb_serial_get_by_index(co->index); if (serial == NULL) { /* no device is connected yet, sorry :( */ err("No USB device connected to ttyUSB%i", co->index); return -ENODEV; } retval = usb_autopm_get_interface(serial->interface); if (retval) goto error_get_interface; port = serial->port[co->index - serial->minor]; tty_port_tty_set(&port->port, NULL); info->port = port; ++port->port.count; if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) { if (serial->type->set_termios) { /* * allocate a fake tty so the driver can initialize * the termios structure, then later call set_termios to * configure according to command line arguments */ tty = kzalloc(sizeof(*tty), GFP_KERNEL); if (!tty) { retval = -ENOMEM; err("no more memory"); goto reset_open_count; } kref_init(&tty->kref); tty_port_tty_set(&port->port, tty); tty->driver = usb_serial_tty_driver; tty->index = co->index; if (tty_init_termios(tty)) { retval = -ENOMEM; err("no more memory"); goto free_tty; } } /* only call the device specific open if this * is the first time the port is opened */ if (serial->type->open) retval = serial->type->open(NULL, port); else retval = usb_serial_generic_open(NULL, port); if (retval) { err("could not open USB console port"); goto fail; } if (serial->type->set_termios) { tty->termios->c_cflag = cflag; tty_termios_encode_baud_rate(tty->termios, baud, baud); memset(&dummy, 0, sizeof(struct ktermios)); serial->type->set_termios(tty, port, &dummy); tty_port_tty_set(&port->port, NULL); kfree(tty); } set_bit(ASYNCB_INITIALIZED, &port->port.flags); } /* Now that any required fake tty operations are completed restore * the tty port count */ --port->port.count; /* The console is special in terms of closing the device so * indicate this port is now acting as a system console. */ port->port.console = 1; mutex_unlock(&serial->disc_mutex); return retval; fail: tty_port_tty_set(&port->port, NULL); free_tty: kfree(tty); reset_open_count: port->port.count = 0; usb_autopm_put_interface(serial->interface); error_get_interface: usb_serial_put(serial); mutex_unlock(&serial->disc_mutex); return retval; }
/* * The parsing of the command line works exactly like the * serial.c code, except that the specifier is "ttyUSB" instead * of "ttyS". */ static int usb_console_setup(struct console *co, char *options) { struct usbcons_info *info = &usbcons_info; int baud = 9600; int bits = 8; int parity = 'n'; int doflow = 0; int cflag = CREAD | HUPCL | CLOCAL; char *s; struct usb_serial *serial; struct usb_serial_port *port; int retval = 0; struct tty_struct *tty = NULL; struct ktermios *termios = NULL, dummy; dbg ("%s", __func__); if (options) { baud = simple_strtoul(options, NULL, 10); s = options; while (*s >= '0' && *s <= '9') s++; if (*s) parity = *s++; if (*s) bits = *s++ - '0'; if (*s) doflow = (*s++ == 'r'); } /* build a cflag setting */ switch (baud) { case 1200: cflag |= B1200; break; case 2400: cflag |= B2400; break; case 4800: cflag |= B4800; break; case 19200: cflag |= B19200; break; case 38400: cflag |= B38400; break; case 57600: cflag |= B57600; break; case 115200: cflag |= B115200; break; case 9600: default: cflag |= B9600; /* * Set this to a sane value to prevent a divide error */ baud = 9600; break; } switch (bits) { case 7: cflag |= CS7; break; default: case 8: cflag |= CS8; break; } switch (parity) { case 'o': case 'O': cflag |= PARODD; break; case 'e': case 'E': cflag |= PARENB; break; } co->cflag = cflag; /* * no need to check the index here: if the index is wrong, console * code won't call us */ serial = usb_serial_get_by_index(co->index); if (serial == NULL) { /* no device is connected yet, sorry :( */ err ("No USB device connected to ttyUSB%i", co->index); return -ENODEV; } port = serial->port[0]; port->tty = NULL; info->port = port; ++port->open_count; if (port->open_count == 1) { if (serial->type->set_termios) { /* * allocate a fake tty so the driver can initialize * the termios structure, then later call set_termios to * configure according to command line arguments */ tty = kzalloc(sizeof(*tty), GFP_KERNEL); if (!tty) { retval = -ENOMEM; err("no more memory"); goto reset_open_count; } termios = kzalloc(sizeof(*termios), GFP_KERNEL); if (!termios) { retval = -ENOMEM; err("no more memory"); goto free_tty; } memset(&dummy, 0, sizeof(struct ktermios)); tty->termios = termios; port->tty = tty; } /* only call the device specific open if this * is the first time the port is opened */ if (serial->type->open) retval = serial->type->open(port, NULL); else retval = usb_serial_generic_open(port, NULL); if (retval) { err("could not open USB console port"); goto free_termios; } if (serial->type->set_termios) { termios->c_cflag = cflag; serial->type->set_termios(port, &dummy); port->tty = NULL; kfree(termios); kfree(tty); } } port->console = 1; retval = 0; out: return retval; free_termios: kfree(termios); port->tty = NULL; free_tty: kfree(tty); reset_open_count: port->open_count = 0; goto out; }
int usb_debug_open(struct usb_serial_port *port, struct file *filp) { port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE; return usb_serial_generic_open(port, filp); }
static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port) { struct klsi_105_private *priv = usb_get_serial_port_data(port); int retval = 0; int rc; int i; unsigned long line_state; struct klsi_105_port_settings *cfg; unsigned long flags; dbg("%s port %d", __func__, port->number); /* Do a defined restart: * Set up sane default baud rate and send the 'READ_ON' * vendor command. * FIXME: set modem line control (how?) * Then read the modem line control and store values in * priv->line_state. */ cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); if (!cfg) { dev_err(&port->dev, "%s - out of memory for config buffer.\n", __func__); return -ENOMEM; } cfg->pktlen = 5; cfg->baudrate = kl5kusb105a_sio_b9600; cfg->databits = kl5kusb105a_dtb_8; cfg->unknown1 = 0; cfg->unknown2 = 1; klsi_105_chg_port_settings(port, cfg); /* set up termios structure */ spin_lock_irqsave(&priv->lock, flags); priv->termios.c_iflag = tty->termios->c_iflag; priv->termios.c_oflag = tty->termios->c_oflag; priv->termios.c_cflag = tty->termios->c_cflag; priv->termios.c_lflag = tty->termios->c_lflag; for (i = 0; i < NCCS; i++) priv->termios.c_cc[i] = tty->termios->c_cc[i]; priv->cfg.pktlen = cfg->pktlen; priv->cfg.baudrate = cfg->baudrate; priv->cfg.databits = cfg->databits; priv->cfg.unknown1 = cfg->unknown1; priv->cfg.unknown2 = cfg->unknown2; spin_unlock_irqrestore(&priv->lock, flags); /* READ_ON and urb submission */ rc = usb_serial_generic_open(tty, port); if (rc) { retval = rc; goto exit; } rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0), KL5KUSB105A_SIO_CONFIGURE, USB_TYPE_VENDOR|USB_DIR_OUT|USB_RECIP_INTERFACE, KL5KUSB105A_SIO_CONFIGURE_READ_ON, 0, /* index */ NULL, 0, KLSI_TIMEOUT); if (rc < 0) { dev_err(&port->dev, "Enabling read failed (error = %d)\n", rc); retval = rc; } else dbg("%s - enabled reading", __func__); rc = klsi_105_get_line_state(port, &line_state); if (rc >= 0) { spin_lock_irqsave(&priv->lock, flags); priv->line_state = line_state; spin_unlock_irqrestore(&priv->lock, flags); dbg("%s - read line state 0x%lx", __func__, line_state); retval = 0; } else retval = rc; exit: kfree(cfg); return retval; }
static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port) { port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE; return usb_serial_generic_open(tty, port); }
static int zte_ev_usb_serial_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_device *udev = port->serial->dev; struct device *dev = &port->dev; int result = 0; int len; unsigned char *buf; buf = kmalloc(MAX_SETUP_DATA_SIZE, GFP_KERNEL); if (!buf) return -ENOMEM; /* send 1st ctl cmd(CTL 21 22 01 00 00 00 00 00) */ len = 0; result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x22, 0x21, 0x0001, 0x0000, NULL, len, USB_CTRL_GET_TIMEOUT); dev_dbg(dev, "result = %d\n", result); /* send 2st cmd and receive data */ /* * 16.0 CTL a1 21 00 00 00 00 07 00 CLASS 25.1.0(5) * 16.0 DI 00 96 00 00 00 00 08 */ len = 0x0007; result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x21, 0xa1, 0x0000, 0x0000, buf, len, USB_CTRL_GET_TIMEOUT); debug_data(dev, __func__, len, buf, result); /* send 3rd cmd */ /* * 16.0 CTL 21 20 00 00 00 00 07 00 CLASS 30.1.0 * 16.0 DO 80 25 00 00 00 00 08 .%..... 30.2.0 */ len = 0x0007; buf[0] = 0x80; buf[1] = 0x25; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x08; result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x20, 0x21, 0x0000, 0x0000, buf, len, USB_CTRL_GET_TIMEOUT); debug_data(dev, __func__, len, buf, result); /* send 4th cmd */ /* * 16.0 CTL 21 22 03 00 00 00 00 00 */ len = 0; result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x22, 0x21, 0x0003, 0x0000, NULL, len, USB_CTRL_GET_TIMEOUT); dev_dbg(dev, "result = %d\n", result); /* send 5th cmd */ /* * 16.0 CTL a1 21 00 00 00 00 07 00 CLASS 33.1.0 * 16.0 DI 80 25 00 00 00 00 08 */ len = 0x0007; result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x21, 0xa1, 0x0000, 0x0000, buf, len, USB_CTRL_GET_TIMEOUT); debug_data(dev, __func__, len, buf, result); /* send 6th cmd */ /* * 16.0 CTL 21 20 00 00 00 00 07 00 CLASS 34.1.0 * 16.0 DO 80 25 00 00 00 00 08 */ len = 0x0007; buf[0] = 0x80; buf[1] = 0x25; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x08; result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x20, 0x21, 0x0000, 0x0000, buf, len, USB_CTRL_GET_TIMEOUT); debug_data(dev, __func__, len, buf, result); kfree(buf); return usb_serial_generic_open(tty, port); }
static int mxu1_open(struct tty_struct *tty, struct usb_serial_port *port) { struct mxu1_device *mxdev; struct mxu1_port *mxport; struct usb_device *dev; struct urb *urb; int status; u16 open_settings; open_settings = (MXU1_PIPE_MODE_CONTINUOUS | MXU1_PIPE_TIMEOUT_ENABLE | (MXU1_TRANSFER_TIMEOUT << 2)); mxdev = usb_get_serial_data(port->serial); mxport = usb_get_serial_port_data(port); dev = port->serial->dev; mxport->mxp_msr = 0; mxport->mxp_mcr |= MXU1_MCR_RTS | MXU1_MCR_DTR; dev_dbg(&port->dev, "%s - start interrupt in urb\n", __func__); urb = port->interrupt_in_urb; urb->context = mxdev; status = usb_submit_urb(urb, GFP_KERNEL); if (status) { dev_err(&port->dev, "failed to submit interrupt urb: %d\n", status); return status; } mxu1_set_termios(tty, port, NULL); status = mxu1_send_ctrl_urb(mxdev->mxd_serial, MXU1_OPEN_PORT, open_settings, MXU1_UART1_PORT); if (status) { dev_err(&port->dev, "%s - cannot send open command: %d\n", __func__, status); goto unlink_int_urb; } status = mxu1_send_ctrl_urb(mxdev->mxd_serial, MXU1_START_PORT, 0, MXU1_UART1_PORT); if (status) { dev_err(&port->dev, "%s - cannot send start command: %d\n", __func__, status); goto unlink_int_urb; } status = mxu1_send_ctrl_urb(mxdev->mxd_serial, MXU1_PURGE_PORT, MXU1_PURGE_INPUT, MXU1_UART1_PORT); if (status) { dev_err(&port->dev, "%s - cannot clear input buffers: %d\n", __func__, status); goto unlink_int_urb; } status = mxu1_send_ctrl_urb(mxdev->mxd_serial, MXU1_PURGE_PORT, MXU1_PURGE_OUTPUT, MXU1_UART1_PORT); if (status) { dev_err(&port->dev, "%s - cannot clear output buffers: %d\n", __func__, status); goto unlink_int_urb; } /* * reset the data toggle on the bulk endpoints to work around bug in * host controllers where things get out of sync some times */ usb_clear_halt(dev, port->write_urb->pipe); usb_clear_halt(dev, port->read_urb->pipe); mxu1_set_termios(tty, port, NULL); status = mxu1_send_ctrl_urb(mxdev->mxd_serial, MXU1_OPEN_PORT, open_settings, MXU1_UART1_PORT); if (status) { dev_err(&port->dev, "%s - cannot send open command: %d\n", __func__, status); goto unlink_int_urb; } status = mxu1_send_ctrl_urb(mxdev->mxd_serial, MXU1_START_PORT, 0, MXU1_UART1_PORT); if (status) { dev_err(&port->dev, "%s - cannot send start command: %d\n", __func__, status); goto unlink_int_urb; } status = usb_serial_generic_open(tty, port); if (status) { dev_err(&port->dev, "%s - submit read urb failed: %d\n", __func__, status); goto unlink_int_urb; } return status; unlink_int_urb: usb_kill_urb(port->interrupt_in_urb); return status; }