Menu
▾
▴
[LV-kern-commit] CVS: kernel-2.4/drivers/usb/serial ipaq.c,NONE,1.1 ipaq.h,NONE,1.1 kl5kusb105.c,NONE,1.1 kl5kusb105.h,NONE,1.1
|
From: Dave A. <ai...@us...> - 2003-06-10 03:08:14
|
Update of /cvsroot/linux-vax/kernel-2.4/drivers/usb/serial
In directory sc8-pr-cvs1:/tmp/cvs-serv14646/drivers/usb/serial
Added Files:
ipaq.c ipaq.h kl5kusb105.c kl5kusb105.h
Log Message:
DA: additional files from 2.4.1[78] kernels..
--- NEW FILE ---
/*
* USB Compaq iPAQ driver
*
* Copyright (C) 2001
* Ganesh Varadarajan <ga...@ve...>
*
* 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.
*
*/
#include <linux/config.h>
#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/slab.h>
#include <linux/fcntl.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#ifdef CONFIG_USB_SERIAL_DEBUG
static int debug = 1;
#else
static int debug = 0;
#endif
#include "usb-serial.h"
#include "ipaq.h"
/*
* Version Information
*/
#define DRIVER_VERSION "v0.1"
#define DRIVER_AUTHOR "Ganesh Varadarajan <ga...@ve...>"
#define DRIVER_DESC "USB Compaq iPAQ driver"
/* Function prototypes for an ipaq */
static int ipaq_open (struct usb_serial_port *port, struct file *filp);
static void ipaq_close (struct usb_serial_port *port, struct file *filp);
static int ipaq_startup (struct usb_serial *serial);
static void ipaq_shutdown (struct usb_serial *serial);
static int ipaq_write(struct usb_serial_port *port, int from_user, const unsigned char *buf,
int count);
static int ipaq_write_bulk(struct usb_serial_port *port, int from_user, const unsigned char *buf,
int count);
static int ipaq_write_flush(struct usb_serial_port *port);
static void ipaq_read_bulk_callback (struct urb *urb);
static void ipaq_write_bulk_callback(struct urb *urb);
static int ipaq_write_room(struct usb_serial_port *port);
static int ipaq_chars_in_buffer(struct usb_serial_port *port);
static void ipaq_destroy_lists(struct usb_serial_port *port);
static __devinitdata struct usb_device_id ipaq_id_table [] = {
{ USB_DEVICE(IPAQ_VENDOR_ID, IPAQ_PRODUCT_ID) },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, ipaq_id_table);
/* All of the device info needed for the Compaq iPAQ */
struct usb_serial_device_type ipaq_device = {
name: "Compaq iPAQ",
id_table: ipaq_id_table,
needs_interrupt_in: MUST_HAVE_NOT,
needs_bulk_in: MUST_HAVE,
needs_bulk_out: MUST_HAVE,
num_interrupt_in: 0,
num_bulk_in: 1,
num_bulk_out: 1,
num_ports: 1,
open: ipaq_open,
close: ipaq_close,
startup: ipaq_startup,
shutdown: ipaq_shutdown,
write: ipaq_write,
write_room: ipaq_write_room,
chars_in_buffer: ipaq_chars_in_buffer,
read_bulk_callback: ipaq_read_bulk_callback,
write_bulk_callback: ipaq_write_bulk_callback,
};
static spinlock_t write_list_lock;
static int bytes_in;
static int bytes_out;
static int ipaq_open(struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
struct ipaq_private *priv;
struct ipaq_packet *pkt;
int i, result = 0;
if (port_paranoia_check(port, __FUNCTION__)) {
return -ENODEV;
}
dbg(__FUNCTION__ " - port %d", port->number);
down(&port->sem);
++port->open_count;
MOD_INC_USE_COUNT;
if (!port->active) {
port->active = 1;
bytes_in = 0;
bytes_out = 0;
priv = (struct ipaq_private *)kmalloc(sizeof(struct ipaq_private), GFP_KERNEL);
if (priv == NULL) {
err(__FUNCTION__ " - Out of memory");
return -ENOMEM;
}
port->private = (void *)priv;
priv->active = 0;
priv->queue_len = 0;
INIT_LIST_HEAD(&priv->queue);
INIT_LIST_HEAD(&priv->freelist);
for (i = 0; i < URBDATA_QUEUE_MAX / PACKET_SIZE; i++) {
pkt = kmalloc(sizeof(struct ipaq_packet), GFP_KERNEL);
if (pkt == NULL) {
goto enomem;
}
pkt->data = kmalloc(PACKET_SIZE, GFP_KERNEL);
if (pkt->data == NULL) {
kfree(pkt);
goto enomem;
}
pkt->len = 0;
pkt->written = 0;
INIT_LIST_HEAD(&pkt->list);
list_add(&pkt->list, &priv->freelist);
priv->free_len += PACKET_SIZE;
}
/*
* Force low latency on. This will immediately push data to the line
* discipline instead of queueing.
*/
port->tty->low_latency = 1;
/*
* Lose the small buffers usbserial provides. Make larger ones.
*/
kfree(port->bulk_in_buffer);
kfree(port->bulk_out_buffer);
port->bulk_in_buffer = kmalloc(URBDATA_SIZE, GFP_KERNEL);
if (port->bulk_in_buffer == NULL) {
goto enomem;
}
port->bulk_out_buffer = kmalloc(URBDATA_SIZE, GFP_KERNEL);
if (port->bulk_out_buffer == NULL) {
kfree(port->bulk_in_buffer);
goto enomem;
}
port->read_urb->transfer_buffer = port->bulk_in_buffer;
port->write_urb->transfer_buffer = port->bulk_out_buffer;
port->read_urb->transfer_buffer_length = URBDATA_SIZE;
port->bulk_out_size = port->write_urb->transfer_buffer_length = URBDATA_SIZE;
/* Start reading from the device */
FILL_BULK_URB(port->read_urb, serial->dev,
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
ipaq_read_bulk_callback, port);
result = usb_submit_urb(port->read_urb);
if (result) {
err(__FUNCTION__ " - failed submitting read urb, error %d", result);
}
/*
* Send out two control messages observed in win98 sniffs. Not sure what
* they do.
*/
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 0x22, 0x21,
0x1, 0, NULL, 0, 5 * HZ);
if (result < 0) {
err(__FUNCTION__ " - failed doing control urb, error %d", result);
}
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 0x22, 0x21,
0x1, 0, NULL, 0, 5 * HZ);
if (result < 0) {
err(__FUNCTION__ " - failed doing control urb, error %d", result);
}
}
up(&port->sem);
return result;
enomem:
ipaq_destroy_lists(port);
kfree(priv);
err(__FUNCTION__ " - Out of memory");
return -ENOMEM;
}
static void ipaq_close(struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial;
struct ipaq_private *priv = port->private;
if (port_paranoia_check(port, __FUNCTION__)) {
return;
}
dbg(__FUNCTION__ " - port %d", port->number);
serial = get_usb_serial(port, __FUNCTION__);
if (!serial)
return;
down (&port->sem);
--port->open_count;
if (port->open_count <= 0) {
/*
* shut down bulk read and write
*/
usb_unlink_urb(port->write_urb);
usb_unlink_urb(port->read_urb);
ipaq_destroy_lists(port);
kfree(priv);
port->private = NULL;
port->active = 0;
port->open_count = 0;
}
up (&port->sem);
/* Uncomment the following line if you want to see some statistics in your syslog */
/* info ("Bytes In = %d Bytes Out = %d", bytes_in, bytes_out); */
MOD_DEC_USE_COUNT;
}
static void ipaq_read_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
struct tty_struct *tty;
unsigned char *data = urb->transfer_buffer;
int i, result;
if (port_paranoia_check(port, __FUNCTION__))
return;
dbg(__FUNCTION__ " - port %d", port->number);
if (!serial) {
dbg(__FUNCTION__ " - bad serial pointer, exiting");
return;
}
if (urb->status) {
dbg(__FUNCTION__ " - nonzero read bulk status received: %d", urb->status);
return;
}
usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
tty = port->tty;
if (urb->actual_length) {
for (i = 0; i < urb->actual_length ; ++i) {
/* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
tty_flip_buffer_push(tty);
}
/* this doesn't actually push the data through unless tty->low_latency is set */
tty_insert_flip_char(tty, data[i], 0);
}
tty_flip_buffer_push(tty);
bytes_in += urb->actual_length;
}
/* Continue trying to always read */
FILL_BULK_URB(port->read_urb, serial->dev,
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
ipaq_read_bulk_callback, port);
result = usb_submit_urb(port->read_urb);
if (result)
err(__FUNCTION__ " - failed resubmitting read urb, error %d", result);
return;
}
static int ipaq_write(struct usb_serial_port *port, int from_user, const unsigned char *buf,
int count)
{
const unsigned char *current_position = buf;
int bytes_sent = 0;
int transfer_size;
dbg(__FUNCTION__ " - port %d", port->number);
usb_serial_debug_data(__FILE__, __FUNCTION__, count, buf);
while (count > 0) {
transfer_size = min(count, PACKET_SIZE);
if (ipaq_write_bulk(port, from_user, current_position, transfer_size)) {
break;
}
current_position += transfer_size;
bytes_sent += transfer_size;
count -= transfer_size;
bytes_out += transfer_size;
}
return bytes_sent;
}
static int ipaq_write_bulk(struct usb_serial_port *port, int from_user, const unsigned char *buf,
int count)
{
struct ipaq_private *priv = port->private;
struct ipaq_packet *pkt = NULL;
int result = 0;
unsigned long flags;
if (priv->free_len <= 0) {
dbg(__FUNCTION__ " - we're stuffed");
return -EAGAIN;
}
spin_lock_irqsave(&write_list_lock, flags);
if (!list_empty(&priv->freelist)) {
pkt = list_entry(priv->freelist.next, struct ipaq_packet, list);
list_del(&pkt->list);
priv->free_len -= PACKET_SIZE;
}
spin_unlock_irqrestore(&write_list_lock, flags);
if (pkt == NULL) {
dbg(__FUNCTION__ " - we're stuffed");
return -EAGAIN;
}
if (from_user) {
copy_from_user(pkt->data, buf, count);
} else {
memcpy(pkt->data, buf, count);
}
usb_serial_debug_data(__FILE__, __FUNCTION__, count, pkt->data);
pkt->len = count;
pkt->written = 0;
spin_lock_irqsave(&write_list_lock, flags);
list_add_tail(&pkt->list, &priv->queue);
priv->queue_len += count;
if (priv->active == 0) {
priv->active = 1;
result = ipaq_write_flush(port);
}
spin_unlock_irqrestore(&write_list_lock, flags);
return result;
}
static int ipaq_write_flush(struct usb_serial_port *port)
{
struct ipaq_private *priv = (struct ipaq_private *)port->private;
struct usb_serial *serial = port->serial;
int count, room, result;
struct ipaq_packet *pkt;
struct urb *urb = port->write_urb;
struct list_head *tmp;
if (urb->status == -EINPROGRESS) {
/* Should never happen */
err(__FUNCTION__ " - flushing while urb is active !");
return -EAGAIN;
}
room = URBDATA_SIZE;
for (tmp = priv->queue.next; tmp != &priv->queue;) {
pkt = list_entry(tmp, struct ipaq_packet, list);
tmp = tmp->next;
count = min(room, (int)(pkt->len - pkt->written));
memcpy(urb->transfer_buffer + (URBDATA_SIZE - room),
pkt->data + pkt->written, count);
room -= count;
pkt->written += count;
priv->queue_len -= count;
if (pkt->written == pkt->len) {
list_del(&pkt->list);
list_add(&pkt->list, &priv->freelist);
priv->free_len += PACKET_SIZE;
}
if (room == 0) {
break;
}
}
count = URBDATA_SIZE - room;
FILL_BULK_URB(port->write_urb, serial->dev,
usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
port->write_urb->transfer_buffer, count, ipaq_write_bulk_callback,
port);
result = usb_submit_urb(urb);
if (result) {
err(__FUNCTION__ " - failed submitting write urb, error %d", result);
}
return result;
}
static void ipaq_write_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
struct ipaq_private *priv = (struct ipaq_private *)port->private;
unsigned long flags;
if (port_paranoia_check (port, __FUNCTION__)) {
return;
}
dbg(__FUNCTION__ " - port %d", port->number);
if (urb->status) {
dbg(__FUNCTION__ " - nonzero write bulk status received: %d", urb->status);
}
spin_lock_irqsave(&write_list_lock, flags);
if (!list_empty(&priv->queue)) {
ipaq_write_flush(port);
} else {
priv->active = 0;
}
spin_unlock_irqrestore(&write_list_lock, flags);
queue_task(&port->tqueue, &tq_immediate);
mark_bh(IMMEDIATE_BH);
return;
}
static int ipaq_write_room(struct usb_serial_port *port)
{
struct ipaq_private *priv = (struct ipaq_private *)port->private;
dbg(__FUNCTION__ " - freelen %d", priv->free_len);
return priv->free_len;
}
static int ipaq_chars_in_buffer(struct usb_serial_port *port)
{
struct ipaq_private *priv = (struct ipaq_private *)port->private;
dbg(__FUNCTION__ " - queuelen %d", priv->queue_len);
return priv->queue_len;
}
static void ipaq_destroy_lists(struct usb_serial_port *port)
{
struct ipaq_private *priv = (struct ipaq_private *)port->private;
struct list_head *tmp;
struct ipaq_packet *pkt;
for (tmp = priv->queue.next; tmp != &priv->queue;) {
pkt = list_entry(tmp, struct ipaq_packet, list);
tmp = tmp->next;
kfree(pkt->data);
kfree(pkt);
}
for (tmp = priv->freelist.next; tmp != &priv->freelist;) {
pkt = list_entry(tmp, struct ipaq_packet, list);
tmp = tmp->next;
kfree(pkt->data);
kfree(pkt);
}
return;
}
static int ipaq_startup(struct usb_serial *serial)
{
dbg(__FUNCTION__);
usb_set_configuration(serial->dev, 1);
return 0;
}
static void ipaq_shutdown(struct usb_serial *serial)
{
int i;
dbg (__FUNCTION__);
/* stop reads and writes on all ports */
for (i=0; i < serial->num_ports; ++i) {
while (serial->port[i].open_count > 0) {
ipaq_close(&serial->port[i], NULL);
}
}
}
static int __init ipaq_init(void)
{
usb_serial_register(&ipaq_device);
info(DRIVER_DESC " " DRIVER_VERSION);
return 0;
}
static void __exit ipaq_exit(void)
{
usb_serial_deregister(&ipaq_device);
}
module_init(ipaq_init);
module_exit(ipaq_exit);
MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
MODULE_PARM(debug, "i");
MODULE_PARM_DESC(debug, "Debug enabled or not");
--- NEW FILE ---
/*
* USB Compaq iPAQ driver
*
* Copyright (C) 2001
* Ganesh Varadarajan <ga...@ve...>
*
* 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.
*
*
*/
#ifndef __LINUX_USB_SERIAL_IPAQ_H
#define __LINUX_USB_SERIAL_IPAQ_H
#define IPAQ_VENDOR_ID 0x049f
#define IPAQ_PRODUCT_ID 0x0003
/*
* Since we can't queue our bulk write urbs (don't know why - it just
* doesn't work), we can send down only one write urb at a time. The simplistic
* approach taken by the generic usbserial driver will work, but it's not good
* for performance. Therefore, we buffer upto URBDATA_QUEUE_MAX bytes of write
* requests coming from the line discipline. This is done by chaining them
* in lists of struct ipaq_packet, each packet holding a maximum of
* PACKET_SIZE bytes.
*
* ipaq_write() can be called from bottom half context; hence we can't
* allocate memory for packets there. So we initialize a pool of packets at
* the first open and maintain a freelist.
*
* The value of PACKET_SIZE was empirically determined by
* checking the maximum write sizes sent down by the ppp ldisc.
* URBDATA_QUEUE_MAX is set to 64K, which is the maximum TCP window size
* supported by the iPAQ.
*/
struct ipaq_packet {
char *data;
size_t len;
size_t written;
struct list_head list;
};
struct ipaq_private {
int active;
int queue_len;
int free_len;
struct list_head queue;
struct list_head freelist;
};
#define URBDATA_SIZE 4096
#define URBDATA_QUEUE_MAX (64 * 1024)
#define PACKET_SIZE 256
#endif
--- NEW FILE ---
/*
* KLSI KL5KUSB105 chip RS232 converter driver
*
* Copyright (C) 2001 Utz-Uwe Haus <ha...@uu...>
*
* 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.
*
* All information about the device was acquired using SniffUSB ans snoopUSB
* on Windows98.
* It was written out of frustration with the PalmConnect USB Serial adapter
* sold by Palm Inc.
* Neither Palm, nor their contractor (MCCI) or their supplier (KLSI) provided
* information that was not already available.
*
* It seems that KLSI bought some silicon-design information from ScanLogic,
* whose SL11R processor is at the core of the KL5KUSB chipset from KLSI.
[...1093 lines suppressed...]
usb_serial_deregister (&kl5kusb105d_device);
}
module_init (klsi_105_init);
module_exit (klsi_105_exit);
MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");
MODULE_PARM(debug, "i");
MODULE_PARM_DESC(debug, "enable extensive debugging messages");
/* FIXME: implement
MODULE_PARM(num_urbs, "i");
MODULE_PARM_DESC(num_urbs, "number of URBs to use in write pool");
*/
/* vim: set sts=8 ts=8 sw=8: */
--- NEW FILE ---
/*
* Definitions for the KLSI KL5KUSB105 serial port adapter
*/
/* vendor/product pairs that are known to contain this chipset */
#define PALMCONNECT_VID 0x0830
#define PALMCONNECT_PID 0x0080
#define KLSI_VID 0x05e9
#define KLSI_KL5KUSB105D_PID 0x00c0
/* Vendor commands: */
/* port table -- the chip supports up to 4 channels */
/* baud rates */
typedef enum {
kl5kusb105a_sio_b115200 = 0,
kl5kusb105a_sio_b57600 = 1,
kl5kusb105a_sio_b38400 = 2,
kl5kusb105a_sio_b19200 = 4,
kl5kusb105a_sio_b14400 = 5,
kl5kusb105a_sio_b9600 = 6,
kl5kusb105a_sio_b4800 = 8, /* unchecked */
kl5kusb105a_sio_b2400 = 9, /* unchecked */
kl5kusb105a_sio_b1200 = 0xa, /* unchecked */
kl5kusb105a_sio_b600 = 0xb /* unchecked */
} KL5KUSB105A_SIO_baudrate_t;
/* data bits */
#define kl5kusb105a_dtb_7 7
#define kl5kusb105a_dtb_8 8
/* requests: */
#define KL5KUSB105A_SIO_SET_DATA 1
#define KL5KUSB105A_SIO_POLL 2
#define KL5KUSB105A_SIO_CONFIGURE 3
/* values used for request KL5KUSB105A_SIO_CONFIGURE */
#define KL5KUSB105A_SIO_CONFIGURE_READ_ON 3
#define KL5KUSB105A_SIO_CONFIGURE_READ_OFF 2
/* Interpretation of modem status lines */
/* These need sorting out by individually connecting pins and checking
* results. FIXME!
* When data is being sent we see 0x30 in the lower byte; this must
* contain DSR and CTS ...
*/
#define KL5KUSB105A_DSR ((1<<4) | (1<<5))
#define KL5KUSB105A_CTS ((1<<5) | (1<<4))
#define KL5KUSB105A_WANTS_TO_SEND 0x30
//#define KL5KUSB105A_DTR /* Data Terminal Ready */
//#define KL5KUSB105A_CTS /* Clear To Send */
//#define KL5KUSB105A_CD /* Carrier Detect */
//#define KL5KUSB105A_DSR /* Data Set Ready */
//#define KL5KUSB105A_RxD /* Receive pin */
//#define KL5KUSB105A_LE
//#define KL5KUSB105A_RTS
//#define KL5KUSB105A_ST
//#define KL5KUSB105A_SR
//#define KL5KUSB105A_RI /* Ring Indicator */
/* vim: set ts=8 sts=8: */
|
