Subject: kernel 2.5.7, tiusb: SilverLink cable driver for TI graphing calculators

["Romain Liévin" <rlievin@free.fr>]

Hi,

this is a new driver for handling a TI-GRAPH LINK USB (aka SilverLink)
cable 
designed to connect a Texas Instruments graphing calculators to a 
computer/workstation through USB.

This driver has an official device number.


==============================[ tiglusb.c ]==========================
/* Hey EMACS -*- linux-c -*-
 *
 * tiglusb -- Texas Instruments' USB GraphLink (aka SilverLink) driver.
 * Target: Texas Instruments graphing calculators
(http://lpg.ticalc.org).
 *      
 * Copyright (C) 2001-2002: 
 *   Romain Lievin <roms@lpg.ticalc.org>
 *   Julien BLACHE <jb@technologeek.org>
 * under the terms of the GNU General Public License.
 *
 * Based on dabusb.c, printer.c & scanner.c
 *
 * Please see the file: linux/Documentation/usb/SilverLink.txt 
 * and the website at:  http://lpg.ticalc.org/prj_usb/
 * for more info.
 *
 */

#include <linux/module.h>
#include <linux/socket.h>
#include <linux/miscdevice.h>
#include <linux/list.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <linux/delay.h>
#include <linux/usb.h>
#include <linux/smp_lock.h>
#include <linux/devfs_fs_kernel.h>

#include "ticable.h"
#include "tiglusb.h"

/*
 * Version Information
 */
#define DRIVER_VERSION "1.01"
#define DRIVER_AUTHOR  "Romain Lievin <roms@lpg.ticalc.org> & Julien
Blache <jb@jblache.org>"
#define DRIVER_DESC    "TI-GRAPH LINK USB (aka SilverLink) driver"
#define DRIVER_LICENSE "GPL"

/* ----- global variables ---------------------------------------------
*/

static tiglusb_t tiglusb[MAXTIGL];
static int timeout = TIMAXTIME;     /* timeout in tenth of seconds    
*/

static devfs_handle_t devfs_handle;

/*---------- misc functions
-----------------------------------------------*/

/* Unregister device */
static void usblp_cleanup (tiglusb_t *s)
{
        devfs_unregister (s->devfs);
        //memset(tiglusb[s->minor], 0, sizeof(tiglusb_t));
        info ("tiglusb%d removed", s->minor);
}

/* Re-initialize device */
static int clear_device(struct usb_device *dev)
{
        if (usb_set_configuration (dev,
dev->config[0].bConfigurationValue) < 0)
        {
                printk("tiglusb: clear_device failed\n");
                return -1;
        }
        
        return 0;
}

/* Clear input & output pipes (endpoints) */
static int clear_pipes(struct usb_device *dev)
{
        unsigned int pipe;
        
        pipe = usb_sndbulkpipe (dev, 1);
        if(usb_clear_halt(dev, usb_pipeendpoint(pipe))) {
                printk("tiglusb: clear_pipe (r), request failed\n");
                return -1;
        }
  
        pipe = usb_sndbulkpipe (dev, 2);
        if(usb_clear_halt(dev, usb_pipeendpoint(pipe))) {
                printk("tiglusb: clear_pipe (w), request failed\n");
                return -1;
        }
        
        return 0;
}

/* ----- kernel module functions---------------------------------------
*/

// ok
static int tiglusb_open(struct inode *inode, struct file *file)
{
        int devnum = MINOR(inode->i_rdev);
        ptiglusb_t s;

        if (devnum < TIUSB_MINOR || devnum >= (TIUSB_MINOR + MAXTIGL))
                return -EIO;
        
        s = &tiglusb[devnum - TIUSB_MINOR];

        down(&s->mutex);

        while (!s->dev || s->opened) {
                up (&s->mutex);
                
                if (file->f_flags & O_NONBLOCK) {
                        return -EBUSY;
                }
                schedule_timeout (HZ / 2);
                
                if (signal_pending (current)) {
                        return -EAGAIN;
                }
                down (&s->mutex);
        }

        s->opened = 1;
        up(&s->mutex);
        
        file->f_pos = 0;
        file->private_data = s;

        return 0;
}

