serial.c

Linux2.4.20针对三星公司的s3c2440内核基础上的一些设备驱动代码

/*
 * serial_fd/serial.c
 *
 * Copyright (c) 2000, 2001, 2002 Lineo
 * Copyright (c) 2001 Hewlett Packard
 *
 * By: 
 *      Stuart Lynne <[e-mail]>, 
 *      Tom Rushworth <[e-mail]>, 
 *      Bruce Balden <[e-mail]>
 *
 * Changes copyright (c) 2003 MontaVista Software, Inc.
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/* 
 * The encapsultaion is designed to overcome difficulties with some USB hardware.
 *
 * While the USB protocol has a CRC over the data while in transit, i.e. while
 * being carried over the bus, there is no end to end protection. If the hardware
 * has any problems getting the data into or out of the USB transmit and receive
 * FIFO's then data can be lost. 
 *
 * This protocol adds a two byte trailer to each USB packet to specify the number
 * of bytes of valid data and a 10 bit CRC that will allow the receiver to verify
 * that the entire USB packet was received without error.
 *
 * This means we now have end to end protection from the class driver to the function
 * driver and back.
 *
 * There is an additional option that can be used to force all transmitted packets
 * to be padded to the maximum packet size. This provides a work around for some
 * devices which have problems with small USB packets.
 *
 * Assuming a packetsize of N:
 *
 *      0..N-2  data and optional padding
 *
 *      N-2     bits 7-2 - number of bytes of valid data
 *              bits 1-0 top two bits of 10 bit CRC
 *      N-1     bottom 8 bits of 10 bit CRC
 *
 *
 *      | Data Length       | 10 bit CRC                                |
 *      + 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 | 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 +
 *      
 * The 10 bit CRC is computed across the sent data, followed by the trailer with
 * the length set and the CRC set to zero. The CRC is then OR'd into the trailer.
 *
 * When received a 10 bit CRC is computed over the entire frame including the trailer
 * and should be equal to zero.
 *
 * Two module parameters are used to control the encapsulation, if both are
 * turned of the module works as a simple serial device with NO
 * encapsulation.
 *
 * See linux/drivers/usb/serial/safe_serial.c for a host class driver
 * implementation of this.
 *
 */


#include <linux/config.h>
#include <linux/module.h>

#include "../usbd-export.h"
#include "../usbd-build.h"
#include "../usbd-module.h"


MODULE_AUTHOR ("[e-mail], [e-mail]");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION ("USB Device Serial Function");

USBD_MODULE_INFO ("serial_fd 0.1-beta");

#ifndef MODULE
#undef GET_USE_COUNT
#define GET_USE_COUNT(foo) 1
#endif

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <net/arp.h>
#include <linux/rtnetlink.h>
#include <linux/smp_lock.h>
#include <linux/ctype.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/atmdev.h>
#include <linux/pkt_sched.h>

#include "../usbd.h"
#include "../usbd-func.h"
#include "../usbd-bus.h"
#include "../usbd-debug.h"
#include "../usbd-inline.h"
#include "../usbd-arch.h"

#include "crc10.h"

#include "serproto.h"

#if 0
#define MIN(a, b) ({            \
        typeof(a) _a = (a);     \
        typeof(b) _b = (b);     \
        _a < _b ? _a : _b;      \
})
#endif


#define MAX_INTERFACES 1

#define MTU                             1500+100


#if !defined (CONFIG_USBD_VENDORID) && !defined(CONFIG_USBD_SERIAL_VENDORID)
#error No Vendor ID
#endif
#if !defined (CONFIG_USBD_PRODUCTID) && !defined(CONFIG_USBD_SERIAL_PRODUCTID)
#error No Product ID
#endif


#if CONFIG_USBD_SERIAL_VENDORID
#undef CONFIG_USBD_VENDORID
#define CONFIG_USBD_VENDORID CONFIG_USBD_SERIAL_VENDORID
#endif

#if CONFIG_USBD_SERIAL_PRODUCTID
#undef CONFIG_USBD_PRODUCTID
#define CONFIG_USBD_PRODUCTID CONFIG_USBD_SERIAL_PRODUCTID
#endif

