path: root/drivers/usb/serial/keyspan.h

/*
  Keyspan USB to Serial Converter driver
 
  (C) Copyright (C) 2000
      Hugh Blemings <hugh@linuxcare.com>
   
  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.

  See http://www.linuxcare.com.au/hugh/keyspan.html for more
  information on this driver.
  
  Code in this driver inspired by and in a number of places taken
  from Brian Warner's original Keyspan-PDA driver.

  This driver has been put together with the support of Innosys, Inc.
  and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
  Thanks Guys :)
  
  Thanks to Paulus for miscellaneous tidy ups, some largish chunks
  of much nicer and/or completely new code and (perhaps most uniquely)
  having the patience to sit down and explain why and where he'd changed
  stuff.

  Tip 'o the hat to Linuxcare for supporting staff in their work on
  open source projects.
  
  See keyspan.c for update history.

*/

#ifndef __LINUX_USB_SERIAL_KEYSPAN_H
#define __LINUX_USB_SERIAL_KEYSPAN_H

#include <linux/config.h>

	/* Function prototypes for Keyspan serial converter */
static int  keyspan_open		(struct usb_serial_port *port,
					 struct file *filp);
static void keyspan_close		(struct usb_serial_port *port,
					 struct file *filp);
static int  keyspan_startup		(struct usb_serial *serial);
static void keyspan_shutdown		(struct usb_serial *serial);
static void keyspan_rx_throttle		(struct usb_serial_port *port);
static void keyspan_rx_unthrottle	(struct usb_serial_port *port);
static int  keyspan_write_room		(struct usb_serial_port *port);

static int  keyspan_write		(struct usb_serial_port *port,
					 int from_user,
					 const unsigned char *buf,
					 int count);

#if 0
static void keyspan_write_bulk_callback (struct urb *urb);
#endif

//static void keyspan_usa26_read_int_callback  (struct urb *urb);
//static void keyspan_usa28_read_int_callback  (struct urb *urb);
static int  keyspan_chars_in_buffer 	(struct usb_serial_port *port);
static int  keyspan_ioctl		(struct usb_serial_port *port,
					 struct file *file,
					 unsigned int cmd,
					 unsigned long arg);
static void keyspan_set_termios		(struct usb_serial_port *port,
					 struct termios *old);
static void keyspan_break_ctl		(struct usb_serial_port *port,
					 int break_state);
static int  keyspan_fake_startup	(struct usb_serial *serial);

static int  keyspan_usa19_calc_baud	(u32 baud_rate, u32 baudclk, 
					 u8 *rate_hi, u8 *rate_low, u8 *prescaler);

static int  keyspan_usa19w_calc_baud	(u32 baud_rate, u32 baudclk,
					 u8 *rate_hi, u8 *rate_low, u8 *prescaler);

//static void keyspan_usa19_setup_urbs	(struct usb_serial *serial);

static int  keyspan_usa28_send_setup	(struct usb_serial *serial,
					 struct usb_serial_port *port);
static int  keyspan_usa26_send_setup	(struct usb_serial *serial,
	       				 struct usb_serial_port *port);
static int  keyspan_usa49_send_setup	(struct usb_serial *serial,
					 struct usb_serial_port *port);

	/* Functions from usbserial.c for ezusb firmware handling */
extern int ezusb_set_reset (struct usb_serial *serial, unsigned char reset_bit);
extern int ezusb_writememory (struct usb_serial *serial, int address, unsigned char *data, int length, __u8 bRequest);

	/* Struct used for firmware */
struct ezusb_hex_record {
	__u16 address;
	__u8 data_size;
	__u8 data[16];
};
	/* Conditionally include firmware images, if they aren't
	   included create a null pointer instead.  Current 
	   firmware images aren't optimised to remove duplicate
	   addresses. */
#ifdef CONFIG_USB_SERIAL_KEYSPAN_USA28
        #include "keyspan_usa28_fw.h"
#else
	static const struct ezusb_hex_record *keyspan_usa28_firmware = NULL;
#endif

#ifdef CONFIG_USB_SERIAL_KEYSPAN_USA28X
        #include "keyspan_usa28x_fw.h"