//ok
static int tiglusb_release(struct inode *inode, struct file *file)
{
        ptiglusb_t s = (ptiglusb_t) file->private_data;
        
        lock_kernel();
        down (&s->mutex);
        s->state = _stopped;
        up (&s->mutex);

        if (!s->remove_pending)
                clear_device(s->dev);
        else
                wake_up (&s->remove_ok);

        s->opened = 0;
        unlock_kernel();

        return 0;
}

//
static ssize_t tiglusb_read(struct file *file, char *buf, 
                            size_t count, loff_t * ppos)
{
        ptiglusb_t s = (ptiglusb_t) file->private_data;
        ssize_t ret = 0;
        int bytes_to_read = 0;
        int bytes_read = 0;
        int result = 0;
        char buffer[BULK_RCV_MAX];
        unsigned int pipe;

        if (*ppos)
                return -ESPIPE;
        
        if (s->remove_pending)
                return -EIO;
        
        if (!s->dev)
                return -EIO;
        
        bytes_to_read = (count >= BULK_RCV_MAX) ? BULK_RCV_MAX : count;

        pipe = usb_rcvbulkpipe (s->dev, 1);
        result = usb_bulk_msg(s->dev, pipe, buffer, bytes_to_read, 
                              &bytes_read, HZ/(timeout/10));
        //printk("hello: %i %i %i %i\n", 
        //     ETIMEDOUT, USB_ST_TIMEOUT, EPIPE, USB_ST_STALL);
        if (result == USB_ST_TIMEOUT) { /* NAK */
                ret = -ETIMEDOUT;
                if(!bytes_read) {
                        printk("quirk !\n");
                }
                warn("tiglusb_read, NAK received.");
                goto out;
        } 
        else if (result == USB_ST_STALL) { /* STALL -- shouldn't happen
*/
                warn("CLEAR_FEATURE request to remove STALL
condition.\n");
                if(usb_clear_halt(s->dev, usb_pipeendpoint(pipe)))
                        warn("send_packet, request failed\n");
                //clear_device(s->dev);
                ret = -EPIPE;
                goto out;
        }
        else if (result < 0) { /* We should not get any I/O errors */
                warn("funky result: %d. Please notify maintainer.",
result);
                ret = -EIO;
                goto out;
        }

        if (copy_to_user(buf, buffer, bytes_read)) {
                ret = -EFAULT;
                goto out;
        }
  
 out:
        return ret ? ret : bytes_read; 
}

//
static ssize_t tiglusb_write(struct file *file, const char *buf, 
                             size_t count, loff_t * ppos)
{
        ptiglusb_t s = (ptiglusb_t) file->private_data;
        ssize_t ret = 0;
        int bytes_to_write = 0;
        int bytes_written = 0;
        int result = 0;
        char buffer[BULK_SND_MAX];
        unsigned int pipe;
        
        if (*ppos)
                return -ESPIPE;
        
        if (s->remove_pending)
                return -EIO;
        
        if (!s->dev)
                return -EIO;
        
        bytes_to_write = (count >= BULK_SND_MAX) ? BULK_SND_MAX : count;
        if (copy_from_user(buffer, buf, bytes_to_write)) {
                ret = -EFAULT;
                goto out;
        }
        
        pipe = usb_sndbulkpipe (s->dev, 2);
        result = usb_bulk_msg(s->dev, pipe, buffer, bytes_to_write, 
                              &bytes_written, HZ/(timeout/10));

        if (result == USB_ST_TIMEOUT) { /* NAK */
                warn("tiglusb_write, NAK received.");
                ret = -ETIMEDOUT;
                goto out;
        }
        else if (result == USB_ST_STALL) { /* STALL -- shouldn't happen
*/
                warn("CLEAR_FEATURE request to remove STALL
condition.\n");
                if(usb_clear_halt(s->dev, usb_pipeendpoint(pipe)))
                        warn("send_packet, request failed\n");
                //clear_device(s->dev);
                ret = -EPIPE;
                goto out;
        }
        else if (result < 0) { /* We should not get any I/O errors */
                warn("funky result: %d. Please notify maintainer.",
result);
                ret = -EIO;
                goto out;
        }
        
        if (bytes_written != bytes_to_write) {
                ret = -EIO;
                goto out;
        } 
        
 out:
        return ret ? ret : bytes_written;
}

//ok
static int tiglusb_ioctl(struct inode *inode, struct file *file,
                              unsigned int cmd, unsigned long arg)
{
        ptiglusb_t s = (ptiglusb_t) file->private_data;
        int ret = 0;    

        if (s->remove_pending)
                return -EIO;
        
        down (&s->mutex);

        if (!s->dev) {
                up (&s->mutex);
                return -EIO;
        }
        
        switch (cmd)
        {
        case IOCTL_TIUSB_TIMEOUT:
                timeout = arg ; // timeout value is passed in tenth of
seconds
                break;
        case IOCTL_TIUSB_RESET_DEVICE:
                printk(KERN_DEBUG "IOCTL_TIGLUSB_RESET_DEVICE\n");
                if(clear_device(s->dev))
                        ret = -EIO;
                break;
        case IOCTL_TIUSB_RESET_PIPES:
                printk(KERN_DEBUG "IOCTL_TIGLUSB_RESET_PIPES\n");
                if(clear_pipes(s->dev))
                        ret = -EIO;
                break;
        default:
                ret = -ENOTTY;
                break;
        }
        
        up (&s->mutex);
        
        return ret;
}

/* ----- kernel module registering ------------------------------------
*/

static struct file_operations tiglusb_fops =
{
        owner:   THIS_MODULE,
        llseek:  no_llseek,
        read:    tiglusb_read,
        write:   tiglusb_write,
        ioctl:   tiglusb_ioctl,
        open:    tiglusb_open,
        release: tiglusb_release,
};

//ok
static int tiglusb_find_struct (void)
{
        int u;
        
        for (u=0; u<MAXTIGL; u++) 
        {
                ptiglusb_t s = &tiglusb[u];
                if (!s->dev)
                        return u;
        }
        
        return -1;
}

/* --- initialisation code ------------------------------------- */

//ok
static void *tiglusb_probe (struct usb_device *dev, unsigned int ifnum,
                            const struct usb_device_id *id)
{
        int minor;
        ptiglusb_t s;
        char name[8];
        
        printk("tiglusb: probing vendor id 0x%x, device id 0x%x
ifnum:%d\n",
               dev->descriptor.idVendor, dev->descriptor.idProduct,
ifnum);
        
        /* 
         * We don't handle multiple configurations. As of version 0x0103
of 
         * the TIGL hardware, there's only 1 configuration. 
         */
        
        if (dev->descriptor.bNumConfigurations != 1)
                return NULL;
        
        if ((dev->descriptor.idProduct != 0xe001) && 
            (dev->descriptor.idVendor != 0x451))
                return NULL;
        
        if (usb_set_configuration (dev,
dev->config[0].bConfigurationValue) < 0) {
                printk("tiglusb_probe: set_configuration failed\n");
                return NULL;
        }
        
        minor = tiglusb_find_struct ();
        if (minor == -1)
                return NULL;
        
        s = &tiglusb[minor];

        down (&s->mutex);
        s->remove_pending = 0;
        s->dev = dev;    
        up (&s->mutex);
        dbg("bound to interface: %d", ifnum);
        
        sprintf(name, "%d", s->minor);
        printk("tiglusb: registering to devfs : major = %d, minor = %d,
node = %s\n", TIUSB_MAJOR, (TIUSB_MINOR + s->minor), name);  
        s->devfs = devfs_register(devfs_handle, name,
                                  DEVFS_FL_DEFAULT, TIUSB_MAJOR,
                                  TIUSB_MINOR + s->minor,
                                  S_IFCHR | S_IRUGO | S_IWUGO,
                                  &tiglusb_fops, NULL);
        
        /* Display firmware version */
        printk("tiglusb: link cable version %i.%02x\n",
               dev->descriptor.bcdDevice >> 8,
               dev->descriptor.bcdDevice & 0xff);
        
        return s;
}

//ok
static void tiglusb_disconnect (struct usb_device *dev, void
*drv_context)
{
        ptiglusb_t s = (ptiglusb_t) drv_context;
        
        if (!s || !s->dev) 
                printk("bogus disconnect");
        
        s->remove_pending = 1;
        wake_up (&s->wait);
        if (s->state == _started)
                sleep_on (&s->remove_ok);
        s->dev = NULL;
        s->opened = 0;
        
        /* cleanup now or later, on close*/
        if (!s->opened)
                usblp_cleanup (s);
        else
                up (&s->mutex);
        
        /* unregister device */
        devfs_unregister(s->devfs); s->devfs = NULL;
        printk("tiglusb: device disconnected\n");
}

static struct usb_device_id tiglusb_ids [] = {
        { USB_DEVICE(0x0451, 0xe001) },
        { }
};

MODULE_DEVICE_TABLE (usb, tiglusb_ids);

static struct usb_driver tiglusb_driver =
{
        name:       "tiglusb",
        probe:      tiglusb_probe,
        disconnect: tiglusb_disconnect,
        fops:       &tiglusb_fops,
        minor:      TIUSB_MINOR,
        id_table:   tiglusb_ids,
};

/* --- initialisation code ------------------------------------- */

#ifndef MODULE
/*      You must set these - there is no sane way to probe for this
cable.
 *      You can use 'tipar=timeout,delay' to set these now. */
static int __init tiglusb_setup (char *str)
{
        int ints[2];

        str = get_options (str, ARRAY_SIZE(ints), ints);

        if (ints[0] > 0) {
                timeout = ints[1];
        }

        return 1;
}
#endif

static int __init tiglusb_init (void)
{
        unsigned u;
        int result;

        /* initialize struct */
        for (u = 0; u < MAXTIGL; u++)
        {
                ptiglusb_t s = &tiglusb[u];
                memset (s, 0, sizeof (tiglusb_t));
                init_MUTEX (&s->mutex);
                s->dev = NULL;
                s->minor = u;
                s->opened = 0;
                init_waitqueue_head (&s->wait);
                init_waitqueue_head (&s->remove_ok);
        }

        /* register device */
        if (devfs_register_chrdev (TIUSB_MAJOR, "tiglusb",
&tiglusb_fops)) {
            printk("tiglusb: unable to get major %d\n", TIUSB_MAJOR);
            return -EIO;
        }

        /* Use devfs, tree: /dev/ticables/usb/[0..3]*/
        devfs_handle = devfs_mk_dir(NULL, "ticables/usb", NULL);
        
        /* register USB module */
        result = usb_register(&tiglusb_driver);
        if (result < 0) {
            devfs_unregister_chrdev(TIUSB_MAJOR, "tiglusb");
            return -1;
        }
        
        info(DRIVER_DESC ", " DRIVER_VERSION);

        return 0;
}

static void __exit tiglusb_cleanup (void)
{
        usb_deregister (&tiglusb_driver);
        devfs_unregister (devfs_handle);
        devfs_unregister_chrdev(TIUSB_MAJOR, "tiglusb");
}

/* ---------------------------------------------------------------------
*/

__setup("tipar=", tiglusb_setup);
module_init(tiglusb_init);
module_exit(tiglusb_cleanup);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);

EXPORT_NO_SYMBOLS;

MODULE_PARM(timeout, "i");
MODULE_PARM_DESC(timeout, "Timeout (default=1.5 seconds)");

/* ---------------------------------------------------------------------
*/



==============================[ tiglusb.h ]========================
/* Hey EMACS -*- linux-c -*-
 *
 * tiglusb - low level driver for SilverLink cable
 *
 * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org>
 * under the terms of the GNU General Public License.
 *
 * Redistribution of this file is permitted under the terms of the GNU
 * Public License (GPL)
 */

#ifndef _TIGLUSB_H
#define _TIGLUSB_H

/*
 * Max. number of devices supported
 */
#define MAXTIGL 16

/*
 * Max. packetsize for IN and OUT pipes
 */
#define BULK_RCV_MAX 32
#define BULK_SND_MAX 32

/*
 * The driver context...
 */

typedef enum { _stopped=0, _started } driver_state_t;

typedef struct
{
        struct usb_device *dev;        /* USB device handle */
        struct semaphore  mutex;       /* locks this struct */
        struct semaphore  sem;
        
        wait_queue_head_t wait;        /* for timed waits */
        wait_queue_head_t remove_ok;   
        
        int minor;                     /* which minor dev #? */
        devfs_handle_t devfs;          /* devfs device */

        driver_state_t state;          /* started/stopped */
        int opened;                    /* tru if open */
        int remove_pending;            

        struct urb readurb, writeurb;  /* The urbs */
        int wcomplete, rcomplete;      /* R/W is complete */

        char rd_buf[BULK_RCV_MAX];     /* read  buffer */
        char wr_buf[BULK_SND_MAX];     /* write buffer */
        
} tiglusb_t, *ptiglusb_t;

extern devfs_handle_t usb_devfs_handle;                 /* /dev/usb dir.
*/

#endif


==============================[ ticable.h ]==========================
/* Hey EMACS -*- linux-c -*-
 *
 * tipar/tiser/tiusb - low level driver for handling link cables
 * designed for Texas Instruments graphing calculators.
 *
 * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org>
 *
 * Redistribution of this file is permitted under the terms of the GNU
 * Public License (GPL)
 */

#ifndef _TICABLE_H 
#define _TICABLE_H 1

/* Internal default constants for the kernel module */
#define TIMAXTIME 15      /* 1.5 seconds        */
#define IO_DELAY  10      /* 10 micro-seconds   */

/* Major & minor number for character devices */
#define TIPAR_MAJOR  115 /* 0 to 7 */
#define TIPAR_MINOR    0

#define TISER_MAJOR  115 /* 8 to 15 */
#define TISER_MINOR    8

#define TIUSB_MAJOR  115  /* 16 to 31 */
#define TIUSB_MINOR   16

/*
 * Request values for the 'ioctl' function.
 */
#define IOCTL_TIPAR_DELAY     _IOW('p', 0xa8, int) /* set delay   */
#define IOCTL_TIPAR_TIMEOUT   _IOW('p', 0xa9, int) /* set timeout */

#define IOCTL_TISER_DELAY     _IOW('p', 0xa0, int) /* set delay   */
#define IOCTL_TISER_TIMEOUT   _IOW('p', 0xa1, int) /* set timeout */

#define IOCTL_TIUSB_TIMEOUT        _IOW('N', 0x20, int) /* set timeout
*/
#define IOCTL_TIUSB_RESET_DEVICE   _IOW('N', 0x21, int) /* reset device
*/
#define IOCTL_TIUSB_RESET_PIPES    _IOW('N', 0x22, int) /* reset both
pipes*/

#endif /* TICABLE_H */

---
Romain LIEVIN aka Roms, mail: roms@lpg.ticalc.org
web: http://lpg.ticalc.org/prj_tilp (on www.ticalc.org)
ICQ: 43585029 (GtkIcq0.60/Linux)