#ifndef CONFIG_USBD_SERIAL_NUMBER_STR
#define CONFIG_USBD_SERIAL_NUMBER_STR           ""
#endif


#ifdef CONFIG_USBD_SELFPOWERED
#define BMATTRIBUTE BMATTRIBUTE_RESERVED | BMATTRIBUTE_SELF_POWERED
#define BMAXPOWER 0
#else
#define BMATTRIBUTE BMATTRIBUTE_RESERVED
#define BMAXPOWER CONFIG_USBD_MAXPOWER
#endif


/*
 * setup some default values for pktsizes and endpoint addresses.
 */

#ifndef CONFIG_USBD_SERIAL_OUT_PKTSIZE
#define CONFIG_USBD_SERIAL_OUT_PKTSIZE             64
#endif

#ifndef CONFIG_USBD_SERIAL_IN_PKTSIZE
#define CONFIG_USBD_SERIAL_IN_PKTSIZE              64
#endif

#ifndef CONFIG_USBD_SERIAL_INT_PKTSIZE
#define CONFIG_USBD_SERIAL_INT_PKTSIZE             16
#endif

#ifndef CONFIG_USBD_SERIAL_OUT_ENDPOINT
#define CONFIG_USBD_SERIAL_OUT_ENDPOINT            1
#endif

#ifndef CONFIG_USBD_SERIAL_IN_ENDPOINT
#define CONFIG_USBD_SERIAL_IN_ENDPOINT             2
#endif

#ifndef CONFIG_USBD_SERIAL_INT_ENDPOINT
#define CONFIG_USBD_SERIAL_INT_ENDPOINT                3
#endif


/*
 * check for architecture specific endpoint configurations
 */

#if     defined(ABS_OUT_ADDR)
#warning
#warning USING ABS ENDPOINT OUT ADDRESS
#undef CONFIG_USBD_SERIAL_OUT_ENDPOINT

#if     ABS_OUT_ADDR > 0
#define CONFIG_USBD_SERIAL_OUT_ENDPOINT            ABS_OUT_ADDR
#endif

#elif   defined(MAX_OUT_ADDR) && defined(CONFIG_USBD_SERIAL_OUT_ENDPOINT) && (CONFIG_USBD_SERIAL_OUT_ENDPOINT > MAX_OUT_ADDR)
#warning
#warning USING DEFAULT ENDPOINT OUT ADDRESS
#undef CONFIG_USBD_SERIAL_OUT_ENDPOINT
#define CONFIG_USBD_SERIAL_OUT_ENDPOINT            DFL_OUT_ADDR
#endif


#if     defined(ABS_IN_ADDR)
#warning
#warning USING ABS ENDPOINT IN ADDRESS
#undef CONFIG_USBD_SERIAL_IN_ENDPOINT

#if     ABS_IN_ADDR
#define CONFIG_USBD_SERIAL_IN_ENDPOINT             ABS_IN_ADDR
#endif

#elif   defined(MAX_IN_ADDR) && defined(CONFIG_USBD_SERIAL_IN_ENDPOINT) && (CONFIG_USBD_SERIAL_IN_ENDPOINT > MAX_IN_ADDR)
#warning
#warning USING DEFAULT ENDPOINT IN ADDRESS
#undef CONFIG_USBD_SERIAL_IN_ENDPOINT
#define CONFIG_USBD_SERIAL_IN_ENDPOINT             DFL_IN_ADDR
#endif


#if     defined(ABS_INT_ADDR)
#warning
#warning USING ABS ENDPOINT INT ADDRESS
#undef CONFIG_USBD_SERIAL_INT_ENDPOINT

#if     ABS_INT_ADDR
#define CONFIG_USBD_SERIAL_INT_ENDPOINT            ABS_INT_ADDR
#endif

#elif   defined(MAX_INT_ADDR) && defined(CONFIG_USBD_SERIAL_INT_ENDPOINT) && (CONFIG_USBD_SERIAL_INT_ENDPOINT > MAX_INT_ADDR)
#warning
#warning USING DEFAULT ENDPOINT INT ADDRESS
#undef CONFIG_USBD_SERIAL_INT_ENDPOINT
#define CONFIG_USBD_SERIAL_INT_ENDPOINT            DFL_INT_ADDR
#endif



