Administrace komentářů

*** anydata.orig.c	2006-02-03 07:03:08.000000000 +0100
--- anydata.c	2006-03-05 18:41:28.000000000 +0100
***************
*** 1,86 ****
  /*
!  * AnyData CDMA Serial USB driver
   *
!  * Copyright (C) 2005 Greg Kroah-Hartman <gregkh@suse.de>
   *
-  *	This program is free software; you can redistribute it and/or
-  *	modify it under the terms of the GNU General Public License version
-  *	2 as published by the Free Software Foundation.
   */
  
  #include <linux/kernel.h>
  #include <linux/init.h>
  #include <linux/tty.h>
  #include <linux/module.h>
  #include <linux/usb.h>
  #include "usb-serial.h"
  
  static struct usb_device_id id_table [] = {
! 	{ USB_DEVICE(0x16d5, 0x6501) },	/* AirData CDMA device */
! 	{ },
  };
- MODULE_DEVICE_TABLE(usb, id_table);
  
! /* if overridden by the user, then use their value for the size of the
!  * read and write urbs */
! static int buffer_size;
! static int debug;
  
  static struct usb_driver anydata_driver = {
  	.name =		"anydata",
  	.probe =	usb_serial_probe,
  	.disconnect =	usb_serial_disconnect,
  	.id_table =	id_table,
! 	.no_dynamic_id = 	1,
  };
  
