patch-2.3.99-pre7 linux/drivers/usb/serial/digi_acceleport.c

Next file: linux/drivers/usb/serial/ezusb_convert.pl
Previous file: linux/drivers/usb/serial/Makefile
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v2.3.99-pre6/linux/drivers/usb/serial/digi_acceleport.c linux/drivers/usb/serial/digi_acceleport.c
@@ -0,0 +1,975 @@
+/*
+*  Digi AccelePort USB-4 Serial Converter
+*
+*  Copyright 2000 by Digi International
+*
+*  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.
+*
+*  Shamelessly based on Brian Warner's keyspan_pda.c and Greg Kroah-Hartman's
+*  usb-serial driver.
+*
+*  Peter Berger ([email protected])
+*  Al Borchers ([email protected])
+*
+*  (5/3/2000) pberger and borchers
+*  First alpha version of the driver--many known limitations and bugs.
+*
+*  $Id: digi_acceleport.c,v 1.28 2000/05/04 01:47:08 root Exp root $
+*/
+
+#include <linux/config.h>
+
+#ifdef CONFIG_USB_SERIAL_DIGI_ACCELEPORT
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/signal.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/malloc.h>
+#include <linux/fcntl.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/tty.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+
+#ifdef CONFIG_USB_SERIAL_DEBUG
+	#define DEBUG
+#else
+	#undef DEBUG
+#endif
+#include <linux/usb.h>
+#include "usb-serial.h"
+
+
+/* Defines */
+
+/* port buffer length -- must be <= transfer buffer length - 2 */
+/* so we can be sure to send the full buffer in one urb */
+#define DIGI_PORT_BUF_LEN			16
+
+/* AccelePort USB Defines */
+
+/* ids */
+#define DIGI_VENDOR_ID				0x05c5
+#define DIGI_ID					0x0004
+
+/* commands */
+#define DIGI_CMD_SET_BAUD_RATE			0
+#define DIGI_CMD_SET_WORD_SIZE			1
+#define DIGI_CMD_SET_PARITY			2
+#define DIGI_CMD_SET_STOP_BITS			3
+#define DIGI_CMD_SET_INPUT_FLOW_CONTROL		4
+#define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL	5
+#define DIGI_CMD_SET_DTR_SIGNAL			6
+#define DIGI_CMD_SET_RTS_SIGNAL			7
+#define DIGI_CMD_RECEIVE_ENABLE			10
+#define DIGI_CMD_BREAK_CONTROL			11
+#define DIGI_CMD_LOCAL_LOOPBACK			12
+#define DIGI_CMD_TRANSMIT_IDLE			13
+#define DIGI_CMD_WRITE_UART_REGISTER		15
+#define DIGI_CMD_AND_UART_REGISTER		16
+#define DIGI_CMD_OR_UART_REGISTER		17
+#define DIGI_CMD_SEND_DATA			18
+
+/* baud rates */
+#define DIGI_BAUD_50				0
+#define DIGI_BAUD_75				1
+#define DIGI_BAUD_110				2
+#define DIGI_BAUD_150				3
+#define DIGI_BAUD_200				4
+#define DIGI_BAUD_300				5
+#define DIGI_BAUD_600				6
+#define DIGI_BAUD_1200				7
+#define DIGI_BAUD_1800				8
+#define DIGI_BAUD_2400				9
+#define DIGI_BAUD_4800				10
+#define DIGI_BAUD_7200				11
+#define DIGI_BAUD_9600				12
+#define DIGI_BAUD_14400				13
+#define DIGI_BAUD_19200				14
+#define DIGI_BAUD_28800				15
+#define DIGI_BAUD_38400				16
+#define DIGI_BAUD_57600				17
+#define DIGI_BAUD_76800				18
+#define DIGI_BAUD_115200			19
+#define DIGI_BAUD_153600			20
+#define DIGI_BAUD_230400			21
+#define DIGI_BAUD_460800			22
+
+/* flow control arguments */
+#define DIGI_ENABLE_IXON_IXOFF_FLOW_CONTROL	1
+#define DIGI_ENABLE_RTS_CTS_FLOW_CONTROL	2
+#define DIGI_ENABLE_DTR_DSR_FLOW_CONTROL	4
+
+/* macros */
+#define MAX(a,b)	(((a)>(b))?(a):(b))
+#define MIN(a,b)	(((a)<(b))?(a):(b))
+
+
+/* Structures */
+
+typedef struct digi_private {
+	spinlock_t dp_port_lock;
+	int dp_buf_len;
+	char dp_buf[32];
+} digi_private_t;
+
+struct s_digiusb {
+	u8 opcode;
+	u8 length;
+	u8 val;
+	u8 pad;
+};
+
+
+/* Local Function Declarations */
+
+static void digi_send_cmd( char *mes, struct usb_serial_port *port, int opcode,
+	int length, int val );
+static void digi_send_oob( char *mes, int opcode, int linenum, int data1, int data2 );
+static void digi_rx_throttle (struct usb_serial_port *port);
+static void digi_rx_unthrottle (struct usb_serial_port *port);
+static int digi_setbaud( struct usb_serial_port *port, int baud );
+static void digi_set_termios( struct usb_serial_port *port, 
+	struct termios *old_termios );
+static void digi_break_ctl( struct usb_serial_port *port, int break_state );
+static int digi_get_modem_info( struct usb_serial *serial,
+	unsigned char *value );
+static int digi_set_modem_info( struct usb_serial *serial,
+	unsigned char value );
+static int digi_ioctl( struct usb_serial_port *port, struct file *file,
+	unsigned int cmd, unsigned long arg );
+static int digi_write( struct usb_serial_port *port, int from_user,
+	const unsigned char *buf, int count );
+static void digi_write_bulk_callback( struct urb *urb );
+static int digi_write_room( struct usb_serial_port *port );
+static int digi_chars_in_buffer( struct usb_serial_port *port );
+static int digi_open( struct usb_serial_port *port, struct file *filp );
+static void digi_close( struct usb_serial_port *port, struct file *filp );
+static int digi_startup (struct usb_serial *serial);
+static void digi_shutdown( struct usb_serial *serial );
+static void digi_read_bulk_callback( struct urb *urb );
+
+
+/* Statics */
+
+/* device info needed for the Digi serial converter */
+static __u16	digi_vendor_id		= DIGI_VENDOR_ID;
+static __u16	digi_product_id		= DIGI_ID;
+
+/* out of band port */
+static int oob_port_num;					/* index of out-of-band port */
+static struct usb_serial_port *oob_port;	/* out-of-band control port */
+static int oob_read_started = 0;
+
+/* config lock -- used to protect digi statics and globals, like oob vars */
+spinlock_t config_lock;
+
+
+/* Globals */
+
+struct usb_serial_device_type digi_acceleport_device = {
+	name:			"Digi USB",
+	idVendor:		&digi_vendor_id,
+	idProduct:		&digi_product_id,
+	needs_interrupt_in:	DONT_CARE,
+	needs_bulk_in:		MUST_HAVE,
+	needs_bulk_out:		MUST_HAVE,
+	num_interrupt_in:	0,
+	num_bulk_in:		5,
+	num_bulk_out:		5,
+	num_ports:		4,
+	open:			digi_open,
+	close:			digi_close,
+	write:			digi_write,
+	write_room:		digi_write_room,
+	write_bulk_callback:	digi_write_bulk_callback,
+	read_bulk_callback:	digi_read_bulk_callback,
+	chars_in_buffer:	digi_chars_in_buffer,
+	throttle:		digi_rx_throttle,
+	unthrottle:		digi_rx_unthrottle,
+	ioctl:			digi_ioctl,
+	set_termios:		digi_set_termios,
+	break_ctl:		digi_break_ctl,
+	startup:		digi_startup,
+	shutdown:		digi_shutdown,
+};
+
+
+/* Functions */
+
+/* Send message on the out-of-Band endpoint */
+static void digi_send_oob( char *mes, int opcode, int linenum, int data1, int data2 )
+{
+	int ret;
+	struct s_digiusb digiusb;
+	digi_private_t *priv = (digi_private_t *)(oob_port->private);
+
+
+dbg( "digi_send_oob: TOP: from '%s', opcode: %d, linenum:%d, data1: %d, data2: %d", mes, opcode, linenum, data1, data2 );
+
+	digiusb.opcode = (u8)opcode;
+	digiusb.length = (u8)linenum;
+	digiusb.val = (u8)data1;
+	digiusb.pad = (u8)data2;
+
+	spin_lock( &priv->dp_port_lock );
+
+	while (oob_port->write_urb->status == -EINPROGRESS) {
+dbg( "digi_send_oob: opcode:%d already writing...", opcode );
+		spin_unlock( &priv->dp_port_lock );
+		interruptible_sleep_on(&oob_port->write_wait);
+		if (signal_pending(current)) {
+			return;
+		}
+		spin_lock( &priv->dp_port_lock );
+	}
+
+	memcpy( oob_port->write_urb->transfer_buffer, &digiusb, sizeof(digiusb) );
+	oob_port->write_urb->transfer_buffer_length = sizeof(digiusb);
+	if( (ret=usb_submit_urb(oob_port->write_urb)) != 0 ) {
+		dbg(
+		"digi_send_oob: usb_submit_urb(write bulk) failed, opcode=%d, ret=%d",
+		opcode, ret );
+	}
+
+	spin_unlock( &priv->dp_port_lock );
+
+dbg( "digi_send_oob: opcode %d done", opcode );
+
+}
+
+
+static void digi_send_cmd( char *mes, struct usb_serial_port *port, int opcode,
+	int length, int val )
+{
+
+	int ret;
+	struct s_digiusb digiusb;
+	digi_private_t *priv = (digi_private_t *)(port->private);
+
+
+dbg( "digi_send_cmd: TOP: from '%s', opcode: %d, val: %d", mes, opcode, val );
+
+	digiusb.opcode = (u8)opcode;
+	digiusb.length = (u8)length;
+	digiusb.val = (u8)val;
+	digiusb.pad = 0;
+
+	spin_lock( &priv->dp_port_lock );
+
+	while( port->write_urb->status == -EINPROGRESS ) {
+dbg( "digi_send_cmd: opcode=%d already writing...", opcode );
+		spin_unlock( &priv->dp_port_lock );
+		interruptible_sleep_on( &port->write_wait );
+		if( signal_pending(current) ) {
+			return;
+		}
+		spin_lock( &priv->dp_port_lock );
+	}
+
+	memcpy( port->write_urb->transfer_buffer, &digiusb, sizeof(digiusb) );
+	port->write_urb->transfer_buffer_length = sizeof(digiusb);
+	if( (ret=usb_submit_urb(port->write_urb)) != 0 )
+		dbg(
+		"digi_send_cmd: usb_submit_urb(write bulk) failed, opcode=%d, ret=%d",
+		opcode, ret );
+
+dbg( "digi_send_cmd: opcode %d done", opcode );
+
+	spin_unlock( &priv->dp_port_lock );
+
+}
+
+
+static void digi_rx_throttle( struct usb_serial_port *port )
+{
+
+dbg( "digi_rx_throttle: TOP: port=%d", port->number );
+
+	/* stop receiving characters. We just turn off the URB request, and
+	   let chars pile up in the device. If we're doing hardware
+	   flowcontrol, the device will signal the other end when its buffer
+	   fills up. If we're doing XON/XOFF, this would be a good time to
+	   send an XOFF, although it might make sense to foist that off
+	   upon the device too. */
+
+	// usb_unlink_urb(port->interrupt_in_urb);
+
+}
+
+
+static void digi_rx_unthrottle( struct usb_serial_port *port )
+{
+
+dbg( "digi_rx_unthrottle: TOP: port=%d", port->number );
+
+	/* just restart the receive interrupt URB */
+	//if (usb_submit_urb(port->interrupt_in_urb))
+	//	dbg( "digi_rx_unthrottle: usb_submit_urb(read urb) failed" );
+
+}
+
+
+static int digi_setbaud( struct usb_serial_port *port, int baud )
+{
+
+	int bindex;
+
+
+dbg( "digi_setbaud: TOP: port=%d", port->number );
+
+	switch( baud ) {
+		case 50: bindex = DIGI_BAUD_50; break;
+		case 75: bindex = DIGI_BAUD_75; break;
+		case 110: bindex = DIGI_BAUD_110; break;
+		case 150: bindex = DIGI_BAUD_150; break;
+		case 200: bindex = DIGI_BAUD_200; break;
+		case 300: bindex = DIGI_BAUD_300; break;
+		case 600: bindex = DIGI_BAUD_600; break;
+		case 1200: bindex = DIGI_BAUD_1200; break;
+		case 1800: bindex = DIGI_BAUD_1800; break;
+		case 2400: bindex = DIGI_BAUD_2400; break;
+		case 4800: bindex = DIGI_BAUD_4800; break;
+		case 7200: bindex = DIGI_BAUD_7200; break;
+		case 9600: bindex = DIGI_BAUD_9600; break;
+		case 14400: bindex = DIGI_BAUD_14400; break;
+		case 19200: bindex = DIGI_BAUD_19200; break;
+		case 28800: bindex = DIGI_BAUD_28800; break;
+		case 38400: bindex = DIGI_BAUD_38400; break;
+		case 57600: bindex = DIGI_BAUD_57600; break;
+		case 76800: bindex = DIGI_BAUD_76800; break;
+		case 115200: bindex = DIGI_BAUD_115200; break;
+		case 153600: bindex = DIGI_BAUD_153600; break;
+		case 230400: bindex = DIGI_BAUD_230400; break;
+		case 460800: bindex = DIGI_BAUD_460800; break;
+		default:
+			dbg( "digi_setbaud: can't handle requested baud rate %d", baud );
+			return( -EINVAL );
+			break;
+	}
+
+	digi_send_cmd( "digi_setbaud:", port, DIGI_CMD_SET_BAUD_RATE, 2, bindex );
+
+	return( 0 );	/* FIX -- send_cmd should return a value??, return it */
+
+}
+
+
+static void digi_set_termios( struct usb_serial_port *port, 
+	struct termios *old_termios )
+{
+
+	unsigned int iflag = port->tty->termios->c_iflag;
+	unsigned int old_iflag = old_termios->c_iflag;
+	unsigned int cflag = port->tty->termios->c_cflag;
+	unsigned int old_cflag = old_termios->c_cflag;
+	int arg;
+
+
+dbg( "digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x", port->number, iflag, old_iflag, cflag, old_cflag );
+
+	/* set baud rate */
+	/* if( (cflag&CBAUD) != (old_cflag&CBAUD) ) */ {
+		switch( (cflag&CBAUD) ) {
+			case B50: digi_setbaud(port, 50); break;
+			case B75: digi_setbaud(port, 75); break;
+			case B110: digi_setbaud(port, 110); break;
+			case B150: digi_setbaud(port, 150); break;
+			case B200: digi_setbaud(port, 200); break;
+			case B300: digi_setbaud(port, 300); break;
+			case B600: digi_setbaud(port, 600); break;
+			case B1200: digi_setbaud(port, 1200); break;
+			case B1800: digi_setbaud(port, 1800); break;
+			case B2400: digi_setbaud(port, 2400); break;
+			case B4800: digi_setbaud(port, 4800); break;
+			case B9600: digi_setbaud(port, 9600); break;
+			case B19200: digi_setbaud(port, 19200); break;
+			case B38400: digi_setbaud(port, 38400); break;
+			case B57600: digi_setbaud(port, 57600); break;
+			case B115200: digi_setbaud(port, 115200); break;
+			default:
+				dbg( "digi_set_termios: can't handle baud rate 0x%x",
+					(cflag&CBAUD) );
+				break;
+		}
+	}
+
+	/* set input flow control */
+	/* if( (iflag&IXOFF) != (old_iflag&IXOFF)
+	|| (cflag&CRTSCTS) != (old_cflag&CRTSCTS) ) */ {
+
+		arg = 0;
+
+		if( (iflag&IXOFF) )
+			arg |= DIGI_ENABLE_IXON_IXOFF_FLOW_CONTROL;
+		if( (cflag&CRTSCTS) )
+			arg |= DIGI_ENABLE_RTS_CTS_FLOW_CONTROL;
+
+		digi_send_cmd( "digi_termios: set input flow control:", port,
+			DIGI_CMD_SET_INPUT_FLOW_CONTROL, 2, arg );
+
+	}
+
+	/* set output flow control */
+	/* if( (iflag&IXON) != (old_iflag&IXON)
+	|| (cflag&CRTSCTS) != (old_cflag&CRTSCTS) ) */ {
+
+		arg = 0;
+
+		if( (iflag&IXON) )
+			arg |= DIGI_ENABLE_IXON_IXOFF_FLOW_CONTROL;
+		if( (cflag&CRTSCTS) )
+			arg |= DIGI_ENABLE_RTS_CTS_FLOW_CONTROL;
+
+		digi_send_cmd( "digi_set_termios: set output flow control:", port,
+			DIGI_CMD_SET_OUTPUT_FLOW_CONTROL, 2, arg );
+
+	}
+
+}
+
+
+static void digi_break_ctl( struct usb_serial_port *port, int break_state )
+{
+dbg( "digi_break_ctl: TOP: port=%d", port->number );
+}
+
+
+/* modem control pins: DTR and RTS are outputs and can be controlled;
+   DCD, RI, DSR, CTS are inputs and can be read */
+
+static int digi_get_modem_info( struct usb_serial *serial,
+	unsigned char *value )
+{
+dbg( "digi_get_modem_info: TOP" );
+	return( 0 );
+}
+
+
+static int digi_set_modem_info( struct usb_serial *serial,
+	unsigned char value )
+{
+dbg( "digi_set_modem_info: TOP" );
+	return( 0 );
+}
+
+
+static int digi_ioctl( struct usb_serial_port *port, struct file *file,
+	unsigned int cmd, unsigned long arg )
+{
+	struct usb_serial *serial = port->serial;
+	int rc;
+	unsigned int value;
+	unsigned char status, mask;
+
+dbg( "digi_ioctl: TOP: port=%d, cmd=0x%x", port->number, cmd );
+return( -ENOIOCTLCMD );
+
+	switch (cmd) {
+	case TIOCMGET: /* get modem pins state */
+		rc = digi_get_modem_info(serial, &status);
+		if (rc < 0)
+			return rc;
+		value =
+			((status & (1<<7)) ? TIOCM_DTR : 0) |
+			((status & (1<<6)) ? TIOCM_CAR : 0) |
+			((status & (1<<5)) ? TIOCM_RNG : 0) |
+			((status & (1<<4)) ? TIOCM_DSR : 0) |
+			((status & (1<<3)) ? TIOCM_CTS : 0) |
+			((status & (1<<2)) ? TIOCM_RTS : 0);
+		if (copy_to_user((unsigned int *)arg, &value, sizeof(int)))
+			return -EFAULT;
+		return 0;
+	case TIOCMSET: /* set a state as returned by MGET */
+		if (copy_from_user(&value, (unsigned int *)arg, sizeof(int)))
+			return -EFAULT;
+		status =
+			((value & TIOCM_DTR) ? (1<<7) : 0) |
+			((value & TIOCM_CAR) ? (1<<6) : 0) |
+			((value & TIOCM_RNG) ? (1<<5) : 0) |
+			((value & TIOCM_DSR) ? (1<<4) : 0) |
+			((value & TIOCM_CTS) ? (1<<3) : 0) |
+			((value & TIOCM_RTS) ? (1<<2) : 0);
+		rc = digi_set_modem_info(serial, status);
+		if (rc < 0)
+			return rc;
+		return 0;
+	case TIOCMBIS: /* set bits in bitmask <arg> */
+	case TIOCMBIC: /* clear bits from bitmask <arg> */
+		if (copy_from_user(&value, (unsigned int *)arg, sizeof(int)))
+			return -EFAULT;
+		rc = digi_get_modem_info(serial, &status);
+		if (rc < 0)
+			return rc;
+		mask =
+			((value & TIOCM_RTS) ? (1<<2) : 0) |
+			((value & TIOCM_DTR) ? (1<<7) : 0);
+		if (cmd == TIOCMBIS)
+			status |= mask;
+		else
+			status &= ~mask;
+		rc = digi_set_modem_info(serial, status);
+		if (rc < 0)
+			return rc;
+		return 0;
+	case TIOCMIWAIT:
+		/* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
+		/* TODO */
+	case TIOCGICOUNT:
+		/* return count of modemline transitions */
+		return 0; /* TODO */
+	}
+	
+	return -ENOIOCTLCMD;
+}
+
+
+static int digi_write( struct usb_serial_port *port, int from_user,
+	const unsigned char *buf, int count )
+{
+
+	int i,ret,data_len,new_len;
+	digi_private_t *priv = (digi_private_t *)(port->private);
+
+
+dbg( "digi_write: TOP: port=%d, count=%d, from_user=%d, in_interrupt=%d",
+port->number, count, from_user, in_interrupt() );
+
+	/* be sure only one write proceeds at a time */
+	/* there are races on the port private buffer */
+	/* and races to check write_urb->status */
+	spin_lock( &priv->dp_port_lock );
+
+	/* wait for urb status clear to submit another urb */
+	if( port->write_urb->status == -EINPROGRESS ) {
+
+dbg( "digi_write: -EINPROGRESS set" );
+
+		/* buffer the data if possible */
+		new_len = MIN( count, DIGI_PORT_BUF_LEN-priv->dp_buf_len );
+		memcpy( priv->dp_buf+priv->dp_buf_len, buf, new_len );
+		priv->dp_buf_len += new_len;
+
+		/* unlock and return number of bytes buffered */
+		spin_unlock( &priv->dp_port_lock );
+dbg( "digi_write: buffering, return %d", new_len );
+		return( new_len );
+
+	}
+
+	/* allow space for any buffered data and for new data, up to */
+	/* transfer buffer size - 2 (for command and length bytes) */
+	new_len = MIN( count, port->bulk_out_size-2-priv->dp_buf_len );
+	data_len = new_len + priv->dp_buf_len;
+
+dbg( "digi_write: counts: new data %d, buf data %d, total data %d (max %d)", new_len, priv->dp_buf_len, data_len, port->bulk_out_size-2 );
+
+	/* nothing to send */
+	if( data_len == 0 ) {
+		spin_unlock( &priv->dp_port_lock );
+		return( 0 );
+	}
+
+	/* set command and length bytes */
+	*((u8 *)(port->write_urb->transfer_buffer)) = (u8)DIGI_CMD_SEND_DATA;
+	*((u8 *)(port->write_urb->transfer_buffer)+1) = (u8)data_len;
+
+	/* set total transfer buffer length */
+	port->write_urb->transfer_buffer_length = data_len+2;
+
+	/* copy in buffered data first */
+	memcpy( port->write_urb->transfer_buffer+2, priv->dp_buf,
+		priv->dp_buf_len );
+
+	/* copy in new data */
+	if( from_user ) {
+		copy_from_user( port->write_urb->transfer_buffer+2+priv->dp_buf_len,
+			buf, new_len );
+	}
+	else {
+		memcpy( port->write_urb->transfer_buffer+2+priv->dp_buf_len,
+			buf, new_len );
+	}  
+
+#ifdef DEBUG
+	printk( KERN_DEBUG __FILE__ ": digi_write: length=%d, data=",
+		port->write_urb->transfer_buffer_length );
+	for( i=0; i<port->write_urb->transfer_buffer_length; ++i ) {
+		printk( "%.2x ",
+			((unsigned char *)port->write_urb->transfer_buffer)[i] );
+	}
+	printk( "\n" );
+#endif
+
+	/* submit urb */
+	if( (ret=usb_submit_urb(port->write_urb)) == 0 ) {
+		/* submit successful, return length of new data written */
+		ret = new_len;
+		/* clear buffer */
+		priv->dp_buf_len = 0;
+	}
+	else {
+		dbg( "digi_write: usb_submit_urb(write bulk) failed, ret=%d", ret );
+		/* no bytes written - should we return the error code or 0? */
+		ret = 0;
+	}
+
+	/* return length of new data written, or error */
+dbg( "digi_write: returning %d", ret );
+	spin_unlock( &priv->dp_port_lock );
+	return( ret );
+
+} 
+
+
+static void digi_write_bulk_callback( struct urb *urb )
+{
+
+	struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
+	struct usb_serial *serial = port->serial;
+	struct tty_struct *tty = port->tty;
+	digi_private_t *priv = (digi_private_t *)(port->private);
+	int ret;
+
+
+dbg( "digi_write_bulk_callback: TOP: port=%d", port->number );
+
+	/* handle callback on out-of-band port */
+	if( port->number == oob_port_num ) {
+		dbg( "digi_write_bulk_callback: oob callback" );
+		wake_up_interruptible( &port->write_wait );
+		return;
+	}
+
+	/* sanity checks */
+	if( port_paranoia_check( port, "digi_write_bulk_callback" )
+	|| serial_paranoia_check( serial, "digi_write_bulk_callback" ) ) {
+		return;
+	}
+
+	/* try to send any buffered data on this port */
+	spin_lock( &priv->dp_port_lock );
+	if( port->write_urb->status != -EINPROGRESS && priv->dp_buf_len > 0 ) {
+
+		/* set command and length bytes */
+		*((u8 *)(port->write_urb->transfer_buffer))
+			= (u8)DIGI_CMD_SEND_DATA;
+		*((u8 *)(port->write_urb->transfer_buffer)+1)
+			= (u8)priv->dp_buf_len;
+
+		/* set total transfer buffer length */
+		port->write_urb->transfer_buffer_length = priv->dp_buf_len+2;
+
+		/* copy in buffered data */
+		memcpy( port->write_urb->transfer_buffer+2, priv->dp_buf,
+			priv->dp_buf_len );
+
+		/* submit urb */
+dbg( "digi_write_bulk_callback: submit urb to write buffer, data len=%d",
+priv->dp_buf_len );
+		if( (ret=usb_submit_urb(port->write_urb)) == 0 ) {
+			/* successful, clear buffer */
+			priv->dp_buf_len = 0;
+		}
+		else {
+			dbg( "digi_write_bulk_callback: usb_submit_urb(write bulk) failed, ret=%d", ret );
+		}
+
+	}
+	spin_unlock( &priv->dp_port_lock );
+
+	/* wake up port processes */
+	wake_up_interruptible( &port->write_wait );
+
+	/* wake up line discipline */
+	tty = port->tty;
+	if( (tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup )
+		(tty->ldisc.write_wakeup)(tty);
+
+	/* wake up other tty processes */
+	wake_up_interruptible( &tty->write_wait );
+
+}
+
+
+static int digi_write_room( struct usb_serial_port *port )
+{
+
+	int room;
+	digi_private_t *priv = (digi_private_t *)(port->private);
+
+
+dbg( "digi_write_room: TOP: port=%d", port->number );
+
+	spin_lock( &priv->dp_port_lock );
+
+	if( port->write_urb->status == -EINPROGRESS )
+		room = 0;
+	else
+		room = port->bulk_out_size - 2 - priv->dp_buf_len;
+
+	spin_unlock( &priv->dp_port_lock );
+
+dbg( "digi_write_room: return room=%d", room );
+	return( room );
+
+}
+
+
+static int digi_chars_in_buffer( struct usb_serial_port *port )
+{
+
+	digi_private_t *priv = (digi_private_t *)(port->private);
+
+
+dbg( "digi_chars_in_buffer: TOP: port=%d", port->number );
+
+	if( port->write_urb->status == -EINPROGRESS ) {
+dbg( "digi_chars_in_buffer: return=%d", port->bulk_out_size );
+		return( port->bulk_out_size );
+	}
+	else {
+dbg( "digi_chars_in_buffer: return=%d", priv->dp_buf_len );
+		return( priv->dp_buf_len );
+	}
+
+}
+
+
+static int digi_open( struct usb_serial_port *port, struct file *filp )
+{
+
+	int ret;
+	digi_private_t *priv = (digi_private_t *)(port->private);
+
+
+dbg( "digi_open: TOP: port %d", port->number );
+
+	/* if port is already open, just return */
+	/* be sure exactly one open succeeds */
+	spin_lock( &priv->dp_port_lock );
+	if( port->active ) {
+		return( 0 );
+	}
+	port->active = 1;
+	spin_unlock( &priv->dp_port_lock );
+ 
+	/* start reading from the out-of-band port for the device */
+	/* be sure this happens exactly once */
+	spin_lock( &config_lock );
+	if( !oob_read_started ) {
+		if( (ret=usb_submit_urb(oob_port->read_urb)) != 0 ) {
+			dbg( "digi_open: usb_submit_urb(read bulk) for oob failed, ret=%d",
+				ret );
+			spin_unlock( &config_lock );
+			return( -ENXIO );
+		}
+		else {
+dbg( "digi_open: usb_submit_urb(read bulk) for oob succeeded" );
+			oob_read_started = 1;
+		}
+	}
+	spin_unlock( &config_lock );
+
+	/* initialize port */
+dbg( "digi_open: init..." );
+	/* set 9600, 8N1, DTR, RTS, RX enable, no input or output flow control */
+	digi_setbaud( port, 9600 );
+	digi_send_cmd( "digi_open: wordsize", port, DIGI_CMD_SET_WORD_SIZE, 2, 3 );
+	digi_send_cmd( "digi_open: parity", port, DIGI_CMD_SET_PARITY, 2, 0 );
+	digi_send_cmd( "digi_open: stopbits", port, DIGI_CMD_SET_STOP_BITS, 2, 0 );
+	digi_send_cmd( "digi_open: DTR on", port, DIGI_CMD_SET_DTR_SIGNAL, 2, 1 );
+	digi_send_cmd( "digi_open: RTS on", port, DIGI_CMD_SET_RTS_SIGNAL, 2, 1 );
+	digi_send_cmd( "digi_open: RX enable on", port, DIGI_CMD_RECEIVE_ENABLE, 2,
+		1 );
+	digi_send_cmd( "digi_open: input flow control off", port,
+		DIGI_CMD_SET_INPUT_FLOW_CONTROL, 2, 0 );
+	digi_send_cmd( "digi_open: output flow control off", port,
+		DIGI_CMD_SET_OUTPUT_FLOW_CONTROL, 2, 0 );
+
+	/* start reading from the device */
+	if( (ret=usb_submit_urb(port->read_urb)) != 0 ) {
+		dbg( "digi_open: usb_submit_urb(read bulk) failed, ret=%d", ret );
+		return( -ENXIO );
+	}
+
+dbg( "digi_open: done" );
+	return( 0 );
+
+}
+
+
+static void digi_close( struct usb_serial_port *port, struct file *filp )
+{
+
+dbg( "digi_close: TOP: port %d", port->number );
+	
+	/* Need to change the control lines here */
+	/* TODO */
+dbg( "digi_close: wanna clear DTR and RTS..." );
+
+//digi_send_cmd( "digi_close DTR off", port, 6, 2, 0);	// clear DTR
+//digi_send_cmd( "digi_close RTS off", port, 7, 2, 0);	// clear RTS
+//digi_send_cmd( "digi_close RX disable", port, 10, 2, 0);	// Rx Disable
+
+digi_send_oob( "digi_close RTS off", DIGI_CMD_SET_RTS_SIGNAL,
+	port->number, 0, 0 );	// clear RTS
+digi_send_oob( "digi_close DTR off", DIGI_CMD_SET_DTR_SIGNAL,
+	port->number, 0, 0 );	// clear DTR
+
+	while( oob_port->write_urb->status == -EINPROGRESS ) {
+dbg ("digi_close: waiting for final writes to complete on oob port %d...", oob_port->number );
+		interruptible_sleep_on( &oob_port->write_wait );
+		if( signal_pending(current) ) {
+			break;
+		}
+	}
+	
+	/* shutdown our bulk reads and writes */
+	usb_unlink_urb (port->write_urb);
+	usb_unlink_urb (port->read_urb);
+
+	port->active = 0;
+
+}
+
+
+static int digi_startup (struct usb_serial *serial)
+{
+
+	int i;
+	digi_private_t *priv;
+
+
+dbg( "digi_startup: TOP" );
+
+	/* initialize config lock */
+	spin_lock_init( &config_lock );
+
+	/* allocate the private data structures for all ports */
+	/* number of regular ports + 1 for the out-of-band port */
+	for( i=0; i<digi_acceleport_device.num_ports+1; i++ ) {
+
+		/* allocate private structure */
+		priv = serial->port[i].private =
+			(digi_private_t *)kmalloc( sizeof(struct digi_private),
+			GFP_KERNEL );
+		if( priv == (digi_private_t *)0 )
+			return( 1 );				/* error */
+
+		/* initialize private structure */
+		priv->dp_buf_len = 0;
+		spin_lock_init( &priv->dp_port_lock );
+
+		/* initialize write wait queue for this port */
+		init_waitqueue_head(&serial->port[i].write_wait);
+
+	}
+
+	/* initialize out of band port info */
+	oob_port_num = digi_acceleport_device.num_ports;
+	oob_port = &serial->port[oob_port_num];
+	oob_read_started = 0;
+
+	return( 0 );
+
+}
+
+
+static void digi_shutdown( struct usb_serial *serial )
+{
+
+	int i;
+
+
+dbg( "digi_shutdown: TOP" );
+
+	/* stop writing and reading from the out-of-band port */
+	usb_unlink_urb( oob_port->write_urb );
+	usb_unlink_urb( oob_port->read_urb );
+	oob_read_started = 0;
+
+	/* free the private data structures for all ports */
+	/* number of regular ports + 1 for the out-of-band port */
+	for( i=0; i<digi_acceleport_device.num_ports+1; i++ )
+		kfree( serial->port[i].private );
+
+}
+
+
+static void digi_read_bulk_callback( struct urb *urb )
+{
+
+	struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
+	struct usb_serial *serial = port->serial;
+	struct tty_struct *tty = port->tty;
+	unsigned char *data = urb->transfer_buffer;
+	int ret,i;
+
+
+dbg( "digi_read_bulk_callback: TOP: port=%d", port->number );
+
+	/* handle oob callback */
+	if( port->number == oob_port_num ) {
+dbg( "digi_read_bulk_callback: oob_port callback, opcode=%d, line=%d, status=%d, ret=%d", data[0], data[1], data[2], data[3] );
+		if( urb->status ) {
+			dbg( "digi_read_bulk_callback: nonzero read bulk status on oob: %d",
+				urb->status );
+		}
+		if( (ret=usb_submit_urb(urb)) != 0 ) {
+			dbg( "digi_read_bulk_callback: failed resubmitting oob urb, ret=%d",
+				ret );
+		}
+		return;
+	}
+
+	/* sanity checks */
+	if( port_paranoia_check( port, "digi_read_bulk_callback" )
+	|| serial_paranoia_check( serial, "digi_read_bulk_callback" ) ) {
+		return;
+	}
+
+	/* check status */
+	if( urb->status ) {
+		dbg( "digi_read_bulk_callback: nonzero read bulk status: %d",
+			urb->status );
+		return;
+	}
+
+#ifdef DEBUG
+	if (urb->actual_length) {
+		printk( KERN_DEBUG __FILE__ ": digi_read_bulk_callback: length=%d, data=",
+			urb->actual_length );
+		for( i=0; i<urb->actual_length; ++i ) {
+			printk( "%.2x ", data[i] );
+		}
+		printk( "\n" );
+	}
+#endif
+
+	/* Digi read packets are:												 */
+	/* 0         1      2         3       4    ...     3+length-1 == 2+length*/
+	/* opcode, length, status, data[0], data[1]...data[length-2]			 */
+	if( urb->actual_length > 3 ) {
+		for( i=3; i<2+data[1]; ++i ) {
+			 tty_insert_flip_char(tty, data[i], 0);
+	  	}
+	  	tty_flip_buffer_push(tty);
+	}
+
+	/* Continue trying to read */
+	if( (ret=usb_submit_urb(urb)) != 0 )
+		dbg( "digi_read_bulk_callback: failed resubmitting read urb, ret=%d",
+			ret );
+
+}
+
+#endif	/* CONFIG_USB_SERIAL_DIGI_ACCELEPORT */
+
FUNET's LINUX-ADM group, [email protected]
TCL-scripts by Sam Shen (who was at: [email protected])