#if     defined(MAX_OUT_PKTSIZE) && defined(CONFIG_USBD_SERIAL_OUT_PKTSIZE) && CONFIG_USBD_SERIAL_OUT_PKTSIZE > MAX_OUT_PKTSIZE
#warning
#warning OVERIDING ENDPOINT OUT PKTSIZE
#undef CONFIG_USBD_SERIAL_OUT_PKTSIZE
#define CONFIG_USBD_SERIAL_OUT_PKTSIZE             MAX_OUT_PKTSIZE
#endif

#if     defined(MAX_IN_PKTSIZE) && defined(CONFIG_USBD_SERIAL_IN_PKTSIZE) && CONFIG_USBD_SERIAL_IN_PKTSIZE > MAX_IN_PKTSIZE
#warning
#warning OVERIDING ENDPOINT IN PKTSIZE
#undef CONFIG_USBD_SERIAL_IN_PKTSIZE
#define CONFIG_USBD_SERIAL_IN_PKTSIZE              MAX_IN_PKTSIZE
#endif

#if     defined(MAX_INT_PKTSIZE) && defined(CONFIG_USBD_SERIAL_INT_PKTSIZE) && CONFIG_USBD_SERIAL_INT_PKTSIZE > MAX_INT_PKTSIZE
#warning
#warning OVERIDING ENDPOINT INT PKTSIZE
#undef CONFIG_USBD_SERIAL_INT_PKTSIZE
#define CONFIG_USBD_SERIAL_INT_PKTSIZE             MAX_INT_PKTSIZE
#endif




struct usb_serial_private {
	int interface;
	struct usb_device_instance *device;
	rwlock_t rwlock;
};

/* Module Parameters ************************************************************************* */

static char *dbg = NULL;
static u32 vendor_id;
static u32 product_id;
static u32 txqueue_urbs;
static u32 txqueue_bytes = 3032;

#ifndef CONFIG_USBD_SERIAL_SAFE_DEFAULT
#define CONFIG_USBD_SERIAL_SAFE_DEFAULT 0
#endif
#ifndef CONFIG_USBD_SERIAL_SAFE_PADDED
#define CONFIG_USBD_SERIAL_SAFE_PADDED 0
#endif

static int safe = CONFIG_USBD_SERIAL_SAFE_DEFAULT;
static int padded = CONFIG_USBD_SERIAL_SAFE_PADDED;

MODULE_PARM (dbg, "s");
MODULE_PARM (vendor_id, "i");
MODULE_PARM (product_id, "i");
MODULE_PARM (txqueue_urbs, "i");
MODULE_PARM (txqueue_bytes, "i");
MODULE_PARM (safe, "i");
MODULE_PARM (padded, "i");

MODULE_PARM_DESC (dbg, "USB Device Debug options");
MODULE_PARM_DESC (vendor_id, "USB Device Vendor ID");
MODULE_PARM_DESC (product_id, "USB Device Product ID");
MODULE_PARM_DESC (txqueue_urbs, "Maximum TX Queue Urbs");
MODULE_PARM_DESC (txqueue_bytes, "Maximum TX Queue Bytes");
MODULE_PARM_DESC (safe, "Safe Encapsulation");
MODULE_PARM_DESC (padded, "Safe Encapsulation Padding");



/* Debug switches (module parameter "dbg=...") *********************************************** */

extern int dbgflg_usbdfd_init;
int dbgflg_usbdfd_usbe;
int dbgflg_usbdfd_tx;
int dbgflg_usbdfd_rx;
int dbgflg_usbdfd_loopback;

static debug_option dbg_table[] = {
	{&dbgflg_usbdfd_init, NULL, "init", "initialization and termination"},
	{&dbgflg_usbdfd_usbe, NULL, "usbe", "USB events"},
	{&dbgflg_usbdfd_rx, NULL, "rx", "receive (from host)"},
	{&dbgflg_usbdfd_tx, NULL, "tx", "transmit (to host)"},
	{&dbgflg_usbdfd_loopback, NULL, "loop", "loopback mode if non-zero"},
	{NULL, NULL, "ser", "serial device (tty) handling"},
	{NULL, NULL, NULL, NULL}
};