#else
	static const struct ezusb_hex_record *keyspan_usa28x_firmware = NULL;
#endif

#ifdef CONFIG_USB_SERIAL_KEYSPAN_USA19
        #include "keyspan_usa19_fw.h"
#else
	static const struct ezusb_hex_record *keyspan_usa19_firmware = NULL;
#endif

#ifdef CONFIG_USB_SERIAL_KEYSPAN_USA18X
        #include "keyspan_usa18x_fw.h"
#else
	static const struct ezusb_hex_record *keyspan_usa18x_firmware = NULL;
#endif

#ifdef CONFIG_USB_SERIAL_KEYSPAN_USA19W
        #include "keyspan_usa19w_fw.h"
#else
	static const struct ezusb_hex_record *keyspan_usa19w_firmware = NULL;
#endif

#ifdef CONFIG_USB_SERIAL_KEYSPAN_USA49W
        #include "keyspan_usa49w_fw.h"
#else
	static const struct ezusb_hex_record *keyspan_usa49w_firmware = NULL;
#endif
	
	/* Values used for baud rate calculation - device specific */
#define	KEYSPAN_INVALID_BAUD_RATE		(-1)
#define	KEYSPAN_BAUD_RATE_OK			(0)
#define	KEYSPAN_USA18X_BAUDCLK			(12000000L)	/* a guess */
#define	KEYSPAN_USA19_BAUDCLK			(12000000L)
#define	KEYSPAN_USA19W_BAUDCLK			(24000000L)
#define	KEYSPAN_USA28X_BAUDCLK			(12000000L)
#define	KEYSPAN_USA49W_BAUDCLK			(48000000L)

	/* Some constants used to characterise each device. 
	   There is a four port device due later in the year,
	   we allow for it now in the following */
#define		KEYSPAN_MAX_NUM_PORTS		(4)
#define		KEYSPAN_MAX_FLIPS		(2)
	
typedef struct {
	/* product ID value */
	int	product_id;
	
	enum	{msg_usa26, msg_usa28, msg_usa49} msg_format;

		/* Number of physical ports */
	int	num_ports;

		/* 1 if endpoint flipping used on input, 0 if not */
	int	indat_endp_flip;

		/* 1 if endpoint flipping used on output, 0 if not */
	int 	outdat_endp_flip;

		/* Table mapping input data endpoint IDs to physical
		   port number and flip if used */
	int	indat_endpoints[KEYSPAN_MAX_NUM_PORTS];

		/* Same for output endpoints */
	int	outdat_endpoints[KEYSPAN_MAX_NUM_PORTS];

		/* Input acknowledge endpoints */
	int	inack_endpoints[KEYSPAN_MAX_NUM_PORTS];

		/* Output control endpoints */	
	int	outcont_endpoints[KEYSPAN_MAX_NUM_PORTS];

		/* Endpoint used for input status */
	int	instat_endpoint;

		/* Endpoint used for global control functions */
	int	glocont_endpoint;	
	
	int	(*calculate_baud_rate) (u32 baud_rate, u32 baudclk,
			u8 *rate_hi, u8 *rate_low, u8 *prescaler);
	u32	baudclk;

} keyspan_device_details; 

	/* Now for each device type we setup the device detail
	   structure with the appropriate information (provided
	   in Keyspan's documentation) */

static const keyspan_device_details usa18x_device_details = {
	0x112,				/* product ID */
       	msg_usa26, 			/* msg type*/
	1,				/* num ports */
	0,				/* indat endpoint flip */
	1,				/* outdat endpoint flip */
  	{0x81},				/* per port indat */
  	{0x01},				/* per port outdat */
	{0x85},				/* per port inack */
	{0x05},				/* per port outcont */
	0x87,				/* instat endpoint */
	0x07,				/* glocont endpoint */
	keyspan_usa19w_calc_baud,	/* calc baud rate */
	KEYSPAN_USA18X_BAUDCLK		/* base baud clock */
};

