2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* USB FTDI SIO driver
|
|
|
|
|
*
|
2006-10-13 22:57:58 +00:00
|
|
|
* Copyright (C) 1999 - 2001
|
|
|
|
|
* Greg Kroah-Hartman (greg@kroah.com)
|
2005-04-16 22:20:36 +00:00
|
|
|
* Bill Ryder (bryder@sgi.com)
|
|
|
|
|
* Copyright (C) 2002
|
|
|
|
|
* Kuba Ober (kuba@mareimbrium.org)
|
|
|
|
|
*
|
2006-10-13 22:57:58 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
* (at your option) any later version.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
|
* See Documentation/usb/usb-serial.txt for more information on using this driver
|
|
|
|
|
*
|
|
|
|
|
* See http://ftdi-usb-sio.sourceforge.net for upto date testing info
|
|
|
|
|
* and extra documentation
|
|
|
|
|
*
|
2002-04-09 19:14:34 +00:00
|
|
|
* Change entries from 2004 and earlier can be found in versions of this
|
|
|
|
|
* file in kernel versions prior to the 2.6.24 release.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Bill Ryder - bryder@sgi.com - wrote the FTDI_SIO implementation */
|
|
|
|
|
/* Thanx to FTDI for so kindly providing details of the protocol required */
|
|
|
|
|
/* to talk to the device */
|
|
|
|
|
/* Thanx to gkh and the rest of the usb dev group for all code I have assimilated :-) */
|
|
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/tty.h>
|
|
|
|
|
#include <linux/tty_driver.h>
|
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
#include <linux/usb.h>
|
|
|
|
|
#include <linux/serial.h>
|
2006-07-12 04:22:58 +00:00
|
|
|
#include <linux/usb/serial.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "ftdi_sio.h"
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Version Information
|
|
|
|
|
*/
|
2005-06-20 15:45:42 +00:00
|
|
|
#define DRIVER_VERSION "v1.4.3"
|
2005-04-16 22:20:36 +00:00
|
|
|
#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
|
|
|
|
|
#define DRIVER_DESC "USB FTDI Serial Converters Driver"
|
|
|
|
|
|
|
|
|
|
static int debug;
|
2005-07-28 17:40:32 +00:00
|
|
|
static __u16 vendor = FTDI_VID;
|
|
|
|
|
static __u16 product;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-09 19:03:08 +00:00
|
|
|
struct ftdi_private {
|
|
|
|
|
ftdi_chip_type_t chip_type;
|
|
|
|
|
/* type of the device, either SIO or FT8U232AM */
|
|
|
|
|
int baud_base; /* baud base clock for divisor setting */
|
|
|
|
|
int custom_divisor; /* custom_divisor kludge, this is for baud_base (different from what goes to the chip!) */
|
|
|
|
|
__u16 last_set_data_urb_value ;
|
|
|
|
|
/* the last data state set - needed for doing a break */
|
|
|
|
|
int write_offset; /* This is the offset in the usb data block to write the serial data -
|
|
|
|
|
* it is different between devices
|
|
|
|
|
*/
|
|
|
|
|
int flags; /* some ASYNC_xxxx flags are supported */
|
|
|
|
|
unsigned long last_dtr_rts; /* saved modem control outputs */
|
|
|
|
|
wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
|
|
|
|
|
char prev_status, diff_status; /* Used for TIOCMIWAIT */
|
|
|
|
|
__u8 rx_flags; /* receive state flags (throttling) */
|
|
|
|
|
spinlock_t rx_lock; /* spinlock for receive state */
|
|
|
|
|
struct delayed_work rx_work;
|
|
|
|
|
struct usb_serial_port *port;
|
|
|
|
|
int rx_processed;
|
|
|
|
|
unsigned long rx_bytes;
|
|
|
|
|
|
|
|
|
|
__u16 interface; /* FT2232C port interface (0 for FT232/245) */
|
|
|
|
|
|
2007-10-18 08:24:24 +00:00
|
|
|
speed_t force_baud; /* if non-zero, force the baud rate to this value */
|
2007-07-09 19:03:08 +00:00
|
|
|
int force_rtscts; /* if non-zero, force RTS-CTS to always be enabled */
|
|
|
|
|
|
|
|
|
|
spinlock_t tx_lock; /* spinlock for transmit state */
|
|
|
|
|
unsigned long tx_bytes;
|
|
|
|
|
unsigned long tx_outstanding_bytes;
|
|
|
|
|
unsigned long tx_outstanding_urbs;
|
|
|
|
|
};
|
|
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
/* struct ftdi_sio_quirk is used by devices requiring special attention. */
|
|
|
|
|
struct ftdi_sio_quirk {
|
2007-05-05 01:23:24 +00:00
|
|
|
int (*probe)(struct usb_serial *);
|
2007-07-09 19:03:08 +00:00
|
|
|
void (*port_probe)(struct ftdi_private *); /* Special settings for probed ports. */
|
2005-06-20 15:45:42 +00:00
|
|
|
};
|
|
|
|
|
|
2008-01-01 14:08:35 +00:00
|
|
|
static int ftdi_jtag_probe (struct usb_serial *serial);
|
2008-03-01 18:49:59 +00:00
|
|
|
static int ftdi_mtxorb_hack_setup (struct usb_serial *serial);
|
2007-07-09 19:03:08 +00:00
|
|
|
static void ftdi_USB_UIRT_setup (struct ftdi_private *priv);
|
|
|
|
|
static void ftdi_HE_TIRA1_setup (struct ftdi_private *priv);
|
2005-06-20 15:45:42 +00:00
|
|
|
|
2008-01-01 14:08:35 +00:00
|
|
|
static struct ftdi_sio_quirk ftdi_jtag_quirk = {
|
|
|
|
|
.probe = ftdi_jtag_probe,
|
2007-05-05 01:23:24 +00:00
|
|
|
};
|
|
|
|
|
|
2008-03-01 18:49:59 +00:00
|
|
|
static struct ftdi_sio_quirk ftdi_mtxorb_hack_quirk = {
|
|
|
|
|
.probe = ftdi_mtxorb_hack_setup,
|
|
|
|
|
};
|
|
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
static struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
|
2007-07-09 19:03:08 +00:00
|
|
|
.port_probe = ftdi_USB_UIRT_setup,
|
2005-06-20 15:45:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
|
2007-07-09 19:03:08 +00:00
|
|
|
.port_probe = ftdi_HE_TIRA1_setup,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The 8U232AM has the same API as the sio except for:
|
|
|
|
|
* - it can support MUCH higher baudrates; up to:
|
|
|
|
|
* o 921600 for RS232 and 2000000 for RS422/485 at 48MHz
|
|
|
|
|
* o 230400 at 12MHz
|
|
|
|
|
* so .. 8U232AM's baudrate setting codes are different
|
|
|
|
|
* - it has a two byte status code.
|
|
|
|
|
* - it returns characters every 16ms (the FTDI does it every 40ms)
|
|
|
|
|
*
|
|
|
|
|
* the bcdDevice value is used to differentiate FT232BM and FT245BM from
|
|
|
|
|
* the earlier FT8U232AM and FT8U232BM. For now, include all known VID/PID
|
|
|
|
|
* combinations in both tables.
|
2005-06-20 15:45:42 +00:00
|
|
|
* FIXME: perhaps bcdDevice can also identify 12MHz FT8U232AM devices,
|
|
|
|
|
* but I don't know if those ever went into mass production. [Ian Abbott]
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static struct usb_device_id id_table_combined [] = {
|
2006-08-09 09:48:03 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
|
2006-05-04 08:35:49 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
|
2006-04-11 18:52:41 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
|
2007-06-22 01:34:23 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
|
2006-10-20 07:43:53 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
|
2007-03-04 23:03:26 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
|
2006-06-23 15:36:21 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
|
2007-05-08 17:52:41 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
|
|
|
|
|
{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
|
2005-06-20 15:45:42 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
|
2008-03-01 18:49:59 +00:00
|
|
|
{ USB_DEVICE(MTXORB_VK_VID, MTXORB_VK_PID),
|
|
|
|
|
.driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
|
2005-06-20 15:45:42 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
|
2006-07-19 04:26:54 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
|
2007-03-26 01:08:35 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
|
2006-09-24 08:52:12 +00:00
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
|
|
|
|
|
{ USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
|
|
|
|
|
{ USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
|
|
|
|
|
{ USB_DEVICE(OCT_VID, OCT_US101_PID) },
|
2005-06-20 15:45:42 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
|
|
|
|
|
.driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
|
|
|
|
|
.driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
|
2005-06-20 15:45:42 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
|
2005-05-17 14:12:13 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
|
2005-08-02 13:01:27 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
|
2005-09-29 12:57:29 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
|
2005-10-26 19:10:41 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
|
2007-02-28 21:50:52 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
|
2005-08-02 13:01:27 +00:00
|
|
|
/*
|
2007-12-25 17:32:08 +00:00
|
|
|
* Due to many user requests for multiple ELV devices we enable
|
|
|
|
|
* them by default.
|
2005-08-02 13:01:27 +00:00
|
|
|
*/
|
2007-12-25 17:32:08 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
|
2008-03-04 21:09:11 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
|
2007-12-25 17:32:08 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
|
2006-10-13 22:57:58 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
|
2006-11-28 21:35:12 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
|
|
|
|
|
{ USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
|
|
|
|
|
{ USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
|
|
|
|
|
{ USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
|
2005-08-02 13:01:27 +00:00
|
|
|
{ USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
|
2007-02-27 11:57:12 +00:00
|
|
|
{ USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
|
2005-04-29 15:06:14 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
|
2005-04-16 22:20:36 +00:00
|
|
|
{ USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
|
|
|
|
|
{ USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
|
|
|
|
|
{ USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
|
2005-04-29 15:06:14 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
|
2005-08-02 13:01:27 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
|
2005-04-29 15:06:14 +00:00
|
|
|
{ USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
|
2005-06-20 15:45:42 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
|
2006-02-27 14:05:32 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
|
2005-07-29 19:16:31 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
|
2006-02-27 14:05:32 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
|
2005-12-13 16:18:47 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
|
2005-07-29 19:16:31 +00:00
|
|
|
{ USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
|
2007-08-08 08:50:17 +00:00
|
|
|
{ USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
|
|
|
|
|
{ USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
|
2005-09-23 19:06:50 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
|
2006-01-09 13:12:40 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
|
2005-09-23 19:06:50 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
|
2006-01-09 13:12:40 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
|
2007-12-26 02:29:33 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
|
2005-11-23 23:45:23 +00:00
|
|
|
{ USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
|
|
|
|
|
{ USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
|
2005-12-09 06:30:59 +00:00
|
|
|
{ USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
|
2006-01-05 16:20:37 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
|
2006-03-21 14:55:20 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
|
2006-01-09 17:11:40 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
|
2006-01-03 13:30:31 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
|
2006-04-10 04:05:09 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
|
2006-04-12 14:20:35 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
|
2006-03-14 23:44:23 +00:00
|
|
|
{ USB_DEVICE(ICOM_ID1_VID, ICOM_ID1_PID) },
|
2006-03-28 11:41:26 +00:00
|
|
|
{ USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
|
2006-05-04 10:34:25 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
|
2006-05-30 11:36:30 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
|
2006-06-17 22:09:15 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
|
2006-07-11 09:36:43 +00:00
|
|
|
{ USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
|
2006-09-06 10:15:02 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
|
2006-09-25 13:19:19 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
|
2006-10-22 21:26:42 +00:00
|
|
|
{ USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
|
2007-02-04 22:39:11 +00:00
|
|
|
{ USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
|
2007-04-25 18:34:28 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
|
2007-09-06 20:34:39 +00:00
|
|
|
{ USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
|
2008-01-17 22:37:46 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
|
2008-03-10 10:38:55 +00:00
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
|
2007-05-05 01:23:24 +00:00
|
|
|
{ USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
|
2008-01-01 14:08:35 +00:00
|
|
|
.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
|
|
|
|
|
{ USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID),
|
|
|
|
|
.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
|
|
|
|
|
{ USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
|
|
|
|
|
.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
|
2005-07-28 17:40:32 +00:00
|
|
|
{ }, /* Optional parameter entry */
|
|
|
|
|
{ } /* Terminating entry */
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE (usb, id_table_combined);
|
|
|
|
|
|
|
|
|
|
static struct usb_driver ftdi_driver = {
|
|
|
|
|
.name = "ftdi_sio",
|
|
|
|
|
.probe = usb_serial_probe,
|
|
|
|
|
.disconnect = usb_serial_disconnect,
|
|
|
|
|
.id_table = id_table_combined,
|
2006-10-13 22:57:58 +00:00
|
|
|
.no_dynamic_id = 1,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2005-11-29 08:43:42 +00:00
|
|
|
static const char *ftdi_chip_name[] = {
|
2005-04-16 22:20:36 +00:00
|
|
|
[SIO] = "SIO", /* the serial part of FT8U100AX */
|
|
|
|
|
[FT8U232AM] = "FT8U232AM",
|
|
|
|
|
[FT232BM] = "FT232BM",
|
|
|
|
|
[FT2232C] = "FT2232C",
|
2007-03-04 23:03:26 +00:00
|
|
|
[FT232RL] = "FT232RL",
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Constants for read urb and write urb */
|
|
|
|
|
#define BUFSZ 512
|
|
|
|
|
#define PKTSZ 64
|
|
|
|
|
|
|
|
|
|
/* rx_flags */
|
|
|
|
|
#define THROTTLED 0x01
|
|
|
|
|
#define ACTUALLY_THROTTLED 0x02
|
|
|
|
|
|
|
|
|
|
/* Used for TIOCMIWAIT */
|
|
|
|
|
#define FTDI_STATUS_B0_MASK (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
|
|
|
|
|
#define FTDI_STATUS_B1_MASK (FTDI_RS_BI)
|
|
|
|
|
/* End TIOCMIWAIT */
|
|
|
|
|
|
2008-02-07 00:06:07 +00:00
|
|
|
#define FTDI_IMPL_ASYNC_FLAGS = (ASYNC_SPD_HI | ASYNC_SPD_VHI \
|
|
|
|
|
| ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* function prototypes for a FTDI serial converter */
|
2005-06-20 15:45:42 +00:00
|
|
|
static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_id *id);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void ftdi_shutdown (struct usb_serial *serial);
|
2007-02-28 18:10:50 +00:00
|
|
|
static int ftdi_sio_port_probe (struct usb_serial_port *port);
|
|
|
|
|
static int ftdi_sio_port_remove (struct usb_serial_port *port);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ftdi_open (struct usb_serial_port *port, struct file *filp);
|
|
|
|
|
static void ftdi_close (struct usb_serial_port *port, struct file *filp);
|
|
|
|
|
static int ftdi_write (struct usb_serial_port *port, const unsigned char *buf, int count);
|
|
|
|
|
static int ftdi_write_room (struct usb_serial_port *port);
|
|
|
|
|
static int ftdi_chars_in_buffer (struct usb_serial_port *port);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static void ftdi_write_bulk_callback (struct urb *urb);
|
|
|
|
|
static void ftdi_read_bulk_callback (struct urb *urb);
|
2006-11-22 14:57:56 +00:00
|
|
|
static void ftdi_process_read (struct work_struct *work);
|
2006-12-08 10:38:45 +00:00
|
|
|
static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios * old);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file);
|
|
|
|
|
static int ftdi_tiocmset (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
|
|
|
|
|
static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
|
|
|
|
|
static void ftdi_break_ctl (struct usb_serial_port *port, int break_state );
|
|
|
|
|
static void ftdi_throttle (struct usb_serial_port *port);
|
|
|
|
|
static void ftdi_unthrottle (struct usb_serial_port *port);
|
|
|
|
|
|
|
|
|
|
static unsigned short int ftdi_232am_baud_base_to_divisor (int baud, int base);
|
|
|
|
|
static unsigned short int ftdi_232am_baud_to_divisor (int baud);
|
|
|
|
|
static __u32 ftdi_232bm_baud_base_to_divisor (int baud, int base);
|
|
|
|
|
static __u32 ftdi_232bm_baud_to_divisor (int baud);
|
|
|
|
|
|
2005-06-21 04:15:16 +00:00
|
|
|
static struct usb_serial_driver ftdi_sio_device = {
|
2005-06-21 04:15:16 +00:00
|
|
|
.driver = {
|
|
|
|
|
.owner = THIS_MODULE,
|
2005-06-21 04:15:16 +00:00
|
|
|
.name = "ftdi_sio",
|
2005-06-21 04:15:16 +00:00
|
|
|
},
|
2005-06-21 04:15:16 +00:00
|
|
|
.description = "FTDI USB Serial Device",
|
2006-12-17 20:50:24 +00:00
|
|
|
.usb_driver = &ftdi_driver ,
|
2005-06-20 15:45:42 +00:00
|
|
|
.id_table = id_table_combined,
|
2005-04-16 22:20:36 +00:00
|
|
|
.num_interrupt_in = 0,
|
|
|
|
|
.num_bulk_in = 1,
|
|
|
|
|
.num_bulk_out = 1,
|
|
|
|
|
.num_ports = 1,
|
2005-06-20 15:45:42 +00:00
|
|
|
.probe = ftdi_sio_probe,
|
2007-02-28 18:10:50 +00:00
|
|
|
.port_probe = ftdi_sio_port_probe,
|
|
|
|
|
.port_remove = ftdi_sio_port_remove,
|
2005-04-16 22:20:36 +00:00
|
|
|
.open = ftdi_open,
|
|
|
|
|
.close = ftdi_close,
|
|
|
|
|
.throttle = ftdi_throttle,
|
|
|
|
|
.unthrottle = ftdi_unthrottle,
|
|
|
|
|
.write = ftdi_write,
|
|
|
|
|
.write_room = ftdi_write_room,
|
|
|
|
|
.chars_in_buffer = ftdi_chars_in_buffer,
|
|
|
|
|
.read_bulk_callback = ftdi_read_bulk_callback,
|
|
|
|
|
.write_bulk_callback = ftdi_write_bulk_callback,
|
|
|
|
|
.tiocmget = ftdi_tiocmget,
|
|
|
|
|
.tiocmset = ftdi_tiocmset,
|
|
|
|
|
.ioctl = ftdi_ioctl,
|
|
|
|
|
.set_termios = ftdi_set_termios,
|
|
|
|
|
.break_ctl = ftdi_break_ctl,
|
|
|
|
|
.shutdown = ftdi_shutdown,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define WDR_TIMEOUT 5000 /* default urb timeout */
|
2005-07-29 19:16:52 +00:00
|
|
|
#define WDR_SHORT_TIMEOUT 1000 /* shorter urb timeout */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* High and low are for DTR, RTS etc etc */
|
|
|
|
|
#define HIGH 1
|
|
|
|
|
#define LOW 0
|
|
|
|
|
|
2006-06-26 11:59:17 +00:00
|
|
|
/* number of outstanding urbs to prevent userspace DoS from happening */
|
|
|
|
|
#define URB_UPPER_LIMIT 42
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* ***************************************************************************
|
2007-05-05 01:23:24 +00:00
|
|
|
* Utility functions
|
2005-04-16 22:20:36 +00:00
|
|
|
* ***************************************************************************
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
|
|
|
|
|
{
|
|
|
|
|
unsigned short int divisor;
|
|
|
|
|
int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
|
|
|
|
|
if ((divisor3 & 0x7) == 7) divisor3 ++; // round x.7/8 up to x+1
|
|
|
|
|
divisor = divisor3 >> 3;
|
|
|
|
|
divisor3 &= 0x7;
|
|
|
|
|
if (divisor3 == 1) divisor |= 0xc000; else // 0.125
|
|
|
|
|
if (divisor3 >= 4) divisor |= 0x4000; else // 0.5
|
|
|
|
|
if (divisor3 != 0) divisor |= 0x8000; // 0.25
|
|
|
|
|
if (divisor == 1) divisor = 0; /* special case for maximum baud rate */
|
|
|
|
|
return divisor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned short int ftdi_232am_baud_to_divisor(int baud)
|
|
|
|
|
{
|
|
|
|
|
return(ftdi_232am_baud_base_to_divisor(baud, 48000000));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
|
|
|
|
|
{
|
|
|
|
|
static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
|
|
|
|
|
__u32 divisor;
|
|
|
|
|
int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
|
|
|
|
|
divisor = divisor3 >> 3;
|
|
|
|
|
divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
|
|
|
|
|
/* Deal with special cases for highest baud rates. */
|
|
|
|
|
if (divisor == 1) divisor = 0; else // 1.0
|
|
|
|
|
if (divisor == 0x4001) divisor = 1; // 1.5
|
|
|
|
|
return divisor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static __u32 ftdi_232bm_baud_to_divisor(int baud)
|
|
|
|
|
{
|
|
|
|
|
return(ftdi_232bm_baud_base_to_divisor(baud, 48000000));
|
|
|
|
|
}
|
|
|
|
|
|
2005-07-29 19:16:41 +00:00
|
|
|
#define set_mctrl(port, set) update_mctrl((port), (set), 0)
|
|
|
|
|
#define clear_mctrl(port, clear) update_mctrl((port), 0, (clear))
|
|
|
|
|
|
|
|
|
|
static int update_mctrl(struct usb_serial_port *port, unsigned int set, unsigned int clear)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
char *buf;
|
2005-07-29 19:16:41 +00:00
|
|
|
unsigned urb_value;
|
2005-04-16 22:20:36 +00:00
|
|
|
int rv;
|
|
|
|
|
|
2005-07-29 19:16:41 +00:00
|
|
|
if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
|
|
|
|
|
dbg("%s - DTR|RTS not being set|cleared", __FUNCTION__);
|
|
|
|
|
return 0; /* no change */
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
buf = kmalloc(1, GFP_NOIO);
|
2005-07-29 19:16:41 +00:00
|
|
|
if (!buf) {
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
2005-07-29 19:16:41 +00:00
|
|
|
|
|
|
|
|
clear &= ~set; /* 'set' takes precedence over 'clear' */
|
|
|
|
|
urb_value = 0;
|
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
|
urb_value |= FTDI_SIO_SET_DTR_LOW;
|
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
|
urb_value |= FTDI_SIO_SET_RTS_LOW;
|
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
|
urb_value |= FTDI_SIO_SET_DTR_HIGH;
|
|
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
|
urb_value |= FTDI_SIO_SET_RTS_HIGH;
|
2005-04-16 22:20:36 +00:00
|
|
|
rv = usb_control_msg(port->serial->dev,
|
|
|
|
|
usb_sndctrlpipe(port->serial->dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_SET_MODEM_CTRL_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
|
2005-07-29 19:16:41 +00:00
|
|
|
urb_value, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 0, WDR_TIMEOUT);
|
|
|
|
|
|
|
|
|
|
kfree(buf);
|
2005-07-29 19:16:41 +00:00
|
|
|
if (rv < 0) {
|
|
|
|
|
err("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
|
|
|
|
|
__FUNCTION__,
|
|
|
|
|
(set & TIOCM_DTR) ? "HIGH" :
|
|
|
|
|
(clear & TIOCM_DTR) ? "LOW" : "unchanged",
|
|
|
|
|
(set & TIOCM_RTS) ? "HIGH" :
|
|
|
|
|
(clear & TIOCM_RTS) ? "LOW" : "unchanged");
|
|
|
|
|
} else {
|
|
|
|
|
dbg("%s - DTR %s, RTS %s", __FUNCTION__,
|
|
|
|
|
(set & TIOCM_DTR) ? "HIGH" :
|
|
|
|
|
(clear & TIOCM_DTR) ? "LOW" : "unchanged",
|
|
|
|
|
(set & TIOCM_RTS) ? "HIGH" :
|
|
|
|
|
(clear & TIOCM_RTS) ? "LOW" : "unchanged");
|
|
|
|
|
priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static __u32 get_ftdi_divisor(struct usb_serial_port * port);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int change_speed(struct usb_serial_port *port)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
char *buf;
|
|
|
|
|
__u16 urb_value;
|
|
|
|
|
__u16 urb_index;
|
|
|
|
|
__u32 urb_index_value;
|
|
|
|
|
int rv;
|
|
|
|
|
|
|
|
|
|
buf = kmalloc(1, GFP_NOIO);
|
|
|
|
|
if (!buf)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
urb_index_value = get_ftdi_divisor(port);
|
|
|
|
|
urb_value = (__u16)urb_index_value;
|
|
|
|
|
urb_index = (__u16)(urb_index_value >> 16);
|
|
|
|
|
if (priv->interface) { /* FT2232C */
|
|
|
|
|
urb_index = (__u16)((urb_index << 8) | priv->interface);
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
rv = usb_control_msg(port->serial->dev,
|
|
|
|
|
usb_sndctrlpipe(port->serial->dev, 0),
|
|
|
|
|
FTDI_SIO_SET_BAUDRATE_REQUEST,
|
|
|
|
|
FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
|
|
|
|
|
urb_value, urb_index,
|
2005-07-29 19:16:52 +00:00
|
|
|
buf, 0, WDR_SHORT_TIMEOUT);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static __u32 get_ftdi_divisor(struct usb_serial_port * port)
|
|
|
|
|
{ /* get_ftdi_divisor */
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
__u32 div_value = 0;
|
|
|
|
|
int div_okay = 1;
|
|
|
|
|
int baud;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The logic involved in setting the baudrate can be cleanly split in 3 steps.
|
|
|
|
|
* Obtaining the actual baud rate is a little tricky since unix traditionally
|
|
|
|
|
* somehow ignored the possibility to set non-standard baud rates.
|
|
|
|
|
* 1. Standard baud rates are set in tty->termios->c_cflag
|
|
|
|
|
* 2. If these are not enough, you can set any speed using alt_speed as follows:
|
|
|
|
|
* - set tty->termios->c_cflag speed to B38400
|
|
|
|
|
* - set your real speed in tty->alt_speed; it gets ignored when
|
|
|
|
|
* alt_speed==0, (or)
|
|
|
|
|
* - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
|
|
|
|
|
* flags & ASYNC_SPD_MASK == ASYNC_SPD_[HI, VHI, SHI, WARP], this just
|
|
|
|
|
* sets alt_speed to (HI: 57600, VHI: 115200, SHI: 230400, WARP: 460800)
|
|
|
|
|
* ** Steps 1, 2 are done courtesy of tty_get_baud_rate
|
|
|
|
|
* 3. You can also set baud rate by setting custom divisor as follows
|
|
|
|
|
* - set tty->termios->c_cflag speed to B38400
|
|
|
|
|
* - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
|
|
|
|
|
* o flags & ASYNC_SPD_MASK == ASYNC_SPD_CUST
|
|
|
|
|
* o custom_divisor set to baud_base / your_new_baudrate
|
|
|
|
|
* ** Step 3 is done courtesy of code borrowed from serial.c - I should really
|
|
|
|
|
* spend some time and separate+move this common code to serial.c, it is
|
|
|
|
|
* replicated in nearly every serial driver you see.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
|
|
|
|
|
|
|
|
|
|
baud = tty_get_baud_rate(port->tty);
|
|
|
|
|
dbg("%s - tty_get_baud_rate reports speed %d", __FUNCTION__, baud);
|
|
|
|
|
|
|
|
|
|
/* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
|
|
|
|
|
|
|
|
|
|
if (baud == 38400 &&
|
|
|
|
|
((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
|
|
|
|
|
(priv->custom_divisor)) {
|
|
|
|
|
baud = priv->baud_base / priv->custom_divisor;
|
|
|
|
|
dbg("%s - custom divisor %d sets baud rate to %d", __FUNCTION__, priv->custom_divisor, baud);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 3. Convert baudrate to device-specific divisor */
|
|
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
if (!baud) baud = 9600;
|
2005-04-16 22:20:36 +00:00
|
|
|
switch(priv->chip_type) {
|
|
|
|
|
case SIO: /* SIO chip */
|
|
|
|
|
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) {
|
2006-10-13 22:57:58 +00:00
|
|
|
dbg("%s - Baudrate (%d) requested is not supported", __FUNCTION__, baud);
|
2005-04-16 22:20:36 +00:00
|
|
|
div_value = ftdi_sio_b9600;
|
2007-10-18 08:24:25 +00:00
|
|
|
baud = 9600;
|
2005-04-16 22:20:36 +00:00
|
|
|
div_okay = 0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case FT8U232AM: /* 8U232AM chip */
|
|
|
|
|
if (baud <= 3000000) {
|
|
|
|
|
div_value = ftdi_232am_baud_to_divisor(baud);
|
|
|
|
|
} else {
|
|
|
|
|
dbg("%s - Baud rate too high!", __FUNCTION__);
|
2007-10-18 08:24:25 +00:00
|
|
|
baud = 9600;
|
2005-04-16 22:20:36 +00:00
|
|
|
div_value = ftdi_232am_baud_to_divisor(9600);
|
|
|
|
|
div_okay = 0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case FT232BM: /* FT232BM chip */
|
|
|
|
|
case FT2232C: /* FT2232C chip */
|
2007-03-23 19:54:27 +00:00
|
|
|
case FT232RL:
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
2007-10-18 08:24:24 +00:00
|
|
|
baud = 9600;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
|
ftdi_chip_name[priv->chip_type]);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-18 08:24:24 +00:00
|
|
|
tty_encode_baud_rate(port->tty, baud, baud);
|
2005-04-16 22:20:36 +00:00
|
|
|
return(div_value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
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 __user * newinfo)
|
|
|
|
|
{ /* set_serial_info */
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
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) |
|
2006-10-13 22:57:58 +00:00
|
|
|
(new_serial.flags & ASYNC_FLAGS));
|
2005-04-16 22:20:36 +00:00
|
|
|
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);
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
|
|
} /* set_serial_info */
|
|
|
|
|
|
|
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
/* Determine type of FTDI chip based on USB config and descriptor. */
|
|
|
|
|
static void ftdi_determine_type(struct usb_serial_port *port)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
|
struct usb_device *udev = serial->dev;
|
|
|
|
|
unsigned version;
|
|
|
|
|
unsigned interfaces;
|
|
|
|
|
|
|
|
|
|
/* Assume it is not the original SIO device for now. */
|
2005-09-12 11:23:25 +00:00
|
|
|
priv->baud_base = 48000000 / 2;
|
2005-06-20 15:45:42 +00:00
|
|
|
priv->write_offset = 0;
|
|
|
|
|
|
|
|
|
|
version = le16_to_cpu(udev->descriptor.bcdDevice);
|
|
|
|
|
interfaces = udev->actconfig->desc.bNumInterfaces;
|
|
|
|
|
dbg("%s: bcdDevice = 0x%x, bNumInterfaces = %u", __FUNCTION__,
|
|
|
|
|
version, interfaces);
|
|
|
|
|
if (interfaces > 1) {
|
|
|
|
|
int inter;
|
|
|
|
|
|
|
|
|
|
/* Multiple interfaces. Assume FT2232C. */
|
|
|
|
|
priv->chip_type = FT2232C;
|
|
|
|
|
/* Determine interface code. */
|
|
|
|
|
inter = serial->interface->altsetting->desc.bInterfaceNumber;
|
|
|
|
|
if (inter == 0) {
|
|
|
|
|
priv->interface = PIT_SIOA;
|
|
|
|
|
} else {
|
|
|
|
|
priv->interface = PIT_SIOB;
|
|
|
|
|
}
|
|
|
|
|
/* BM-type devices have a bug where bcdDevice gets set
|
|
|
|
|
* to 0x200 when iSerialNumber is 0. */
|
|
|
|
|
if (version < 0x500) {
|
|
|
|
|
dbg("%s: something fishy - bcdDevice too low for multi-interface device",
|
|
|
|
|
__FUNCTION__);
|
|
|
|
|
}
|
|
|
|
|
} else if (version < 0x200) {
|
|
|
|
|
/* Old device. Assume its the original SIO. */
|
|
|
|
|
priv->chip_type = SIO;
|
|
|
|
|
priv->baud_base = 12000000 / 16;
|
|
|
|
|
priv->write_offset = 1;
|
|
|
|
|
} else if (version < 0x400) {
|
|
|
|
|
/* Assume its an FT8U232AM (or FT8U245AM) */
|
|
|
|
|
/* (It might be a BM because of the iSerialNumber bug,
|
|
|
|
|
* but it will still work as an AM device.) */
|
|
|
|
|
priv->chip_type = FT8U232AM;
|
2007-03-23 19:54:27 +00:00
|
|
|
} else if (version < 0x600) {
|
2005-06-20 15:45:42 +00:00
|
|
|
/* Assume its an FT232BM (or FT245BM) */
|
|
|
|
|
priv->chip_type = FT232BM;
|
2007-03-23 19:54:27 +00:00
|
|
|
} else {
|
|
|
|
|
/* Assume its an FT232R */
|
|
|
|
|
priv->chip_type = FT232RL;
|
2005-06-20 15:45:42 +00:00
|
|
|
}
|
|
|
|
|
info("Detected %s", ftdi_chip_name[priv->chip_type]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* ***************************************************************************
|
|
|
|
|
* Sysfs Attribute
|
|
|
|
|
* ***************************************************************************
|
|
|
|
|
*/
|
|
|
|
|
|
2005-05-17 10:44:04 +00:00
|
|
|
static ssize_t show_latency_timer(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct usb_serial_port *port = to_usb_serial_port(dev);
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2007-02-28 18:10:50 +00:00
|
|
|
struct usb_device *udev = port->serial->dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned short latency = 0;
|
|
|
|
|
int rv = 0;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s",__FUNCTION__);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
rv = usb_control_msg(udev,
|
|
|
|
|
usb_rcvctrlpipe(udev, 0),
|
|
|
|
|
FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
|
|
|
|
|
FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
0, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
(char*) &latency, 1, WDR_TIMEOUT);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (rv < 0) {
|
2007-10-18 10:06:30 +00:00
|
|
|
dev_err(dev, "Unable to read latency timer: %i\n", rv);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
|
|
|
|
}
|
|
|
|
|
return sprintf(buf, "%i\n", latency);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write a new value of the latency timer, in units of milliseconds. */
|
2005-05-17 10:44:04 +00:00
|
|
|
static ssize_t store_latency_timer(struct device *dev, struct device_attribute *attr, const char *valbuf,
|
2005-04-16 22:20:36 +00:00
|
|
|
size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct usb_serial_port *port = to_usb_serial_port(dev);
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2007-02-28 18:10:50 +00:00
|
|
|
struct usb_device *udev = port->serial->dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
char buf[1];
|
|
|
|
|
int v = simple_strtoul(valbuf, NULL, 10);
|
|
|
|
|
int rv = 0;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s: setting latency timer = %i", __FUNCTION__, v);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
rv = usb_control_msg(udev,
|
|
|
|
|
usb_sndctrlpipe(udev, 0),
|
|
|
|
|
FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
|
|
|
|
|
FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
v, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 0, WDR_TIMEOUT);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (rv < 0) {
|
2007-10-18 10:06:30 +00:00
|
|
|
dev_err(dev, "Unable to write latency timer: %i\n", rv);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write an event character directly to the FTDI register. The ASCII
|
|
|
|
|
value is in the low 8 bits, with the enable bit in the 9th bit. */
|
2005-05-17 10:44:04 +00:00
|
|
|
static ssize_t store_event_char(struct device *dev, struct device_attribute *attr, const char *valbuf,
|
2005-04-16 22:20:36 +00:00
|
|
|
size_t count)
|
|
|
|
|
{
|
|
|
|
|
struct usb_serial_port *port = to_usb_serial_port(dev);
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2007-02-28 18:10:50 +00:00
|
|
|
struct usb_device *udev = port->serial->dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
char buf[1];
|
|
|
|
|
int v = simple_strtoul(valbuf, NULL, 10);
|
|
|
|
|
int rv = 0;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s: setting event char = %i", __FUNCTION__, v);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
rv = usb_control_msg(udev,
|
|
|
|
|
usb_sndctrlpipe(udev, 0),
|
|
|
|
|
FTDI_SIO_SET_EVENT_CHAR_REQUEST,
|
|
|
|
|
FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
v, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 0, WDR_TIMEOUT);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (rv < 0) {
|
|
|
|
|
dbg("Unable to write event character: %i", rv);
|
|
|
|
|
return -EIO;
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static DEVICE_ATTR(latency_timer, S_IWUSR | S_IRUGO, show_latency_timer, store_latency_timer);
|
|
|
|
|
static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
|
|
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
static int create_sysfs_attrs(struct usb_serial_port *port)
|
2006-08-28 18:43:25 +00:00
|
|
|
{
|
2007-02-28 18:10:50 +00:00
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2006-08-28 18:43:25 +00:00
|
|
|
int retval = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
dbg("%s",__FUNCTION__);
|
2006-08-28 18:43:25 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* XXX I've no idea if the original SIO supports the event_char
|
|
|
|
|
* sysfs parameter, so I'm playing it safe. */
|
|
|
|
|
if (priv->chip_type != SIO) {
|
|
|
|
|
dbg("sysfs attributes for %s", ftdi_chip_name[priv->chip_type]);
|
2007-02-28 18:10:50 +00:00
|
|
|
retval = device_create_file(&port->dev, &dev_attr_event_char);
|
2006-08-28 18:43:25 +00:00
|
|
|
if ((!retval) &&
|
2007-05-09 18:53:04 +00:00
|
|
|
(priv->chip_type == FT232BM ||
|
|
|
|
|
priv->chip_type == FT2232C ||
|
|
|
|
|
priv->chip_type == FT232RL)) {
|
2007-02-28 18:10:50 +00:00
|
|
|
retval = device_create_file(&port->dev,
|
2006-08-28 18:43:25 +00:00
|
|
|
&dev_attr_latency_timer);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
2006-08-28 18:43:25 +00:00
|
|
|
return retval;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
static void remove_sysfs_attrs(struct usb_serial_port *port)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-02-28 18:10:50 +00:00
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
dbg("%s",__FUNCTION__);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* XXX see create_sysfs_attrs */
|
|
|
|
|
if (priv->chip_type != SIO) {
|
2007-02-28 18:10:50 +00:00
|
|
|
device_remove_file(&port->dev, &dev_attr_event_char);
|
2007-08-21 18:08:56 +00:00
|
|
|
if (priv->chip_type == FT232BM ||
|
|
|
|
|
priv->chip_type == FT2232C ||
|
|
|
|
|
priv->chip_type == FT232RL) {
|
2007-02-28 18:10:50 +00:00
|
|
|
device_remove_file(&port->dev, &dev_attr_latency_timer);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ***************************************************************************
|
|
|
|
|
* FTDI driver specific functions
|
|
|
|
|
* ***************************************************************************
|
|
|
|
|
*/
|
|
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
/* Probe function to check for special devices */
|
|
|
|
|
static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_id *id)
|
|
|
|
|
{
|
2007-05-05 01:23:24 +00:00
|
|
|
struct ftdi_sio_quirk *quirk = (struct ftdi_sio_quirk *)id->driver_info;
|
|
|
|
|
|
|
|
|
|
if (quirk && quirk->probe) {
|
|
|
|
|
int ret = quirk->probe(serial);
|
|
|
|
|
if (ret != 0)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
usb_set_serial_data(serial, (void *)id->driver_info);
|
|
|
|
|
|
2007-05-05 01:23:24 +00:00
|
|
|
return 0;
|
2005-06-20 15:45:42 +00:00
|
|
|
}
|
|
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
static int ftdi_sio_port_probe(struct usb_serial_port *port)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv;
|
2007-07-09 19:03:08 +00:00
|
|
|
struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
|
|
|
|
|
|
2006-08-28 18:43:25 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s",__FUNCTION__);
|
|
|
|
|
|
2006-02-27 20:29:43 +00:00
|
|
|
priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!priv){
|
|
|
|
|
err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
spin_lock_init(&priv->rx_lock);
|
2006-06-26 11:59:17 +00:00
|
|
|
spin_lock_init(&priv->tx_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
|
|
|
|
|
2007-07-09 19:03:08 +00:00
|
|
|
if (quirk && quirk->port_probe)
|
|
|
|
|
quirk->port_probe(priv);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Increase the size of read buffers */
|
2005-04-19 00:39:34 +00:00
|
|
|
kfree(port->bulk_in_buffer);
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-22 14:57:56 +00:00
|
|
|
INIT_DELAYED_WORK(&priv->rx_work, ftdi_process_read);
|
|
|
|
|
priv->port = port;
|
2005-06-02 09:34:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Free port's existing write urb and transfer buffer. */
|
|
|
|
|
if (port->write_urb) {
|
|
|
|
|
usb_free_urb (port->write_urb);
|
|
|
|
|
port->write_urb = NULL;
|
|
|
|
|
}
|
2005-04-19 00:39:34 +00:00
|
|
|
kfree(port->bulk_out_buffer);
|
|
|
|
|
port->bulk_out_buffer = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
usb_set_serial_port_data(port, priv);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
ftdi_determine_type (port);
|
|
|
|
|
create_sysfs_attrs(port);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
/* Setup for the USB-UIRT device, which requires hardwired
|
|
|
|
|
* baudrate (38400 gets mapped to 312500) */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Called from usbserial:serial_probe */
|
2007-07-09 19:03:08 +00:00
|
|
|
static void ftdi_USB_UIRT_setup (struct ftdi_private *priv)
|
2005-06-20 15:45:42 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s",__FUNCTION__);
|
|
|
|
|
|
|
|
|
|
priv->flags |= ASYNC_SPD_CUST;
|
|
|
|
|
priv->custom_divisor = 77;
|
2007-10-18 08:24:24 +00:00
|
|
|
priv->force_baud = 38400;
|
2005-06-20 15:45:42 +00:00
|
|
|
} /* ftdi_USB_UIRT_setup */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-20 15:45:42 +00:00
|
|
|
/* Setup for the HE-TIRA1 device, which requires hardwired
|
|
|
|
|
* baudrate (38400 gets mapped to 100000) and RTS-CTS enabled. */
|
2007-07-09 19:03:08 +00:00
|
|
|
static void ftdi_HE_TIRA1_setup (struct ftdi_private *priv)
|
2005-06-20 15:45:42 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s",__FUNCTION__);
|
|
|
|
|
|
|
|
|
|
priv->flags |= ASYNC_SPD_CUST;
|
|
|
|
|
priv->custom_divisor = 240;
|
2007-10-18 08:24:24 +00:00
|
|
|
priv->force_baud = 38400;
|
2005-04-16 22:20:36 +00:00
|
|
|
priv->force_rtscts = 1;
|
2005-06-20 15:45:42 +00:00
|
|
|
} /* ftdi_HE_TIRA1_setup */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-05 01:23:24 +00:00
|
|
|
/*
|
2008-01-01 14:08:35 +00:00
|
|
|
* First port on JTAG adaptors such as Olimex arm-usb-ocd or the FIC/OpenMoko
|
|
|
|
|
* Neo1973 Debug Board is reserved for JTAG interface and can be accessed from
|
|
|
|
|
* userspace using openocd.
|
2007-05-05 01:23:24 +00:00
|
|
|
*/
|
2008-01-01 14:08:35 +00:00
|
|
|
static int ftdi_jtag_probe(struct usb_serial *serial)
|
2007-05-05 01:23:24 +00:00
|
|
|
{
|
|
|
|
|
struct usb_device *udev = serial->dev;
|
|
|
|
|
struct usb_interface *interface = serial->interface;
|
|
|
|
|
|
|
|
|
|
dbg("%s",__FUNCTION__);
|
|
|
|
|
|
|
|
|
|
if (interface == udev->actconfig->interface[0]) {
|
2008-01-01 14:08:35 +00:00
|
|
|
info("Ignoring serial port reserved for JTAG");
|
2007-05-05 01:23:24 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-01 18:49:59 +00:00
|
|
|
/*
|
|
|
|
|
* The Matrix Orbital VK204-25-USB has an invalid IN endpoint.
|
|
|
|
|
* We have to correct it if we want to read from it.
|
|
|
|
|
*/
|
|
|
|
|
static int ftdi_mtxorb_hack_setup(struct usb_serial *serial)
|
|
|
|
|
{
|
|
|
|
|
struct usb_host_endpoint *ep = serial->dev->ep_in[1];
|
|
|
|
|
struct usb_endpoint_descriptor *ep_desc = &ep->desc;
|
|
|
|
|
|
|
|
|
|
if (ep->enabled && ep_desc->wMaxPacketSize == 0) {
|
|
|
|
|
ep_desc->wMaxPacketSize = 0x40;
|
|
|
|
|
info("Fixing invalid wMaxPacketSize on read pipe");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
/* ftdi_shutdown is called from usbserial:usb_serial_disconnect
|
2005-04-16 22:20:36 +00:00
|
|
|
* 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)
|
2007-02-28 18:10:50 +00:00
|
|
|
{
|
|
|
|
|
dbg("%s", __FUNCTION__);
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
static int ftdi_sio_port_remove(struct usb_serial_port *port)
|
|
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
|
|
dbg("%s", __FUNCTION__);
|
|
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
remove_sysfs_attrs(port);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
|
|
|
|
/* all open ports are closed at this point
|
|
|
|
|
* (by usbserial.c:__serial_close, which calls ftdi_close)
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (priv) {
|
|
|
|
|
usb_set_serial_port_data(port, NULL);
|
|
|
|
|
kfree(priv);
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-28 18:10:50 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
static int ftdi_open (struct usb_serial_port *port, struct file *filp)
|
|
|
|
|
{ /* ftdi_open */
|
|
|
|
|
struct usb_device *dev = port->serial->dev;
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
unsigned long flags;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int result = 0;
|
|
|
|
|
char buf[1]; /* Needed for the usb_control_msg I think */
|
|
|
|
|
|
|
|
|
|
dbg("%s", __FUNCTION__);
|
|
|
|
|
|
2006-06-26 11:59:17 +00:00
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
priv->tx_bytes = 0;
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
|
|
|
|
spin_lock_irqsave(&priv->rx_lock, flags);
|
|
|
|
|
priv->rx_bytes = 0;
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
|
2006-04-13 20:27:12 +00:00
|
|
|
if (port->tty)
|
|
|
|
|
port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* No error checking for this (will get errors later anyway) */
|
|
|
|
|
/* See ftdi_sio.h for description of what is reset */
|
|
|
|
|
usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
|
|
|
|
|
FTDI_SIO_RESET_SIO,
|
2005-04-16 22:20:36 +00:00
|
|
|
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 */
|
2006-04-13 20:27:12 +00:00
|
|
|
if (port->tty)
|
2007-10-18 08:24:24 +00:00
|
|
|
ftdi_set_termios(port, port->tty->termios);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* 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 */
|
2005-07-29 19:16:41 +00:00
|
|
|
set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* Not throttled */
|
|
|
|
|
spin_lock_irqsave(&priv->rx_lock, flags);
|
|
|
|
|
priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
|
|
|
|
|
/* Start reading from the device */
|
2005-06-02 09:34:11 +00:00
|
|
|
priv->rx_processed = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_fill_bulk_urb(port->read_urb, dev,
|
|
|
|
|
usb_rcvbulkpipe(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, GFP_KERNEL);
|
|
|
|
|
if (result)
|
|
|
|
|
err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
} /* ftdi_open */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* usbserial:__serial_close only calls ftdi_close if the point is open
|
|
|
|
|
*
|
|
|
|
|
* This only gets called when it is the last close
|
2006-10-13 22:57:58 +00:00
|
|
|
*
|
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void ftdi_close (struct usb_serial_port *port, struct file *filp)
|
|
|
|
|
{ /* ftdi_close */
|
|
|
|
|
unsigned int c_cflag = port->tty->termios->c_cflag;
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
char buf[1];
|
|
|
|
|
|
|
|
|
|
dbg("%s", __FUNCTION__);
|
|
|
|
|
|
2008-01-22 12:56:18 +00:00
|
|
|
mutex_lock(&port->serial->disc_mutex);
|
|
|
|
|
if (c_cflag & HUPCL && !port->serial->disconnected){
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Disable flow control */
|
2006-10-13 22:57:58 +00:00
|
|
|
if (usb_control_msg(port->serial->dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_sndctrlpipe(port->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");
|
2006-10-13 22:57:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-29 19:16:41 +00:00
|
|
|
/* drop RTS and DTR */
|
|
|
|
|
clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
|
2005-04-16 22:20:36 +00:00
|
|
|
} /* Note change no line if hupcl is off */
|
2008-01-22 12:56:18 +00:00
|
|
|
mutex_unlock(&port->serial->disc_mutex);
|
2005-06-02 09:34:11 +00:00
|
|
|
|
|
|
|
|
/* cancel any scheduled reading */
|
|
|
|
|
cancel_delayed_work(&priv->rx_work);
|
|
|
|
|
flush_scheduled_work();
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* shutdown our bulk read */
|
2006-11-08 14:36:25 +00:00
|
|
|
usb_kill_urb(port->read_urb);
|
2005-04-16 22:20:36 +00:00
|
|
|
} /* ftdi_close */
|
|
|
|
|
|
|
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* 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,
|
|
|
|
|
const unsigned char *buf, int count)
|
|
|
|
|
{ /* ftdi_write */
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
struct urb *urb;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
int data_offset ; /* will be 1 for the SIO and 0 otherwise */
|
|
|
|
|
int status;
|
|
|
|
|
int transfer_size;
|
2006-06-26 11:59:17 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
dbg("%s port %d, %d bytes", __FUNCTION__, port->number, count);
|
|
|
|
|
|
|
|
|
|
if (count == 0) {
|
|
|
|
|
dbg("write request of 0 bytes");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2006-06-26 11:59:17 +00:00
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
if (priv->tx_outstanding_urbs > URB_UPPER_LIMIT) {
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
|
|
|
|
dbg("%s - write limit hit\n", __FUNCTION__);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-03-23 13:30:16 +00:00
|
|
|
priv->tx_outstanding_urbs++;
|
2006-06-26 11:59:17 +00:00
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
data_offset = priv->write_offset;
|
|
|
|
|
dbg("data_offset set to %d",data_offset);
|
|
|
|
|
|
|
|
|
|
/* Determine total transfer size */
|
|
|
|
|
transfer_size = count;
|
|
|
|
|
if (data_offset > 0) {
|
|
|
|
|
/* Original sio needs control bytes too... */
|
|
|
|
|
transfer_size += (data_offset *
|
|
|
|
|
((count + (PKTSZ - 1 - data_offset)) /
|
|
|
|
|
(PKTSZ - data_offset)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
buffer = kmalloc (transfer_size, GFP_ATOMIC);
|
|
|
|
|
if (!buffer) {
|
|
|
|
|
err("%s ran out of kernel memory for urb ...", __FUNCTION__);
|
2007-03-23 13:30:16 +00:00
|
|
|
count = -ENOMEM;
|
|
|
|
|
goto error_no_buffer;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
urb = usb_alloc_urb(0, GFP_ATOMIC);
|
|
|
|
|
if (!urb) {
|
|
|
|
|
err("%s - no more free urbs", __FUNCTION__);
|
2007-03-23 13:30:16 +00:00
|
|
|
count = -ENOMEM;
|
|
|
|
|
goto error_no_urb;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy data */
|
|
|
|
|
if (data_offset > 0) {
|
|
|
|
|
/* Original sio requires control byte at start of each packet. */
|
|
|
|
|
int user_pktsz = PKTSZ - data_offset;
|
|
|
|
|
int todo = count;
|
|
|
|
|
unsigned char *first_byte = buffer;
|
|
|
|
|
const unsigned char *current_position = buf;
|
|
|
|
|
|
|
|
|
|
while (todo > 0) {
|
|
|
|
|
if (user_pktsz > todo) {
|
|
|
|
|
user_pktsz = todo;
|
|
|
|
|
}
|
|
|
|
|
/* Write the control byte at the front of the packet*/
|
2006-10-13 22:57:58 +00:00
|
|
|
*first_byte = 1 | ((user_pktsz) << 2);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Copy data for packet */
|
|
|
|
|
memcpy (first_byte + data_offset,
|
|
|
|
|
current_position, user_pktsz);
|
|
|
|
|
first_byte += user_pktsz + data_offset;
|
|
|
|
|
current_position += user_pktsz;
|
|
|
|
|
todo -= user_pktsz;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* No control byte required. */
|
|
|
|
|
/* Copy in the data to send */
|
|
|
|
|
memcpy (buffer, buf, count);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
usb_serial_debug_data(debug, &port->dev, __FUNCTION__, transfer_size, buffer);
|
|
|
|
|
|
|
|
|
|
/* fill the buffer and send it */
|
2006-10-13 22:57:58 +00:00
|
|
|
usb_fill_bulk_urb(urb, port->serial->dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
|
|
|
|
|
buffer, transfer_size,
|
|
|
|
|
ftdi_write_bulk_callback, port);
|
|
|
|
|
|
|
|
|
|
status = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
|
if (status) {
|
|
|
|
|
err("%s - failed submitting write urb, error %d", __FUNCTION__, status);
|
|
|
|
|
count = status;
|
2007-03-23 13:30:16 +00:00
|
|
|
goto error;
|
2006-06-26 11:59:17 +00:00
|
|
|
} else {
|
|
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
priv->tx_outstanding_bytes += count;
|
|
|
|
|
priv->tx_bytes += count;
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* we are done with this urb, so let the host driver
|
|
|
|
|
* really free it when it is finished with it */
|
2007-03-23 13:30:16 +00:00
|
|
|
usb_free_urb(urb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
dbg("%s write returning: %d", __FUNCTION__, count);
|
|
|
|
|
return count;
|
2007-03-23 13:30:16 +00:00
|
|
|
error:
|
|
|
|
|
usb_free_urb(urb);
|
|
|
|
|
error_no_urb:
|
|
|
|
|
kfree (buffer);
|
|
|
|
|
error_no_buffer:
|
|
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
priv->tx_outstanding_urbs--;
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
|
|
|
|
return count;
|
2005-04-16 22:20:36 +00:00
|
|
|
} /* ftdi_write */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* This function may get called when the device is closed */
|
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static void ftdi_write_bulk_callback (struct urb *urb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-26 11:59:17 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
|
2006-06-26 11:59:17 +00:00
|
|
|
struct ftdi_private *priv;
|
|
|
|
|
int data_offset; /* will be 1 for the SIO and 0 otherwise */
|
|
|
|
|
unsigned long countback;
|
2007-06-15 22:44:13 +00:00
|
|
|
int status = urb->status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* free up the transfer buffer, as usb_free_urb() does not do this */
|
|
|
|
|
kfree (urb->transfer_buffer);
|
|
|
|
|
|
|
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2007-06-15 22:44:13 +00:00
|
|
|
if (status) {
|
|
|
|
|
dbg("nonzero write bulk status received: %d", status);
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-26 11:59:17 +00:00
|
|
|
priv = usb_get_serial_port_data(port);
|
|
|
|
|
if (!priv) {
|
|
|
|
|
dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
/* account for transferred data */
|
|
|
|
|
countback = urb->actual_length;
|
|
|
|
|
data_offset = priv->write_offset;
|
|
|
|
|
if (data_offset > 0) {
|
|
|
|
|
/* Subtract the control bytes */
|
|
|
|
|
countback -= (data_offset * ((countback + (PKTSZ - 1)) / PKTSZ));
|
|
|
|
|
}
|
|
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
--priv->tx_outstanding_urbs;
|
|
|
|
|
priv->tx_outstanding_bytes -= countback;
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
|
|
|
|
|
2006-05-23 04:58:49 +00:00
|
|
|
usb_serial_port_softint(port);
|
2005-04-16 22:20:36 +00:00
|
|
|
} /* ftdi_write_bulk_callback */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ftdi_write_room( struct usb_serial_port *port )
|
|
|
|
|
{
|
2006-06-26 11:59:17 +00:00
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
int room;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
|
|
|
|
|
2006-06-26 11:59:17 +00:00
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
if (priv->tx_outstanding_urbs < URB_UPPER_LIMIT) {
|
|
|
|
|
/*
|
|
|
|
|
* We really can take anything the user throws at us
|
|
|
|
|
* but let's pick a nice big number to tell the tty
|
|
|
|
|
* layer that we have lots of free space
|
|
|
|
|
*/
|
|
|
|
|
room = 2048;
|
|
|
|
|
} else {
|
|
|
|
|
room = 0;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
|
|
|
|
return room;
|
2005-04-16 22:20:36 +00:00
|
|
|
} /* ftdi_write_room */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ftdi_chars_in_buffer (struct usb_serial_port *port)
|
|
|
|
|
{ /* ftdi_chars_in_buffer */
|
2006-06-26 11:59:17 +00:00
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
int buffered;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
|
|
|
|
|
2006-06-26 11:59:17 +00:00
|
|
|
spin_lock_irqsave(&priv->tx_lock, flags);
|
|
|
|
|
buffered = (int)priv->tx_outstanding_bytes;
|
|
|
|
|
spin_unlock_irqrestore(&priv->tx_lock, flags);
|
|
|
|
|
if (buffered < 0) {
|
|
|
|
|
err("%s outstanding tx bytes is negative!", __FUNCTION__);
|
|
|
|
|
buffered = 0;
|
|
|
|
|
}
|
|
|
|
|
return buffered;
|
2005-04-16 22:20:36 +00:00
|
|
|
} /* ftdi_chars_in_buffer */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static void ftdi_read_bulk_callback (struct urb *urb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* ftdi_read_bulk_callback */
|
|
|
|
|
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
|
|
|
|
|
struct tty_struct *tty;
|
|
|
|
|
struct ftdi_private *priv;
|
2006-06-26 11:59:17 +00:00
|
|
|
unsigned long countread;
|
|
|
|
|
unsigned long flags;
|
2007-06-15 22:44:13 +00:00
|
|
|
int status = urb->status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
if (urb->number_of_packets > 0) {
|
|
|
|
|
err("%s transfer_buffer_length %d actual_length %d number of packets %d",__FUNCTION__,
|
|
|
|
|
urb->transfer_buffer_length, urb->actual_length, urb->number_of_packets );
|
|
|
|
|
err("%s transfer_flags %x ", __FUNCTION__,urb->transfer_flags );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
|
|
|
|
|
|
|
|
|
if (port->open_count <= 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
tty = port->tty;
|
|
|
|
|
if (!tty) {
|
|
|
|
|
dbg("%s - bad tty pointer - exiting",__FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
priv = usb_get_serial_port_data(port);
|
|
|
|
|
if (!priv) {
|
|
|
|
|
dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (urb != port->read_urb) {
|
|
|
|
|
err("%s - Not my urb!", __FUNCTION__);
|
|
|
|
|
}
|
|
|
|
|
|
2007-06-15 22:44:13 +00:00
|
|
|
if (status) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* This will happen at close every time so it is a dbg not an err */
|
2007-06-15 22:44:13 +00:00
|
|
|
dbg("(this is ok on close) nonzero read bulk status received: "
|
|
|
|
|
"%d", status);
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-26 11:59:17 +00:00
|
|
|
/* count data bytes, but not status bytes */
|
|
|
|
|
countread = urb->actual_length;
|
|
|
|
|
countread -= 2 * ((countread + (PKTSZ - 1)) / PKTSZ);
|
|
|
|
|
spin_lock_irqsave(&priv->rx_lock, flags);
|
|
|
|
|
priv->rx_bytes += countread;
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
|
2006-11-22 14:57:56 +00:00
|
|
|
ftdi_process_read(&priv->rx_work.work);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
} /* ftdi_read_bulk_callback */
|
|
|
|
|
|
|
|
|
|
|
2006-11-22 14:57:56 +00:00
|
|
|
static void ftdi_process_read (struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* ftdi_process_read */
|
2006-11-22 14:57:56 +00:00
|
|
|
struct ftdi_private *priv =
|
|
|
|
|
container_of(work, struct ftdi_private, rx_work.work);
|
|
|
|
|
struct usb_serial_port *port = priv->port;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct urb *urb;
|
|
|
|
|
struct tty_struct *tty;
|
|
|
|
|
char error_flag;
|
2006-10-13 22:57:58 +00:00
|
|
|
unsigned char *data;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
int i;
|
|
|
|
|
int result;
|
|
|
|
|
int need_flip;
|
|
|
|
|
int packet_offset;
|
2005-06-02 09:34:11 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
|
|
|
|
|
|
|
|
|
if (port->open_count <= 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
tty = port->tty;
|
|
|
|
|
if (!tty) {
|
|
|
|
|
dbg("%s - bad tty pointer - exiting",__FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
priv = usb_get_serial_port_data(port);
|
|
|
|
|
if (!priv) {
|
|
|
|
|
dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
urb = port->read_urb;
|
|
|
|
|
if (!urb) {
|
|
|
|
|
dbg("%s - bad read_urb pointer - exiting", __FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
data = urb->transfer_buffer;
|
|
|
|
|
|
2005-06-02 09:34:11 +00:00
|
|
|
if (priv->rx_processed) {
|
|
|
|
|
dbg("%s - already processed: %d bytes, %d remain", __FUNCTION__,
|
|
|
|
|
priv->rx_processed,
|
|
|
|
|
urb->actual_length - priv->rx_processed);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2005-06-02 09:34:11 +00:00
|
|
|
/* The first two bytes of every read packet are status */
|
|
|
|
|
if (urb->actual_length > 2) {
|
|
|
|
|
usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
|
|
|
|
|
} else {
|
|
|
|
|
dbg("Status only: %03oo %03oo",data[0],data[1]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/* TO DO -- check for hung up line and handle appropriately: */
|
|
|
|
|
/* send hangup */
|
|
|
|
|
/* See acm.c - you do a tty_hangup - eg tty_hangup(tty) */
|
|
|
|
|
/* if CD is dropped and the line is not CLOCAL then we should hangup */
|
|
|
|
|
|
|
|
|
|
need_flip = 0;
|
2005-06-02 09:34:11 +00:00
|
|
|
for (packet_offset = priv->rx_processed; packet_offset < urb->actual_length; packet_offset += PKTSZ) {
|
|
|
|
|
int length;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Compare new line status to the old one, signal if different */
|
2005-06-02 09:34:11 +00:00
|
|
|
/* N.B. packet may be processed more than once, but differences
|
|
|
|
|
* are only processed once. */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (priv != NULL) {
|
|
|
|
|
char new_status = data[packet_offset+0] & FTDI_STATUS_B0_MASK;
|
|
|
|
|
if (new_status != priv->prev_status) {
|
|
|
|
|
priv->diff_status |= new_status ^ priv->prev_status;
|
|
|
|
|
wake_up_interruptible(&priv->delta_msr_wait);
|
|
|
|
|
priv->prev_status = new_status;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-02 09:34:11 +00:00
|
|
|
length = min(PKTSZ, urb->actual_length-packet_offset)-2;
|
|
|
|
|
if (length < 0) {
|
|
|
|
|
err("%s - bad packet length: %d", __FUNCTION__, length+2);
|
|
|
|
|
length = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (priv->rx_flags & THROTTLED) {
|
|
|
|
|
dbg("%s - throttled", __FUNCTION__);
|
|
|
|
|
break;
|
|
|
|
|
}
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 04:54:13 +00:00
|
|
|
if (tty_buffer_request_room(tty, length) < length) {
|
2005-06-02 09:34:11 +00:00
|
|
|
/* break out & wait for throttling/unthrottling to happen */
|
|
|
|
|
dbg("%s - receive room low", __FUNCTION__);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Handle errors and break */
|
|
|
|
|
error_flag = TTY_NORMAL;
|
|
|
|
|
/* Although the device uses a bitmask and hence can have multiple */
|
|
|
|
|
/* errors on a packet - the order here sets the priority the */
|
|
|
|
|
/* error is returned to the tty layer */
|
|
|
|
|
|
|
|
|
|
if ( data[packet_offset+1] & FTDI_RS_OE ) {
|
|
|
|
|
error_flag = TTY_OVERRUN;
|
|
|
|
|
dbg("OVERRRUN error");
|
|
|
|
|
}
|
|
|
|
|
if ( data[packet_offset+1] & FTDI_RS_BI ) {
|
|
|
|
|
error_flag = TTY_BREAK;
|
|
|
|
|
dbg("BREAK received");
|
|
|
|
|
}
|
|
|
|
|
if ( data[packet_offset+1] & FTDI_RS_PE ) {
|
|
|
|
|
error_flag = TTY_PARITY;
|
|
|
|
|
dbg("PARITY error");
|
|
|
|
|
}
|
|
|
|
|
if ( data[packet_offset+1] & FTDI_RS_FE ) {
|
|
|
|
|
error_flag = TTY_FRAME;
|
|
|
|
|
dbg("FRAMING error");
|
|
|
|
|
}
|
2005-06-02 09:34:11 +00:00
|
|
|
if (length > 0) {
|
|
|
|
|
for (i = 2; i < length+2; i++) {
|
2006-10-13 22:57:58 +00:00
|
|
|
/* Note that the error flag is duplicated for
|
2005-04-16 22:20:36 +00:00
|
|
|
every character received since we don't know
|
|
|
|
|
which character it applied to */
|
|
|
|
|
tty_insert_flip_char(tty, data[packet_offset+i], error_flag);
|
|
|
|
|
}
|
|
|
|
|
need_flip = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef NOT_CORRECT_BUT_KEEPING_IT_FOR_NOW
|
|
|
|
|
/* if a parity error is detected you get status packets forever
|
|
|
|
|
until a character is sent without a parity error.
|
|
|
|
|
This doesn't work well since the application receives a never
|
|
|
|
|
ending stream of bad data - even though new data hasn't been sent.
|
|
|
|
|
Therefore I (bill) have taken this out.
|
2006-10-13 22:57:58 +00:00
|
|
|
However - this might make sense for framing errors and so on
|
2005-04-16 22:20:36 +00:00
|
|
|
so I am leaving the code in for now.
|
|
|
|
|
*/
|
|
|
|
|
else {
|
|
|
|
|
if (error_flag != TTY_NORMAL){
|
|
|
|
|
dbg("error_flag is not normal");
|
|
|
|
|
/* In this case it is just status - if that is an error send a bad character */
|
|
|
|
|
if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
|
|
|
|
|
tty_flip_buffer_push(tty);
|
|
|
|
|
}
|
|
|
|
|
tty_insert_flip_char(tty, 0xff, error_flag);
|
|
|
|
|
need_flip = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
} /* "for(packet_offset=0..." */
|
|
|
|
|
|
|
|
|
|
/* Low latency */
|
|
|
|
|
if (need_flip) {
|
|
|
|
|
tty_flip_buffer_push(tty);
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-02 09:34:11 +00:00
|
|
|
if (packet_offset < urb->actual_length) {
|
|
|
|
|
/* not completely processed - record progress */
|
|
|
|
|
priv->rx_processed = packet_offset;
|
|
|
|
|
dbg("%s - incomplete, %d bytes processed, %d remain",
|
|
|
|
|
__FUNCTION__, packet_offset,
|
|
|
|
|
urb->actual_length - packet_offset);
|
|
|
|
|
/* check if we were throttled while processing */
|
|
|
|
|
spin_lock_irqsave(&priv->rx_lock, flags);
|
|
|
|
|
if (priv->rx_flags & THROTTLED) {
|
|
|
|
|
priv->rx_flags |= ACTUALLY_THROTTLED;
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
dbg("%s - deferring remainder until unthrottled",
|
|
|
|
|
__FUNCTION__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
/* if the port is closed stop trying to read */
|
|
|
|
|
if (port->open_count > 0){
|
|
|
|
|
/* delay processing of remainder */
|
|
|
|
|
schedule_delayed_work(&priv->rx_work, 1);
|
|
|
|
|
} else {
|
|
|
|
|
dbg("%s - port is closed", __FUNCTION__);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* urb is completely processed */
|
|
|
|
|
priv->rx_processed = 0;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* if the port is closed stop trying to read */
|
|
|
|
|
if (port->open_count > 0){
|
|
|
|
|
/* Continue trying to always read */
|
2006-10-13 22:57:58 +00:00
|
|
|
usb_fill_bulk_urb(port->read_urb, port->serial->dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_rcvbulkpipe(port->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, GFP_ATOMIC);
|
|
|
|
|
if (result)
|
|
|
|
|
err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
} /* ftdi_process_read */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2006-10-13 22:57:58 +00:00
|
|
|
__u16 urb_value = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
char buf[1];
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* break_state = -1 to turn on break, and 0 to turn off break */
|
|
|
|
|
/* see drivers/char/tty_io.c to see it used */
|
|
|
|
|
/* last_set_data_urb_value NEVER has the break bit set in it */
|
|
|
|
|
|
|
|
|
|
if (break_state) {
|
|
|
|
|
urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
|
|
|
|
|
} else {
|
2006-10-13 22:57:58 +00:00
|
|
|
urb_value = priv->last_set_data_urb_value;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_SET_DATA_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_DATA_REQUEST_TYPE,
|
|
|
|
|
urb_value , priv->interface,
|
|
|
|
|
buf, 0, WDR_TIMEOUT) < 0) {
|
|
|
|
|
err("%s FAILED to enable/disable break state (state was %d)", __FUNCTION__,break_state);
|
2006-10-13 22:57:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
dbg("%s break state is %d - urb is %d", __FUNCTION__,break_state, urb_value);
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* old_termios contains the original termios settings and tty->termios contains
|
|
|
|
|
* the new setting to be used
|
|
|
|
|
* WARNING: set_termios calls this with old_termios in kernel space
|
|
|
|
|
*/
|
|
|
|
|
|
2006-12-08 10:38:45 +00:00
|
|
|
static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* ftdi_termios */
|
|
|
|
|
struct usb_device *dev = port->serial->dev;
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
2007-10-18 08:24:24 +00:00
|
|
|
struct ktermios *termios = port->tty->termios;
|
|
|
|
|
unsigned int cflag = termios->c_cflag;
|
2005-04-16 22:20:36 +00:00
|
|
|
__u16 urb_value; /* will hold the new flags */
|
|
|
|
|
char buf[1]; /* Perhaps I should dynamically alloc this? */
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
// Added for xon/xoff support
|
2007-10-18 08:24:24 +00:00
|
|
|
unsigned int iflag = termios->c_iflag;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char vstop;
|
|
|
|
|
unsigned char vstart;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s", __FUNCTION__);
|
|
|
|
|
|
|
|
|
|
/* Force baud rate if this device requires it, unless it is set to B0. */
|
2007-10-18 08:24:24 +00:00
|
|
|
if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dbg("%s: forcing baud rate for this device", __FUNCTION__);
|
2007-10-18 08:24:25 +00:00
|
|
|
tty_encode_baud_rate(port->tty, priv->force_baud,
|
|
|
|
|
priv->force_baud);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Force RTS-CTS if this device requires it. */
|
|
|
|
|
if (priv->force_rtscts) {
|
|
|
|
|
dbg("%s: forcing rtscts for this device", __FUNCTION__);
|
2007-10-18 08:24:24 +00:00
|
|
|
termios->c_cflag |= CRTSCTS;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
2007-10-18 08:24:24 +00:00
|
|
|
cflag = termios->c_cflag;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
/* FIXME -For this cut I don't care if the line is really changing or
|
|
|
|
|
not - so just do the change regardless - should be able to
|
2005-04-16 22:20:36 +00:00
|
|
|
compare old_termios and tty->termios */
|
2006-10-13 22:57:58 +00:00
|
|
|
/* NOTE These routines can get interrupted by
|
|
|
|
|
ftdi_sio_read_bulk_callback - need to examine what this
|
2005-04-16 22:20:36 +00:00
|
|
|
means - don't see any problems yet */
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set number of data bits, parity, stop bits */
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2007-10-18 08:24:24 +00:00
|
|
|
termios->c_cflag &= ~CMSPAR;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
urb_value = 0;
|
|
|
|
|
urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
|
|
|
|
|
FTDI_SIO_SET_DATA_STOP_BITS_1);
|
2006-10-13 22:57:58 +00:00
|
|
|
urb_value |= (cflag & PARENB ?
|
|
|
|
|
(cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_DATA_PARITY_EVEN) :
|
|
|
|
|
FTDI_SIO_SET_DATA_PARITY_NONE);
|
|
|
|
|
if (cflag & CSIZE) {
|
|
|
|
|
switch (cflag & CSIZE) {
|
|
|
|
|
case CS5: urb_value |= 5; dbg("Setting CS5"); break;
|
|
|
|
|
case CS6: urb_value |= 6; dbg("Setting CS6"); break;
|
|
|
|
|
case CS7: urb_value |= 7; dbg("Setting CS7"); break;
|
|
|
|
|
case CS8: urb_value |= 8; dbg("Setting CS8"); break;
|
|
|
|
|
default:
|
|
|
|
|
err("CSIZE was set but not CS5-CS8");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is needed by the break command since it uses the same command - but is
|
|
|
|
|
* or'ed with this value */
|
|
|
|
|
priv->last_set_data_urb_value = urb_value;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_SET_DATA_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_DATA_REQUEST_TYPE,
|
|
|
|
|
urb_value , priv->interface,
|
2005-07-29 19:16:52 +00:00
|
|
|
buf, 0, WDR_SHORT_TIMEOUT) < 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
err("%s FAILED to set databits/stopbits/parity", __FUNCTION__);
|
2006-10-13 22:57:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* Now do the baudrate */
|
|
|
|
|
if ((cflag & CBAUD) == B0 ) {
|
|
|
|
|
/* Disable flow control */
|
|
|
|
|
if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
0, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 0, WDR_TIMEOUT) < 0) {
|
|
|
|
|
err("%s error from disable flowcontrol urb", __FUNCTION__);
|
2006-10-13 22:57:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Drop RTS and DTR */
|
2005-07-29 19:16:41 +00:00
|
|
|
clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
|
/* set the baudrate determined before */
|
|
|
|
|
if (change_speed(port)) {
|
2005-09-22 07:48:49 +00:00
|
|
|
err("%s urb failed to set baudrate", __FUNCTION__);
|
|
|
|
|
}
|
|
|
|
|
/* Ensure RTS and DTR are raised when baudrate changed from 0 */
|
2006-04-13 20:27:12 +00:00
|
|
|
if (!old_termios || (old_termios->c_cflag & CBAUD) == B0) {
|
2005-09-22 07:48:49 +00:00
|
|
|
set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set flow control */
|
|
|
|
|
/* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
|
|
|
|
|
if (cflag & CRTSCTS) {
|
|
|
|
|
dbg("%s Setting to CRTSCTS flow control", __FUNCTION__);
|
2006-10-13 22:57:58 +00:00
|
|
|
if (usb_control_msg(dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_sndctrlpipe(dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
|
|
|
|
|
0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
|
|
|
|
|
buf, 0, WDR_TIMEOUT) < 0) {
|
|
|
|
|
err("urb failed to set to rts/cts flow control");
|
2006-10-13 22:57:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Xon/Xoff code
|
|
|
|
|
*
|
|
|
|
|
* Check the IXOFF status in the iflag component of the termios structure
|
|
|
|
|
* if IXOFF is not set, the pre-xon/xoff code is executed.
|
|
|
|
|
*/
|
|
|
|
|
if (iflag & IXOFF) {
|
|
|
|
|
dbg("%s request to enable xonxoff iflag=%04x",__FUNCTION__,iflag);
|
|
|
|
|
// Try to enable the XON/XOFF on the ftdi_sio
|
|
|
|
|
// Set the vstart and vstop -- could have been done up above where
|
|
|
|
|
// a lot of other dereferencing is done but that would be very
|
|
|
|
|
// inefficient as vstart and vstop are not always needed
|
2007-10-18 08:24:24 +00:00
|
|
|
vstart = termios->c_cc[VSTART];
|
|
|
|
|
vstop = termios->c_cc[VSTOP];
|
2005-04-16 22:20:36 +00:00
|
|
|
urb_value=(vstop << 8) | (vstart);
|
|
|
|
|
|
|
|
|
|
if (usb_control_msg(dev,
|
|
|
|
|
usb_sndctrlpipe(dev, 0),
|
|
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST,
|
|
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
|
|
|
|
|
urb_value , (FTDI_SIO_XON_XOFF_HS
|
|
|
|
|
| priv->interface),
|
|
|
|
|
buf, 0, WDR_TIMEOUT) < 0) {
|
|
|
|
|
err("urb failed to set to xon/xoff flow control");
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* else clause to only run if cfag ! CRTSCTS and iflag ! XOFF */
|
|
|
|
|
/* CHECKME Assuming XON/XOFF handled by tty stack - not by device */
|
|
|
|
|
dbg("%s Turning off hardware flow control", __FUNCTION__);
|
2006-10-13 22:57:58 +00:00
|
|
|
if (usb_control_msg(dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_sndctrlpipe(dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
0, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 0, WDR_TIMEOUT) < 0) {
|
|
|
|
|
err("urb failed to clear flow control");
|
2006-10-13 22:57:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
} /* ftdi_termios */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
unsigned char buf[2];
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
dbg("%s TIOCMGET", __FUNCTION__);
|
|
|
|
|
switch (priv->chip_type) {
|
|
|
|
|
case SIO:
|
|
|
|
|
/* Request the status from the device */
|
2006-10-13 22:57:58 +00:00
|
|
|
if ((ret = usb_control_msg(port->serial->dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_rcvctrlpipe(port->serial->dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_GET_MODEM_STATUS_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
0, 0,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 1, WDR_TIMEOUT)) < 0 ) {
|
|
|
|
|
err("%s Could not get modem status of device - err: %d", __FUNCTION__,
|
|
|
|
|
ret);
|
|
|
|
|
return(ret);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case FT8U232AM:
|
|
|
|
|
case FT232BM:
|
|
|
|
|
case FT2232C:
|
2007-08-21 18:08:56 +00:00
|
|
|
case FT232RL:
|
2005-04-16 22:20:36 +00:00
|
|
|
/* the 8U232AM returns a two byte value (the sio is a 1 byte value) - in the same
|
|
|
|
|
format as the data returned from the in point */
|
2006-10-13 22:57:58 +00:00
|
|
|
if ((ret = usb_control_msg(port->serial->dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_rcvctrlpipe(port->serial->dev, 0),
|
2006-10-13 22:57:58 +00:00
|
|
|
FTDI_SIO_GET_MODEM_STATUS_REQUEST,
|
2005-04-16 22:20:36 +00:00
|
|
|
FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
|
2006-10-13 22:57:58 +00:00
|
|
|
0, priv->interface,
|
2005-04-16 22:20:36 +00:00
|
|
|
buf, 2, WDR_TIMEOUT)) < 0 ) {
|
|
|
|
|
err("%s Could not get modem status of device - err: %d", __FUNCTION__,
|
|
|
|
|
ret);
|
|
|
|
|
return(ret);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
|
|
|
|
|
(buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
|
|
|
|
|
(buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
|
|
|
|
|
(buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
|
2006-10-13 22:57:58 +00:00
|
|
|
priv->last_dtr_rts;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
|
|
|
|
|
{
|
|
|
|
|
dbg("%s TIOCMSET", __FUNCTION__);
|
2005-07-29 19:16:41 +00:00
|
|
|
return update_mctrl(port, set, clear);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
|
|
dbg("%s cmd 0x%04x", __FUNCTION__, cmd);
|
|
|
|
|
|
|
|
|
|
/* Based on code from acm.c and others */
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
|
|
|
|
|
case TIOCGSERIAL: /* gets serial port data */
|
|
|
|
|
return get_serial_info(port, (struct serial_struct __user *) arg);
|
|
|
|
|
|
|
|
|
|
case TIOCSSERIAL: /* sets serial port data */
|
|
|
|
|
return set_serial_info(port, (struct serial_struct __user *) arg);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
|
|
|
|
|
* - mask passed in arg for lines of interest
|
|
|
|
|
* (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
|
|
|
|
|
* Caller should use TIOCGICOUNT to see which one it was.
|
|
|
|
|
*
|
|
|
|
|
* This code is borrowed from linux/drivers/char/serial.c
|
|
|
|
|
*/
|
|
|
|
|
case TIOCMIWAIT:
|
|
|
|
|
while (priv != NULL) {
|
|
|
|
|
interruptible_sleep_on(&priv->delta_msr_wait);
|
|
|
|
|
/* see if a signal did it */
|
|
|
|
|
if (signal_pending(current))
|
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
|
else {
|
|
|
|
|
char diff = priv->diff_status;
|
|
|
|
|
|
|
|
|
|
if (diff == 0) {
|
|
|
|
|
return -EIO; /* no change => error */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Consume all events */
|
|
|
|
|
priv->diff_status = 0;
|
|
|
|
|
|
|
|
|
|
/* Return 0 if caller wanted to know about these bits */
|
|
|
|
|
if ( ((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
|
|
|
|
|
((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
|
|
|
|
|
((arg & TIOCM_CD) && (diff & FTDI_RS0_RLSD)) ||
|
|
|
|
|
((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS)) ) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* Otherwise caller can't care less about what happened,
|
|
|
|
|
* and so we continue to wait for more events.
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return(0);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
2006-10-13 22:57:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-13 22:57:58 +00:00
|
|
|
/* This is not necessarily an error - turns out the higher layers will do
|
2005-04-16 22:20:36 +00:00
|
|
|
* some ioctls itself (see comment above)
|
|
|
|
|
*/
|
|
|
|
|
dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __FUNCTION__, cmd);
|
|
|
|
|
|
|
|
|
|
return(-ENOIOCTLCMD);
|
|
|
|
|
} /* ftdi_ioctl */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void ftdi_throttle (struct usb_serial_port *port)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->rx_lock, flags);
|
|
|
|
|
priv->rx_flags |= THROTTLED;
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void ftdi_unthrottle (struct usb_serial_port *port)
|
|
|
|
|
{
|
|
|
|
|
struct ftdi_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
int actually_throttled;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
dbg("%s - port %d", __FUNCTION__, port->number);
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->rx_lock, flags);
|
|
|
|
|
actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
|
|
|
|
|
priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
|
|
|
|
|
spin_unlock_irqrestore(&priv->rx_lock, flags);
|
|
|
|
|
|
|
|
|
|
if (actually_throttled)
|
2006-11-22 14:57:56 +00:00
|
|
|
schedule_delayed_work(&priv->rx_work, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init ftdi_init (void)
|
|
|
|
|
{
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
dbg("%s", __FUNCTION__);
|
2005-07-28 17:40:32 +00:00
|
|
|
if (vendor > 0 && product > 0) {
|
|
|
|
|
/* Add user specified VID/PID to reserved element of table. */
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; id_table_combined[i].idVendor; i++)
|
|
|
|
|
;
|
|
|
|
|
id_table_combined[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
|
|
|
|
|
id_table_combined[i].idVendor = vendor;
|
|
|
|
|
id_table_combined[i].idProduct = product;
|
|
|
|
|
}
|
2005-06-20 15:45:42 +00:00
|
|
|
retval = usb_serial_register(&ftdi_sio_device);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (retval)
|
2005-06-20 15:45:42 +00:00
|
|
|
goto failed_sio_register;
|
2005-04-16 22:20:36 +00:00
|
|
|
retval = usb_register(&ftdi_driver);
|
2006-10-13 22:57:58 +00:00
|
|
|
if (retval)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto failed_usb_register;
|
|
|
|
|
|
|
|
|
|
info(DRIVER_VERSION ":" DRIVER_DESC);
|
|
|
|
|
return 0;
|
|
|
|
|
failed_usb_register:
|
2005-06-20 15:45:42 +00:00
|
|
|
usb_serial_deregister(&ftdi_sio_device);
|
|
|
|
|
failed_sio_register:
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void __exit ftdi_exit (void)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
dbg("%s", __FUNCTION__);
|
|
|
|
|
|
|
|
|
|
usb_deregister (&ftdi_driver);
|
2005-06-20 15:45:42 +00:00
|
|
|
usb_serial_deregister (&ftdi_sio_device);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
module_init(ftdi_init);
|
|
|
|
|
module_exit(ftdi_exit);
|
|
|
|
|
|
|
|
|
|
MODULE_AUTHOR( DRIVER_AUTHOR );
|
|
|
|
|
MODULE_DESCRIPTION( DRIVER_DESC );
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
|
|
module_param(debug, bool, S_IRUGO | S_IWUSR);
|
|
|
|
|
MODULE_PARM_DESC(debug, "Debug enabled or not");
|
2005-07-28 17:40:32 +00:00
|
|
|
module_param(vendor, ushort, 0);
|
|
|
|
|
MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
|
|
|
|
|
__MODULE_STRING(FTDI_VID)")");
|
|
|
|
|
module_param(product, ushort, 0);
|
|
|
|
|
MODULE_PARM_DESC(vendor, "User specified product ID");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
![](/avatar/362e80bc9fa0d4c6d6e2a8a86ae5d0d0?size=36 "Neil \\"Superna\\" ARMSTRONG"){kind=small}