! static int anydata_open(struct usb_serial_port *port, struct file *filp)
! {
! 	char *buffer;
! 	int result = 0;
  
! 	dbg("%s - port %d", __FUNCTION__, port->number);
  
- 	if (buffer_size) {
- 		/* override the default buffer sizes */
- 		buffer = kmalloc(buffer_size, GFP_KERNEL);
- 		if (!buffer) {
- 			dev_err(&port->dev, "%s - out of memory.\n",
- 				__FUNCTION__);
- 			return -ENOMEM;
- 		}
- 		kfree (port->read_urb->transfer_buffer);
- 		port->read_urb->transfer_buffer = buffer;
- 		port->read_urb->transfer_buffer_length = buffer_size;
- 
- 		buffer = kmalloc(buffer_size, GFP_KERNEL);
- 		if (!buffer) {
- 			dev_err(&port->dev, "%s - out of memory.\n",
- 				__FUNCTION__);
- 			return -ENOMEM;
- 		}
- 		kfree (port->write_urb->transfer_buffer);
- 		port->write_urb->transfer_buffer = buffer;
- 		port->write_urb->transfer_buffer_length = buffer_size;
- 		port->bulk_out_size = buffer_size;
- 	}
- 
- 	/* Start reading from the device */
- 	usb_fill_bulk_urb(port->read_urb, port->serial->dev,
- 			  usb_rcvbulkpipe(port->serial->dev,
- 				  	  port->bulk_in_endpointAddress),
- 			  port->read_urb->transfer_buffer,
- 			  port->read_urb->transfer_buffer_length,
- 			  usb_serial_generic_write_bulk_callback, port);
- 	result = usb_submit_urb(port->read_urb, GFP_KERNEL);
- 	if (result)
- 		dev_err(&port->dev,
- 			"%s - failed submitting read urb, error %d\n",
- 			__FUNCTION__, result);
- 
- 	return result;
- }
  
  static struct usb_serial_driver anydata_device = {
  	.driver = {
  		.owner =	THIS_MODULE,
--- 1,131 ----
  /*
!  * Prolific ANYDATA USB to serial adaptor driver
!  * Based on ANYDATA USB driver
   *
!  * Copyright (C) 2006 Daniel Kozak (kozzi11@gmail.com)
!  * 
!  * Original driver for 2.2.x by anonymous
!  *
!  *	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.
!  *
!  * See Documentation/usb/usb-serial.txt for more information on using this driver
   *
   */
  
+ #include <linux/config.h>
  #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/serial.h>
  #include <linux/module.h>
+ #include <linux/moduleparam.h>
+ #include <linux/spinlock.h>
+ #include <asm/uaccess.h>
  #include <linux/usb.h>
  #include "usb-serial.h"
+ #include "anydata.h"
+ 
+ /*
+  * Version Information
+  */
+ #define DRIVER_DESC "Prolific ANYDATA USB to serial adaptor driver"
+ 
+ static int debug;
+ 
+ #define ANYDATA_CLOSING_WAIT	(30*HZ)
+ 
+ #define ANYDATA_BUF_SIZE		1024
+ #define ANYDATA_TMP_BUF_SIZE	1024
+ 
+ struct anydata_buf {
+ 	unsigned int	buf_size;
+ 	char		*buf_buf;
+ 	char		*buf_get;
+ 	char		*buf_put;
+ };
  
  static struct usb_device_id id_table [] = {
! 	{ USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ID) },
! 				/* Terminating entry */
  };
  
! MODULE_DEVICE_TABLE (usb, id_table);
  
  static struct usb_driver anydata_driver = {
  	.name =		"anydata",
  	.probe =	usb_serial_probe,
  	.disconnect =	usb_serial_disconnect,
  	.id_table =	id_table,
! 	//.no_dynamic_id = 	1,
  };
  
! #define SET_LINE_REQUEST_TYPE		0x21
! #define SET_LINE_REQUEST		0x20
  
! #define SET_CONTROL_REQUEST_TYPE	0x21
! #define SET_CONTROL_REQUEST		0x22
! #define CONTROL_DTR			0x01
! #define CONTROL_RTS			0x02
! 
! #define BREAK_REQUEST_TYPE		0x21
! #define BREAK_REQUEST			0x23	
! #define BREAK_ON			0xffff
! #define BREAK_OFF			0x0000
! 
! #define GET_LINE_REQUEST_TYPE		0xa1
! #define GET_LINE_REQUEST		0x21
! 
! #define VENDOR_WRITE_REQUEST_TYPE	0x40
! #define VENDOR_WRITE_REQUEST		0x01
! 
! #define VENDOR_READ_REQUEST_TYPE	0xc0
! #define VENDOR_READ_REQUEST		0x01
! 
! #define UART_STATE			0x08
! #define UART_STATE_TRANSIENT_MASK	0x74
! #define UART_DCD			0x01
! #define UART_DSR			0x02
! #define UART_BREAK_ERROR		0x04
! #define UART_RING			0x08
! #define UART_FRAME_ERROR		0x10
! #define UART_PARITY_ERROR		0x20
! #define UART_OVERRUN_ERROR		0x40
! #define UART_CTS			0x80
! 
! /* function prototypes for a ANYDATA serial converter */
! static int anydata_open (struct usb_serial_port *port, struct file *filp);
! static void anydata_close (struct usb_serial_port *port, struct file *filp);
! static int anydata_ioctl (struct usb_serial_port *port, struct file *file,
! 			 unsigned int cmd, unsigned long arg);
! static void anydata_read_int_callback (struct urb *urb, struct pt_regs *regs);
! static void anydata_read_bulk_callback (struct urb *urb, struct pt_regs *regs);
! static void anydata_write_bulk_callback (struct urb *urb, struct pt_regs *regs);
! static int anydata_write (struct usb_serial_port *port,
! 			 const unsigned char *buf, int count);
! static void anydata_send (struct usb_serial_port *port);
! static int anydata_write_room(struct usb_serial_port *port);
! static int anydata_chars_in_buffer(struct usb_serial_port *port);
! static void anydata_break_ctl(struct usb_serial_port *port,int break_state);
! static int anydata_startup (struct usb_serial *serial);
! static void anydata_shutdown (struct usb_serial *serial);
! static struct anydata_buf *anydata_buf_alloc(unsigned int size);
! static void anydata_buf_free(struct anydata_buf *pb);
! static void anydata_buf_clear(struct anydata_buf *pb);
! static unsigned int anydata_buf_data_avail(struct anydata_buf *pb);
! static unsigned int anydata_buf_space_avail(struct anydata_buf *pb);
! static unsigned int anydata_buf_put(struct anydata_buf *pb, const char *buf,
! 	unsigned int count);
! static unsigned int anydata_buf_get(struct anydata_buf *pb, char *buf,
! 	unsigned int count);
  
  
+ /* All of the device info needed for the ANYDATA SIO serial converter */
  static struct usb_serial_driver anydata_device = {
  	.driver = {
  		.owner =	THIS_MODULE,
***************
*** 92,123 ****
  	.num_bulk_out =		NUM_DONT_CARE,
  	.num_ports =		1,
  	.open =			anydata_open,
  };
  
! static int __init anydata_init(void)
  {
  	int retval;
  
  	retval = usb_serial_register(&anydata_device);
  	if (retval)
! 		return retval;
  	retval = usb_register(&anydata_driver);
  	if (retval)
! 		usb_serial_deregister(&anydata_device);
  	return retval;
  }
  
! static void __exit anydata_exit(void)
  {
! 	usb_deregister(&anydata_driver);
! 	usb_serial_deregister(&anydata_device);
  }
  
  module_init(anydata_init);
  module_exit(anydata_exit);
  MODULE_LICENSE("GPL");
  
  module_param(debug, bool, S_IRUGO | S_IWUSR);
  MODULE_PARM_DESC(debug, "Debug enabled or not");
! module_param(buffer_size, int, 0);
! MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers");
--- 137,942 ----
  	.num_bulk_out =		NUM_DONT_CARE,
  	.num_ports =		1,
  	.open =			anydata_open,
+ 	.close =		anydata_close,
+ 	.write =		anydata_write,
+ 	.ioctl =		anydata_ioctl,
+ 	.break_ctl =		anydata_break_ctl,
+ 	.read_bulk_callback =	anydata_read_bulk_callback,
+ 	.read_int_callback =	anydata_read_int_callback,
+ 	.write_bulk_callback =	anydata_write_bulk_callback,
+ 	.write_room =		anydata_write_room,
+ 	.chars_in_buffer =	anydata_chars_in_buffer,
+ 	.attach =		anydata_startup,
+ 	.shutdown =		anydata_shutdown,
+ };
+ 
+ enum anydata_type {
+ 	type_0,		/* don't know the difference between type 0 and */
+ 	type_1,		/* type 1, until someone from prolific tells us... */
+ 	HX,		/* HX version of the anydata chip */
+ };
+ 
+ struct anydata_private {
+ 	spinlock_t lock;
+ 	struct anydata_buf *buf;
+ 	int write_urb_in_use;
+ 	wait_queue_head_t delta_msr_wait;
+ 	u8 line_control;
+ 	u8 line_status;
+ 	u8 termios_initialized;
+ 	enum anydata_type type;
  };
  
! 
! static int anydata_startup (struct usb_serial *serial)
! {
! 	struct anydata_private *priv;
! 	enum anydata_type type = type_0;
! 	int i;
! 
! 	if (serial->dev->descriptor.bDeviceClass == 0x02)
! 		type = type_0;
! 	else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
! 		type = HX;
! 	else if (serial->dev->descriptor.bDeviceClass == 0x00)
! 		type = type_1;
! 	else if (serial->dev->descriptor.bDeviceClass == 0xFF)
! 		type = type_1;
! 	dbg("device type: %d", type);
! 
! 	for (i = 0; i < serial->num_ports; ++i) {
! 		priv = kmalloc (sizeof (struct anydata_private), GFP_KERNEL);
! 		if (!priv)
! 			goto cleanup;
! 		memset (priv, 0x00, sizeof (struct anydata_private));
! 		spin_lock_init(&priv->lock);
! 		priv->buf = anydata_buf_alloc(ANYDATA_BUF_SIZE);
! 		if (priv->buf == NULL) {
! 			kfree(priv);
! 			goto cleanup;
! 		}
! 		init_waitqueue_head(&priv->delta_msr_wait);
! 		priv->type = type;
! 		usb_set_serial_port_data(serial->port[i], priv);
! 	}
! 	return 0;
! 
! cleanup:
! 	for (--i; i>=0; --i) {
! 		priv = usb_get_serial_port_data(serial->port[i]);
! 		anydata_buf_free(priv->buf);
! 		kfree(priv);
! 		usb_set_serial_port_data(serial->port[i], NULL);
! 	}
! 	return -ENOMEM;
! }
! 
! static int set_control_lines (struct usb_device *dev, u8 value)
  {
  	int retval;
+ 	
+ 	retval = usb_control_msg (dev, usb_sndctrlpipe (dev, 0),
+ 				  SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
+ 				  value, 0, NULL, 0, 100);
+ 	dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
+ 	return retval;
+ }
+ 
+ static int anydata_write (struct usb_serial_port *port,  const unsigned char *buf, int count)
+ {
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	unsigned long flags;
+ 
+ 	dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
+ 
+ 	if (!count)
+ 		return count;
+ 
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 	count = anydata_buf_put(priv->buf, buf, count);
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+ 	anydata_send(port);
+ 
+ 	return count;
+ }
+ 
+ static void anydata_send(struct usb_serial_port *port)
+ {
+ 	int count, result;
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	unsigned long flags;
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 
+ 	if (priv->write_urb_in_use) {
+ 		spin_unlock_irqrestore(&priv->lock, flags);
+ 		return;
+ 	}
+ 
+ 	count = anydata_buf_get(priv->buf, port->write_urb->transfer_buffer,
+ 		port->bulk_out_size);
+ 
+ 	if (count == 0) {
+ 		spin_unlock_irqrestore(&priv->lock, flags);
+ 		return;
+ 	}
+ 
+ 	priv->write_urb_in_use = 1;
+ 
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+ 	usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, port->write_urb->transfer_buffer);
+ 
+ 	port->write_urb->transfer_buffer_length = count;
+ 	port->write_urb->dev = port->serial->dev;
+ 	result = usb_submit_urb (port->write_urb, GFP_ATOMIC);
+ 	if (result) {
+ 		dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __FUNCTION__, result);
+ 		priv->write_urb_in_use = 0;
+ 		// TODO: reschedule anydata_send
+ 	}
+ 
+ 	schedule_work(&port->work);
+ }
+ 
+ static int anydata_write_room(struct usb_serial_port *port)
+ {
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	int room = 0;
+ 	unsigned long flags;
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 	room = anydata_buf_space_avail(priv->buf);
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+ 	dbg("%s - returns %d", __FUNCTION__, room);
+ 	return room;
+ }
+ 
+ static int anydata_chars_in_buffer(struct usb_serial_port *port)
+ {
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	int chars = 0;
+ 	unsigned long flags;
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 	chars = anydata_buf_data_avail(priv->buf);
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+ 	dbg("%s - returns %d", __FUNCTION__, chars);
+ 	return chars;
+ }
+ 
+ 
+ 
+ static int anydata_open (struct usb_serial_port *port, struct file *filp)
+ {
+ 	struct usb_serial *serial = port->serial;
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	unsigned char *buf;
+ 	int result;
+ 
+ 	dbg("%s -  port %d", __FUNCTION__, port->number);
+ 
+ 	if (priv->type != HX) {
+ 		usb_clear_halt(serial->dev, port->write_urb->pipe);
+ 		usb_clear_halt(serial->dev, port->read_urb->pipe);
+ 	}
+ 
+ 	buf = kmalloc(10, GFP_KERNEL);
+ 	if (buf==NULL)
+ 		return -ENOMEM;
+ 
+ #define FISH(a,b,c,d)								\
+ 	result=usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev,0),	\
+ 			       b, a, c, d, buf, 1, 100);			\
+ 	dbg("0x%x:0x%x:0x%x:0x%x  %d - %x",a,b,c,d,result,buf[0]);
+ 
+ #define SOUP(a,b,c,d)								\
+ 	result=usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev,0),	\
+ 			       b, a, c, d, NULL, 0, 100);			\
+ 	dbg("0x%x:0x%x:0x%x:0x%x  %d",a,b,c,d,result);
+ 
+ 	FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ 	SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 0);
+ 	FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ 	FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
+ 	FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ 	SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 1);
+ 	FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
+ 	FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
+ 	SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0, 1);
+ 	SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 1, 0);
+ 
+ 	if (priv->type == HX) {
+ 		/* HX chip */
+ 		SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x44);
+ 		/* reset upstream data pipes */
+           	SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 8, 0);
+         	SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 9, 0);
+ 	} else {
+ 		SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x24);
+ 	}
+ 
+ 	kfree(buf);
+ 
+ 	/* Setup termios */
+ 	//FIXME: need to assert RTS and DTR if CRTSCTS off
+ 
+ 	dbg("%s - submitting read urb", __FUNCTION__);
+ 	port->read_urb->dev = serial->dev;
+ 	result = usb_submit_urb (port->read_urb, GFP_KERNEL);
+ 	if (result) {
+ 		dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __FUNCTION__, result);
+ 		anydata_close (port, NULL);
+ 		return -EPROTO;
+ 	}
+ 
+ 	dbg("%s - submitting interrupt urb", __FUNCTION__);
+ 	port->interrupt_in_urb->dev = serial->dev;
+ 	result = usb_submit_urb (port->interrupt_in_urb, GFP_KERNEL);
+ 	if (result) {
+ 		dev_err(&port->dev, "%s - failed submitting interrupt urb, error %d\n", __FUNCTION__, result);
+ 		anydata_close (port, NULL);
+ 		return -EPROTO;
+ 	}
+ 	return 0;
+ }
+ 
+ 
+ static void anydata_close (struct usb_serial_port *port, struct file *filp)
+ {
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	unsigned long flags;
+ 	unsigned int c_cflag;
+ 	int bps;
+ 	long timeout;
+ 	wait_queue_t wait;						\
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	/* wait for data to drain from the buffer */
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 	timeout = ANYDATA_CLOSING_WAIT;
+ 	init_waitqueue_entry(&wait, current);
+ 	add_wait_queue(&port->tty->write_wait, &wait);
+ 	for (;;) {
+ 		set_current_state(TASK_INTERRUPTIBLE);
+ 		if (anydata_buf_data_avail(priv->buf) == 0
+ 		|| timeout == 0 || signal_pending(current)
+ 		|| !usb_get_intfdata(port->serial->interface))	/* disconnect */
+ 			break;
+ 		spin_unlock_irqrestore(&priv->lock, flags);
+ 		timeout = schedule_timeout(timeout);
+ 		spin_lock_irqsave(&priv->lock, flags);
+ 	}
+ 	set_current_state(TASK_RUNNING);
+ 	remove_wait_queue(&port->tty->write_wait, &wait);
+ 	/* clear out any remaining data in the buffer */
+ 	anydata_buf_clear(priv->buf);
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+ 	/* wait for characters to drain from the device */
+ 	/* (this is long enough for the entire 256 byte */
+ 	/* anydata hardware buffer to drain with no flow */
+ 	/* control for data rates of 1200 bps or more, */
+ 	/* for lower rates we should really know how much */
+ 	/* data is in the buffer to compute a delay */
+ 	/* that is not unnecessarily long) */
+ 	bps = tty_get_baud_rate(port->tty);
+ 	if (bps > 1200)
+ 		timeout = max((HZ*2560)/bps,HZ/10);
+ 	else
+ 		timeout = 2*HZ;
+ 	schedule_timeout_interruptible(timeout);
+ 
+ 	/* shutdown our urbs */
+ 	dbg("%s - shutting down urbs", __FUNCTION__);
+ 	usb_kill_urb(port->write_urb);
+ 	usb_kill_urb(port->read_urb);
+ 	usb_kill_urb(port->interrupt_in_urb);
+ 
+ 	if (port->tty) {
+ 		c_cflag = port->tty->termios->c_cflag;
+ 		if (c_cflag & HUPCL) {
+ 			/* drop DTR and RTS */
+ 			spin_lock_irqsave(&priv->lock, flags);
+ 			priv->line_control = 0;
+ 			spin_unlock_irqrestore (&priv->lock, flags);
+ 			set_control_lines (port->serial->dev, 0);
+ 		}
+ 	}
+ }
+ 
+ 
+ 
+ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
+ {
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	unsigned long flags;
+ 	unsigned int prevstatus;
+ 	unsigned int status;
+ 	unsigned int changed;
+ 
+ 	spin_lock_irqsave (&priv->lock, flags);
+ 	prevstatus = priv->line_status;
+ 	spin_unlock_irqrestore (&priv->lock, flags);
+ 
+ 	while (1) {
+ 		interruptible_sleep_on(&priv->delta_msr_wait);
+ 		/* see if a signal did it */
+ 		if (signal_pending(current))
+ 			return -ERESTARTSYS;
+ 		
+ 		spin_lock_irqsave (&priv->lock, flags);
+ 		status = priv->line_status;
+ 		spin_unlock_irqrestore (&priv->lock, flags);
+ 		
+ 		changed=prevstatus^status;
+ 		
+ 		if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
+ 		    ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
+ 		    ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
+ 		    ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
+ 			return 0;
+ 		}
+ 		prevstatus = status;
+ 	}
+ 	/* NOTREACHED */
+ 	return 0;
+ }
+ 
+ static int anydata_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
+ {
+ 	dbg("%s (%d) cmd = 0x%04x", __FUNCTION__, port->number, cmd);
+ 
+ 	switch (cmd) {
+ 		case TIOCMIWAIT:
+ 			dbg("%s (%d) TIOCMIWAIT", __FUNCTION__,  port->number);
+ 			return wait_modem_info(port, arg);
+ 
+ 		default:
+ 			dbg("%s not supported = 0x%04x", __FUNCTION__, cmd);
+ 			break;
+ 	}
+ 
+ 	return -ENOIOCTLCMD;
+ }
+ 
+ static void anydata_break_ctl (struct usb_serial_port *port, int break_state)
+ {
+ 	struct usb_serial *serial = port->serial;
+ 	u16 state;
+ 	int result;
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	if (break_state == 0)
+ 		state = BREAK_OFF;
+ 	else
+ 		state = BREAK_ON;
+ 	dbg("%s - turning break %s", __FUNCTION__, state==BREAK_OFF ? "off" : "on");
+ 
+ 	result = usb_control_msg (serial->dev, usb_sndctrlpipe (serial->dev, 0),
+ 				  BREAK_REQUEST, BREAK_REQUEST_TYPE, state, 
+ 				  0, NULL, 0, 100);
+ 	if (result)
+ 		dbg("%s - error sending break = %d", __FUNCTION__, result);
+ }
+ 
+ 
+ static void anydata_shutdown (struct usb_serial *serial)
+ {
+ 	int i;
+ 	struct anydata_private *priv;
+ 
+ 	dbg("%s", __FUNCTION__);
+ 
+ 	for (i = 0; i < serial->num_ports; ++i) {
+ 		priv = usb_get_serial_port_data(serial->port[i]);
+ 		if (priv) {
+ 			anydata_buf_free(priv->buf);
+ 			kfree(priv);
+ 			usb_set_serial_port_data(serial->port[i], NULL);
+ 		}
+ 	}		
+ }
+ 
+ static void anydata_update_line_status(struct usb_serial_port *port,
+ 				      unsigned char *data,
+ 				      unsigned int actual_length)
+ {
+ 
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	unsigned long flags;
+ 	u8 status_idx = UART_STATE;
+ 	u8 length = UART_STATE + 1;
+ 
  
+ 
+ 	if (actual_length < length)
+ 		goto exit;
+ 
+         /* Save off the uart status for others to look at */
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 	priv->line_status = data[status_idx];
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+ exit:
+ 	return;
+ }
+ 
+ static void anydata_read_int_callback (struct urb *urb, struct pt_regs *regs)
+ {
+ 	struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+ 	unsigned char *data = urb->transfer_buffer;
+ 	unsigned int actual_length = urb->actual_length;
+ 	int status;
+ 
+ 	dbg("%s (%d)", __FUNCTION__, port->number);
+ 
+ 	switch (urb->status) {
+ 	case 0:
+ 		/* success */
+ 		break;
+ 	case -ECONNRESET:
+ 	case -ENOENT:
+ 	case -ESHUTDOWN:
+ 		/* this urb is terminated, clean up */
+ 		dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+ 		return;
+ 	default:
+ 		dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+ 		goto exit;
+ 	}
+ 
+ 	usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
+ 	anydata_update_line_status(port, data, actual_length);
+ 
+ exit:
+ 	status = usb_submit_urb (urb, GFP_ATOMIC);
+ 	if (status)
+ 		dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with result %d\n",
+ 			__FUNCTION__, status);
+ }
+ 
+ 
+ static void anydata_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
+ {
+ 	struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	struct tty_struct *tty;
+ 	unsigned char *data = urb->transfer_buffer;
+ 	unsigned long flags;
+ 	int i;
+ 	int result;
+ 	u8 status;
+ 	char tty_flag;
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	if (urb->status) {
+ 		dbg("%s - urb->status = %d", __FUNCTION__, urb->status);
+ 		if (!port->open_count) {
+ 			dbg("%s - port is closed, exiting.", __FUNCTION__);
+ 			return;
+ 		}
+ 		if (urb->status == -EPROTO) {
+ 			/* ANYDATA mysteriously fails with -EPROTO reschedule the read */
+ 			dbg("%s - caught -EPROTO, resubmitting the urb", __FUNCTION__);
+ 			urb->status = 0;
+ 			urb->dev = port->serial->dev;
+ 			result = usb_submit_urb(urb, GFP_ATOMIC);
+ 			if (result)
+ 				dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
+ 			return;
+ 		}
+ 		dbg("%s - unable to handle the error, exiting.", __FUNCTION__);
+ 		return;
+ 	}
+ 
+ 	usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+ 
+ 	/* get tty_flag from status */
+ 	tty_flag = TTY_NORMAL;
+ 
+ 	spin_lock_irqsave(&priv->lock, flags);
+ 	status = priv->line_status;
+ 	priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 	wake_up_interruptible (&priv->delta_msr_wait);
+ 
+ 	/* break takes precedence over parity, */
+ 	/* which takes precedence over framing errors */
+ 	if (status & UART_BREAK_ERROR )
+ 		tty_flag = TTY_BREAK;
+ 	else if (status & UART_PARITY_ERROR)
+ 		tty_flag = TTY_PARITY;
+ 	else if (status & UART_FRAME_ERROR)
+ 		tty_flag = TTY_FRAME;
+ 	dbg("%s - tty_flag = %d", __FUNCTION__, tty_flag);
+ 
+ 	tty = port->tty;
+ 	if (tty && urb->actual_length) {
+ 			/* overrun is special, not associated with a char */
+ 		if (status & UART_OVERRUN_ERROR)
+ 			tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+ 		for (i = 0; i < urb->actual_length; ++i)
+ 			tty_insert_flip_char (tty, data[i], tty_flag);
+ 		tty_flip_buffer_push (tty);
+ 	}
+ 
+ 	/* Schedule the next read _if_ we are still open */
+ 	if (port->open_count) {
+ 		urb->dev = port->serial->dev;
+ 		result = usb_submit_urb(urb, GFP_ATOMIC);
+ 		if (result)
+ 			dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
+ 	}
+ 
+ 	return;
+ }
+ 
+ 
+ 
+ static void anydata_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
+ {
+ 	struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+ 	struct anydata_private *priv = usb_get_serial_port_data(port);
+ 	int result;
+ 
+ 	dbg("%s - port %d", __FUNCTION__, port->number);
+ 
+ 	switch (urb->status) {
+ 	case 0:
+ 		/* success */
+ 		break;
+ 	case -ECONNRESET:
+ 	case -ENOENT:
+ 	case -ESHUTDOWN:
+ 		/* this urb is terminated, clean up */
+ 		dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+ 		priv->write_urb_in_use = 0;
+ 		return;
+ 	default:
+ 		/* error in the urb, so we have to resubmit it */
+ 		dbg("%s - Overflow in write", __FUNCTION__);
+ 		dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
+ 		port->write_urb->transfer_buffer_length = 1;
+ 		port->write_urb->dev = port->serial->dev;
+ 		result = usb_submit_urb (port->write_urb, GFP_ATOMIC);
+ 		if (result)
+ 			dev_err(&urb->dev->dev, "%s - failed resubmitting write urb, error %d\n", __FUNCTION__, result);
+ 		else
+ 			return;
+ 	}
+ 
+ 	priv->write_urb_in_use = 0;
+ 
+ 	/* send any buffered data */
+ 	anydata_send(port);
+ }
+ 
+ 
+ /*
+  * anydata_buf_alloc
+  *
+  * Allocate a circular buffer and all associated memory.
+  */
+ 
+ static struct anydata_buf *anydata_buf_alloc(unsigned int size)
+ {
+ 
+ 	struct anydata_buf *pb;
+ 
+ 
+ 	if (size == 0)
+ 		return NULL;
+ 
+ 	pb = (struct anydata_buf *)kmalloc(sizeof(struct anydata_buf), GFP_KERNEL);
+ 	if (pb == NULL)
+ 		return NULL;
+ 
+ 	pb->buf_buf = kmalloc(size, GFP_KERNEL);
+ 	if (pb->buf_buf == NULL) {
+ 		kfree(pb);
+ 		return NULL;
+ 	}
+ 
+ 	pb->buf_size = size;
+ 	pb->buf_get = pb->buf_put = pb->buf_buf;
+ 
+ 	return pb;
+ 
+ }
+ 
+ 
+ /*
+  * anydata_buf_free
+  *
+  * Free the buffer and all associated memory.
+  */
+ 
+ static void anydata_buf_free(struct anydata_buf *pb)
+ {
+ 	if (pb) {
+ 		kfree(pb->buf_buf);
+ 		kfree(pb);
+ 	}
+ }
+ 
+ 
+ /*
+  * anydata_buf_clear
+  *
+  * Clear out all data in the circular buffer.
+  */
+ 
+ static void anydata_buf_clear(struct anydata_buf *pb)
+ {
+ 	if (pb != NULL)
+ 		pb->buf_get = pb->buf_put;
+ 		/* equivalent to a get of all data available */
+ }
+ 
+ 
+ /*
+  * anydata_buf_data_avail
+  *
+  * Return the number of bytes of data available in the circular
+  * buffer.
+  */
+ 
+ static unsigned int anydata_buf_data_avail(struct anydata_buf *pb)
+ {
+ 	if (pb != NULL)
+ 		return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
+ 	else
+ 		return 0;
+ }
+ 
+ 
+ /*
+  * anydata_buf_space_avail
+  *
+  * Return the number of bytes of space available in the circular
+  * buffer.
+  */
+ 
+ static unsigned int anydata_buf_space_avail(struct anydata_buf *pb)
+ {
+ 	if (pb != NULL)
+ 		return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
+ 	else
+ 		return 0;
+ }
+ 
+ 
+ /*
+  * anydata_buf_put
+  *
+  * Copy data data from a user buffer and put it into the circular buffer.
+  * Restrict to the amount of space available.
+  *
+  * Return the number of bytes copied.
+  */
+ 
+ static unsigned int anydata_buf_put(struct anydata_buf *pb, const char *buf,
+ 	unsigned int count)
+ {
+ 
+ 	unsigned int len;
+ 
+ 
+ 	if (pb == NULL)
+ 		return 0;
+ 
+ 	len  = anydata_buf_space_avail(pb);
+ 	if (count > len)
+ 		count = len;
+ 
+ 	if (count == 0)
+ 		return 0;
+ 
+ 	len = pb->buf_buf + pb->buf_size - pb->buf_put;
+ 	if (count > len) {
+ 		memcpy(pb->buf_put, buf, len);
+ 		memcpy(pb->buf_buf, buf+len, count - len);
+ 		pb->buf_put = pb->buf_buf + count - len;
+ 	} else {
+ 		memcpy(pb->buf_put, buf, count);
+ 		if (count < len)
+ 			pb->buf_put += count;
+ 		else /* count == len */
+ 			pb->buf_put = pb->buf_buf;
+ 	}
+ 
+ 	return count;
+ 
+ }
+ 
+ 
+ /*
+  * anydata_buf_get
+  *
+  * Get data from the circular buffer and copy to the given buffer.
+  * Restrict to the amount of data available.
+  *
+  * Return the number of bytes copied.
+  */
+ 
+ static unsigned int anydata_buf_get(struct anydata_buf *pb, char *buf,
+ 	unsigned int count)
+ {
+ 
+ 	unsigned int len;
+ 
+ 
+ 	if (pb == NULL)
+ 		return 0;
+ 
+ 	len = anydata_buf_data_avail(pb);
+ 	if (count > len)
+ 		count = len;
+ 
+ 	if (count == 0)
+ 		return 0;
+ 
+ 	len = pb->buf_buf + pb->buf_size - pb->buf_get;
+ 	if (count > len) {
+ 		memcpy(buf, pb->buf_get, len);
+ 		memcpy(buf+len, pb->buf_buf, count - len);
+ 		pb->buf_get = pb->buf_buf + count - len;
+ 	} else {
+ 		memcpy(buf, pb->buf_get, count);
+ 		if (count < len)
+ 			pb->buf_get += count;
+ 		else /* count == len */
+ 			pb->buf_get = pb->buf_buf;
+ 	}
+ 
+ 	return count;
+ 
+ }
+ 
+ static int __init anydata_init (void)
+ {
+ 	int retval;
  	retval = usb_serial_register(&anydata_device);
  	if (retval)
! 		goto failed_usb_serial_register;
  	retval = usb_register(&anydata_driver);
  	if (retval)
! 		goto failed_usb_register;
! 	info(DRIVER_DESC);
! 	return 0;
! failed_usb_register:
! 	usb_serial_deregister(&anydata_device);
! failed_usb_serial_register:
  	return retval;
  }
  
! 
! static void __exit anydata_exit (void)
  {
! 	usb_deregister (&anydata_driver);
! 	usb_serial_deregister (&anydata_device);
  }
  
+ 
  module_init(anydata_init);
  module_exit(anydata_exit);
+ 
+ MODULE_DESCRIPTION(DRIVER_DESC);
  MODULE_LICENSE("GPL");
  
  module_param(debug, bool, S_IRUGO | S_IWUSR);
  MODULE_PARM_DESC(debug, "Debug enabled or not");
! 



vyse uvedeny text oznacte (cely) a vlozte jej do textoveho editoru
ulote jej jako anydata.diff tento vznikli soubor skopirujte do adresare 
/cesta/k/vasim/zdrojum/linuxu/drivers/usb/serial/
 např" cp anydata.diff /usr/src/linux-2.6.15/drivers/usb/serial/" 
potom prejde do slozky kam jste skopirovaly anydata.diff 
napr" cd /usr/src/linux-2.6.15/drivers/usb/serial/"
a zadejte prikaz:  patch -p0 < anydata.diff