static const keyspan_device_details usa19_device_details = {
	0x107,				/* product ID */
       	msg_usa28, 			/* msg type*/
	1,				/* num ports */
	1,				/* indat endpoint flip */
	1,				/* outdat endpoint flip */
  	{0x81},				/* per port indat */
  	{0x01},				/* per port outdat */
	{0x83},				/* per port inack */
	{0x03},				/* per port outcont */
	0x84,				/* instat endpoint */
	-1,				/* glocont endpoint */
	keyspan_usa19_calc_baud,	/* calc baud rate */
	KEYSPAN_USA19_BAUDCLK		/* base baud clock */
};

static const keyspan_device_details usa19w_device_details = {
	0x108,				/* product ID */
       	msg_usa26, 			/* msg type*/
	1,				/* num ports */
	0,				/* indat endpoint flip */
	1,				/* outdat endpoint flip */
  	{0x81},				/* per port indat */
  	{0x01},				/* per port outdat */
	{0x85},				/* per port inack */
	{0x05},				/* per port outcont */
	0x87,				/* instat endpoint */
	0x07,				/* glocont endpoint */
	keyspan_usa19w_calc_baud,	/* calc baud rate */
	KEYSPAN_USA19W_BAUDCLK		/* base baud clock */
};

static const keyspan_device_details usa28x_device_details = {
	0x110,				/* product ID */
       	msg_usa26, 			/* msg type*/
	2,				/* num ports */
	0,				/* indat endpoint flip */
	1,				/* outdat endpoint flip */
  	{0x81, 0x83},			/* per port indat */
  	{0x01, 0x03},			/* per port outdat */
	{0x85, 0x86},			/* per port inack */
	{0x05, 0x06},			/* per port outcont */
	0x87,				/* instat endpoint */
	0x07,				/* glocont endpoint */
	keyspan_usa19w_calc_baud,	/* calc baud rate */
	KEYSPAN_USA28X_BAUDCLK
};

static const keyspan_device_details usa49w_device_details = {
	0x010a,				/* product ID */
       	msg_usa49, 			/* msg type*/
	4,				/* num ports */
	0,				/* indat endpoint flip */
	0,				/* outdat endpoint flip */
  	{ 0x81, 0x82, 0x83, 0x84},	/* per port indat */
  	{ 0x01, 0x02, 0x03, 0x04},	/* per port outdat */
	{-1, -1, -1, -1},		/* per port inack */
	{-1, -1, -1, -1},		/* per port outcont */
	0x87,				/* instat endpoint */
	0x07,				/* glocont endpoint */
	keyspan_usa19w_calc_baud,	/* calc baud rate */
	KEYSPAN_USA49W_BAUDCLK
};

static const keyspan_device_details *keyspan_devices[] = {
	&usa18x_device_details,
	&usa19_device_details,
	&usa19w_device_details,
	&usa28x_device_details,
	&usa49w_device_details,
	NULL
};

	/* Device info for the Keyspan serial converter, used
	   by the overall usb-serial probe function */
#define KEYSPAN_VENDOR_ID			(0x06cd)

    /* Product IDs for the five products supported, pre-renumeration */
#define	keyspan_usa18x_pre_product_id	0x0105
#define	keyspan_usa19_pre_product_id	0x0103
#define	keyspan_usa19w_pre_product_id	0x0106
#define	keyspan_usa28_pre_product_id	0x0101
#define	keyspan_usa28x_pre_product_id	0x0102
#define	keyspan_usa49w_pre_product_id	0x0109

    /* Product IDs post-renumeration */
#define	keyspan_usa18x_product_id	0x0112
#define	keyspan_usa19_product_id	0x0107
#define	keyspan_usa19w_product_id	0x0108
#define	keyspan_usa28_product_id	0x010f
#define	keyspan_usa28x_product_id	0x0110
#define	keyspan_usa49w_product_id	0x010a

static __devinitdata struct usb_device_id keyspan_ids_combined[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa18x_pre_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19_pre_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19w_pre_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28_pre_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28x_pre_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa49w_pre_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa18x_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19w_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28x_product_id},
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa49w_product_id},
    { } /* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, keyspan_ids_combined);

/* Eventually, we will not need separate id tables for each USB
   ID pattern.  But, for now, it looks like we need slightly different
   behavior for each match. */