#define dbg_init(lvl,fmt,args...) dbgPRINT(dbgflg_usbdfd_init,lvl,fmt,##args)
#define dbg_usbe(lvl,fmt,args...) dbgPRINT(dbgflg_usbdfd_usbe,lvl,fmt,##args)
#define dbg_rx(lvl,fmt,args...) dbgPRINT(dbgflg_usbdfd_rx,lvl,fmt,##args)
#define dbg_tx(lvl,fmt,args...) dbgPRINT(dbgflg_usbdfd_tx,lvl,fmt,##args)
#define dbg_loop(lvl,fmt,args...) dbgPRINT(dbgflg_usbdfd_loopback,lvl,fmt,##args)

/* ******************************************************************************************* */

static int serial_created;

static struct usb_serial_private *serial_private_array[MAX_INTERFACES];

static rwlock_t serial_rwlock = RW_LOCK_UNLOCKED;	// lock for serproto device array access

static __inline__ struct usb_serial_private *get_serial_private (int interface)
{
	if (interface < 0 || interface >= MAX_INTERFACES) {
		return NULL;
	}
	return serial_private_array[interface];
}


/* usb-func.c ******************************************************************************** */


/* Communications Interface Class descriptions 
 */

static struct usb_endpoint_description serial_default[] = {
      {bEndpointAddress:CONFIG_USBD_SERIAL_OUT_ENDPOINT,
	      bmAttributes:BULK,
	      wMaxPacketSize:CONFIG_USBD_SERIAL_OUT_PKTSIZE,
	      bInterval:0,
	      direction:OUT,
      transferSize:CONFIG_USBD_SERIAL_OUT_PKTSIZE,},

      {bEndpointAddress:CONFIG_USBD_SERIAL_IN_ENDPOINT,
	      bmAttributes:BULK,
	      wMaxPacketSize:CONFIG_USBD_SERIAL_IN_PKTSIZE,
	      bInterval:0,
	      direction:IN,
      transferSize:CONFIG_USBD_SERIAL_IN_PKTSIZE,},

#if defined(CONFIG_USBD_SERIAL_INT_ENDPOINT) && (CONFIG_USBD_SERIAL_INT_ENDPOINT > 0)
      {bEndpointAddress:CONFIG_USBD_SERIAL_INT_ENDPOINT,
	      bmAttributes:INTERRUPT,
	      wMaxPacketSize:CONFIG_USBD_SERIAL_INT_PKTSIZE,
	      bInterval:0,
	      direction:IN,
      transferSize:CONFIG_USBD_SERIAL_INT_PKTSIZE,},
#endif

};


/* Data Interface Alternate description(s)
 */
static __devinitdata struct usb_alternate_description serial_data_alternate_descriptions[] = {
      {iInterface:"Simple Serial Data Interface - Bulk mode",
	      bAlternateSetting:0,
	      endpoints:sizeof (serial_default) /
	 sizeof (struct usb_endpoint_description),
      endpoint_list:serial_default,},
};

/* Interface description(s)
 */
static __devinitdata struct usb_interface_description serial_interfaces[] = {
      {iInterface:"Simple Serial Data Interface",
	      bInterfaceClass:LINEO_CLASS,
	      bInterfaceSubClass:LINEO_SUBCLASS_SAFESERIAL,
	      bInterfaceProtocol:LINEO_SAFESERIAL_CRC,
	      alternates:sizeof (serial_data_alternate_descriptions) /
	 sizeof (struct usb_alternate_description),
      alternate_list:serial_data_alternate_descriptions,},
};


#ifdef CONFIG_USBD_SERIAL_CDC
/*
 * CDC ACM Configuration
 */


/* Communication Interface Class descriptions
 */
static struct usb_class_description cdc_comm_class_descriptions[] = {
	{ CS_INTERFACE, USB_ST_HEADER,  0, { header: { bcdCDC: CLASS_BCD_VERSION, } }},
	{ CS_INTERFACE, USB_ST_UF,      1, { union_function: { bMasterInterface: 0, bSlaveInterface: { 1 }, }}},
	{ CS_INTERFACE, USB_ST_CMF,     0, { call_management: { bmCapabilities: 0, bDataInterface: 1, }}},
	{ CS_INTERFACE, USB_ST_ACMF,    0, { abstract_control: { bmCapabilities: 0, }}},
};


/* Data Interface Alternate 1 endpoints
 */
static __devinitdata struct usb_endpoint_description serial_alt_1_endpoints[] = {
      {bEndpointAddress:CONFIG_USBD_SERIAL_OUT_ENDPOINT,
	      bmAttributes:BULK,
	      wMaxPacketSize:CONFIG_USBD_SERIAL_OUT_PKTSIZE,
	      bInterval:0,
	      direction:OUT,
      transferSize:CONFIG_USBD_SERIAL_OUT_PKTSIZE,},

      {bEndpointAddress:CONFIG_USBD_SERIAL_IN_ENDPOINT,
	      bmAttributes:BULK,
	      wMaxPacketSize:CONFIG_USBD_SERIAL_IN_PKTSIZE,
	      bInterval:0,
	      direction:IN,
      transferSize:CONFIG_USBD_SERIAL_OUT_PKTSIZE,},

#if defined(CONFIG_USBD_SERIAL_INT_ENDPOINT) && (CONFIG_USBD_SERIAL_INT_ENDPOINT > 0)
      {bEndpointAddress:CONFIG_USBD_SERIAL_INT_ENDPOINT,
	      bmAttributes:INTERRUPT,
	      wMaxPacketSize:CONFIG_USBD_SERIAL_INT_PKTSIZE,
	      bInterval:0,
	      direction:IN,
      transferSize:CONFIG_USBD_SERIAL_INT_PKTSIZE,},
#endif
};


/* Data Interface Alternate description(s)
 */
static __devinitdata struct usb_alternate_description cdc_comm_alternate_descriptions[] = {
      {iInterface:"CDC ACM Comm Interface",
	      bAlternateSetting:0,
	      classes:sizeof (cdc_comm_class_descriptions) /
	 sizeof (struct usb_class_description),
      class_list:cdc_comm_class_descriptions,},
};

static __devinitdata struct usb_alternate_description cdc_data_alternate_descriptions[] = {
      {iInterface:"CDC ACM Data Interface - Disabled mode",
#ifdef CONFIG_ARCH_LUBBOCK
      bAlternateSetting:1,},
#else
      bAlternateSetting:0,},
#endif
      {iInterface:"CDC ACM Data Interface - Bulk mode",

#ifdef CONFIG_ARCH_LUBBOCK
	      bAlternateSetting:0,
#else
	      bAlternateSetting:1,
#endif
	      endpoints:sizeof (serial_alt_1_endpoints) /
	 sizeof (struct usb_endpoint_description),
      endpoint_list:serial_alt_1_endpoints,},
};


/* Interface description(s)
 */
static __devinitdata struct usb_interface_description cdc_interfaces[] = {
      {iInterface:"CDC ACM Communication Interface",
	      bInterfaceClass:COMMUNICATIONS_INTERFACE_CLASS,
	      bInterfaceSubClass:COMMUNICATIONS_ACM_SUBCLASS,
	      bInterfaceProtocol:COMMUNICATIONS_NO_PROTOCOL,
	      alternates:sizeof (cdc_comm_alternate_descriptions) /
	 sizeof (struct usb_alternate_description),
      alternate_list:cdc_comm_alternate_descriptions,},

      {iInterface:"CDC ACM Data Interface",
	      bInterfaceClass:DATA_INTERFACE_CLASS,
	      bInterfaceSubClass:COMMUNICATIONS_NO_SUBCLASS,
	      bInterfaceProtocol:COMMUNICATIONS_NO_PROTOCOL,
	      alternates:sizeof (cdc_data_alternate_descriptions) /
	 sizeof (struct usb_alternate_description),
      alternate_list:cdc_data_alternate_descriptions,},
};

#endif				/* CONFIG_USBD_SERIAL_CDC */