static __devinitdata struct usb_device_id keyspan_usa18x_pre_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa18x_pre_product_id},
    { }	/* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa19_pre_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19_pre_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa19w_pre_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19w_pre_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa28_pre_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28_pre_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa28x_pre_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28x_pre_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa49w_pre_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa49w_pre_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa18x_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa18x_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa19_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa19w_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa19w_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa28_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa28x_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa28x_product_id},
    { } /* Terminating entry */
};

static __devinitdata struct usb_device_id keyspan_usa49w_ids[] = {
    {idVendor: KEYSPAN_VENDOR_ID, idProduct: keyspan_usa49w_product_id},
    { } /* Terminating entry */
};

    /* Structs for the devices, pre and post renumeration.
       These are incomplete at present - HAB 20000708  */
struct usb_serial_device_type keyspan_usa18x_pre_device = {
	name:			"Keyspan USA18X - (without firmware)",
	id_table:		keyspan_usa18x_pre_ids,
	needs_interrupt_in:	DONT_CARE,
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		1,
	startup:		keyspan_fake_startup	
};

struct usb_serial_device_type keyspan_usa19_pre_device = {
	name:			"Keyspan USA19 - (without firmware)",
	id_table:		keyspan_usa19_pre_ids,
	needs_interrupt_in:	DONT_CARE,
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		1,
	startup:		keyspan_fake_startup	
};


struct usb_serial_device_type keyspan_usa19w_pre_device = {
	name:			"Keyspan USA19W - (without firmware)",
	id_table:		keyspan_usa19w_pre_ids,
	needs_interrupt_in:	DONT_CARE,
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		1,
	startup:		keyspan_fake_startup	
};


struct usb_serial_device_type keyspan_usa28_pre_device = {
	name:			"Keyspan USA28 - (without firmware)",
	id_table:		keyspan_usa28_pre_ids,
	needs_interrupt_in:	DONT_CARE,
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		2,
	startup:		keyspan_fake_startup	
};

struct usb_serial_device_type keyspan_usa28x_pre_device = {
	name:			"Keyspan USA28X - (without firmware)",
	id_table:		keyspan_usa28x_pre_ids,
	needs_interrupt_in:	DONT_CARE,
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		2,
	startup:		keyspan_fake_startup	
};

struct usb_serial_device_type keyspan_usa49w_pre_device = {
	name:			"Keyspan USA49W - (without firmware)",
	id_table:		keyspan_usa49w_pre_ids,
	needs_interrupt_in:	DONT_CARE,
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		4,
	startup:		keyspan_fake_startup	
};

struct usb_serial_device_type keyspan_usa18x_device = {
	name:			"Keyspan USA18X",
	id_table:		keyspan_usa18x_ids,
	needs_interrupt_in:	DONT_CARE,	
	needs_bulk_in:		MUST_HAVE,
	needs_bulk_out:		MUST_HAVE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		3,
	num_bulk_out:		4,
	num_ports:		1,
	open:			keyspan_open,
	close:			keyspan_close,
	write:			keyspan_write,
	write_room:		keyspan_write_room,
	//write_bulk_callback: 	Not used - we define our own herbs
	//read_int_callback:	keyspan_usa26_read_int_callback,
	chars_in_buffer:	keyspan_chars_in_buffer,
	throttle:		keyspan_rx_throttle,
	unthrottle:		keyspan_rx_unthrottle,
	ioctl:			keyspan_ioctl,
	set_termios:		keyspan_set_termios,
	break_ctl:		keyspan_break_ctl,
	startup:		keyspan_startup,
	shutdown:		keyspan_shutdown,
};

struct usb_serial_device_type keyspan_usa19_device = {
	name:			"Keyspan USA19",
	id_table:		keyspan_usa19_ids,
	needs_interrupt_in:	DONT_CARE,	
	needs_bulk_in:		MUST_HAVE,
	needs_bulk_out:		MUST_HAVE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		3,
	num_bulk_out:		4,
	num_ports:		1,
	open:			keyspan_open,
	close:			keyspan_close,
	write:			keyspan_write,
	write_room:		keyspan_write_room,
//	write_bulk_callback: 	keyspan_write_bulk_callback,
//	read_int_callback:	keyspan_usa28_read_int_callback,
	chars_in_buffer:	keyspan_chars_in_buffer,
	throttle:		keyspan_rx_throttle,
	unthrottle:		keyspan_rx_unthrottle,
	ioctl:			keyspan_ioctl,
	set_termios:		keyspan_set_termios,
	break_ctl:		keyspan_break_ctl,
	startup:		keyspan_startup,
	shutdown:		keyspan_shutdown,
};


struct usb_serial_device_type keyspan_usa19w_device = {
	name:			"Keyspan USA19W",
	id_table:		keyspan_usa19w_ids,
	needs_interrupt_in:	DONT_CARE,	
	needs_bulk_in:		MUST_HAVE,
	needs_bulk_out:		MUST_HAVE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		3,
	num_bulk_out:		4,
	num_ports:		1,
	open:			keyspan_open,
	close:			keyspan_close,
	write:			keyspan_write,
	write_room:		keyspan_write_room,
	//write_bulk_callback: 	Not used - we define our own herbs
	//read_int_callback:	keyspan_usa26_read_int_callback,
	chars_in_buffer:	keyspan_chars_in_buffer,
	throttle:		keyspan_rx_throttle,
	unthrottle:		keyspan_rx_unthrottle,
	ioctl:			keyspan_ioctl,
	set_termios:		keyspan_set_termios,
	break_ctl:		keyspan_break_ctl,
	startup:		keyspan_startup,
	shutdown:		keyspan_shutdown,
};


struct usb_serial_device_type keyspan_usa28_device = {
	name:			"Keyspan USA28",
	id_table:		keyspan_usa28_ids,
	needs_interrupt_in:	DONT_CARE,	
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		2,
	open:			keyspan_open,
	close:			keyspan_close,
	throttle:		keyspan_rx_throttle,
	unthrottle:		keyspan_rx_unthrottle,
	set_termios:		keyspan_set_termios,
};


struct usb_serial_device_type keyspan_usa28x_device = {
	name:			"Keyspan USA28X",
	id_table:		keyspan_usa28x_ids,
	needs_interrupt_in:	DONT_CARE,	
	needs_bulk_in:		DONT_CARE,
	needs_bulk_out:		DONT_CARE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		NUM_DONT_CARE,
	num_bulk_out:		NUM_DONT_CARE,
	num_ports:		2,
	open:			keyspan_open,
	close:			keyspan_close,
	write:			keyspan_write,
	write_room:		keyspan_write_room,
//	write_bulk_callback: 	keyspan_write_bulk_callback,
//	read_int_callback:	keyspan_usa26_read_int_callback,
	chars_in_buffer:	keyspan_chars_in_buffer,
	throttle:		keyspan_rx_throttle,
	unthrottle:		keyspan_rx_unthrottle,
	ioctl:			keyspan_ioctl,
	set_termios:		keyspan_set_termios,
	break_ctl:		keyspan_break_ctl,
	startup:		keyspan_startup,
	shutdown:		keyspan_shutdown,

};
				

struct usb_serial_device_type keyspan_usa49w_device = {
	name:			"Keyspan USA49W",
	id_table:		keyspan_usa49w_ids,
	needs_interrupt_in:	DONT_CARE,	
	needs_bulk_in:		MUST_HAVE,
	needs_bulk_out:		MUST_HAVE,
	num_interrupt_in:	NUM_DONT_CARE,
	num_bulk_in:		5,
	num_bulk_out:		5,
	num_ports:		4,
	open:			keyspan_open,
	close:			keyspan_close,
	write:			keyspan_write,
	write_room:		keyspan_write_room,
	//write_bulk_callback: 	Not used - we define our own herbs
	//read_int_callback:	keyspan_usa26_read_int_callback,
	chars_in_buffer:	keyspan_chars_in_buffer,
	throttle:		keyspan_rx_throttle,
	unthrottle:		keyspan_rx_unthrottle,
	ioctl:			keyspan_ioctl,
	set_termios:		keyspan_set_termios,
	break_ctl:		keyspan_break_ctl,
	startup:		keyspan_startup,
	shutdown:		keyspan_shutdown,
};


#endif