diff options
Diffstat (limited to 'drivers')
| -rw-r--r-- | drivers/staging/Kconfig | 2 | ||||
| -rw-r--r-- | drivers/staging/Makefile | 1 | ||||
| -rw-r--r-- | drivers/staging/frontier/Kconfig | 6 | ||||
| -rw-r--r-- | drivers/staging/frontier/Makefile | 2 | ||||
| -rw-r--r-- | drivers/staging/frontier/README | 28 | ||||
| -rw-r--r-- | drivers/staging/frontier/TODO | 9 | ||||
| -rw-r--r-- | drivers/staging/frontier/alphatrack.c | 901 | ||||
| -rw-r--r-- | drivers/staging/frontier/alphatrack.h | 117 | ||||
| -rw-r--r-- | drivers/staging/frontier/alphatrack_sysfs.c | 279 | ||||
| -rw-r--r-- | drivers/staging/frontier/frontier_compat.h | 63 | ||||
| -rw-r--r-- | drivers/staging/frontier/surface_sysfs.h | 100 | ||||
| -rw-r--r-- | drivers/staging/frontier/tranzport.c | 1017 |
12 files changed, 2525 insertions, 0 deletions
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig index e2f57e9b694..15f2b1148df 100644 --- a/drivers/staging/Kconfig +++ b/drivers/staging/Kconfig @@ -89,5 +89,7 @@ source "drivers/staging/rspiusb/Kconfig" source "drivers/staging/mimio/Kconfig" +source "drivers/staging/frontier/Kconfig" + endif # !STAGING_EXCLUDE_BUILD endif # STAGING diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile index 94efc9df5a8..d33803092b6 100644 --- a/drivers/staging/Makefile +++ b/drivers/staging/Makefile @@ -27,3 +27,4 @@ obj-$(CONFIG_ALTERA_PCIE_CHDMA) += altpciechdma/ obj-$(CONFIG_RTL8187SE) += rtl8187se/ obj-$(CONFIG_USB_RSPI) += rspiusb/ obj-$(CONFIG_INPUT_MIMIO) += mimio/ +obj-$(CONFIG_TRANZPORT) += frontier/ diff --git a/drivers/staging/frontier/Kconfig b/drivers/staging/frontier/Kconfig new file mode 100644 index 00000000000..7121853bd39 --- /dev/null +++ b/drivers/staging/frontier/Kconfig @@ -0,0 +1,6 @@ +config TRANZPORT + tristate "Frontier Tranzport and Alphatrack support" + depends on USB + default N + ---help--- + Enable support for the Frontier Tranzport and Alphatrack devices. diff --git a/drivers/staging/frontier/Makefile b/drivers/staging/frontier/Makefile new file mode 100644 index 00000000000..2d2ac97492d --- /dev/null +++ b/drivers/staging/frontier/Makefile @@ -0,0 +1,2 @@ +obj-$(CONFIG_TRANZPORT) += tranzport.o +obj-$(CONFIG_TRANZPORT) += alphatrack.o diff --git a/drivers/staging/frontier/README b/drivers/staging/frontier/README new file mode 100644 index 00000000000..07c9ef9b8fc --- /dev/null +++ b/drivers/staging/frontier/README @@ -0,0 +1,28 @@ +This directory contains the USB Tranzport and Alphatrack Kernel drivers for Linux. + +At present the tranzport does reads/writes of 8 byte cmds to /dev/tranzport0 to control +the lights and screen and wheel + +At present the alphatrack accepts reads/writes of 12 byte cmds to /dev/tranzport0 to control +the lights and screen and fader. + +Both drivers also have some sysfs hooks that are non-functional at the moment. + +The API is currently closely tied to the ardour revision and WILL change. + +A sysfs interface is PERFECT for simple userspace apps to do fun things with the +lights and screen. It's fairly lousy for handling input events and very lousy +for watching the state of the shuttle wheel. + +A linux input events interface is great for the input events and shuttle wheel. It's +theoretically OK on LEDs. A Fader can be mapped to an absolute mouse device. +But there is no LCD support at all. + +In the end this is going to be driven by a midi layer, which handles all those +cases via a defined API, but - among other things - is slow, doesn't do +flow control, and is a LOT of extra work. Frankly, I'd like to keep the +core driver simple because the only realtime work really required is +the bottom half interrupt handler and the output overlapping. + +Exposing some sort of clean aio api to userspace would be perfect. What that +API looks like? Gah. beats me. diff --git a/drivers/staging/frontier/TODO b/drivers/staging/frontier/TODO new file mode 100644 index 00000000000..3620ad2df3e --- /dev/null +++ b/drivers/staging/frontier/TODO @@ -0,0 +1,9 @@ +TODO: + - checkpatch.pl clean + - sparse clean + - fix userspace interface to be sane + - possibly just port to userspace with libusb + - review by the USB developer community + +Please send any patches for this driver to Greg Kroah-Hartman <greg@kroah.com> +and David Taht <d@teklibre.com>. diff --git a/drivers/staging/frontier/alphatrack.c b/drivers/staging/frontier/alphatrack.c new file mode 100644 index 00000000000..efc2345a676 --- /dev/null +++ b/drivers/staging/frontier/alphatrack.c @@ -0,0 +1,901 @@ +/* + * Frontier Designs Alphatrack driver + * + * Copyright (C) 2007 Michael Taht (m@taht.net) + * + * Based on the usbled driver and ldusb drivers by + * + * Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com) + * Copyright (C) 2005 Michael Hund <mhund@ld-didactic.de> + * + * The ldusb driver was, in turn, derived from Lego USB Tower driver + * Copyright (C) 2003 David Glance <advidgsf@sourceforge.net> + * 2001-2004 Juergen Stuber <starblue@users.sourceforge.net> + * + * 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, version 2. + * + */ + +/** + * This driver uses a ring buffer for time critical reading of + * interrupt in reports and provides read and write methods for + * raw interrupt reports. + */ + +/* Note: this currently uses a dumb ringbuffer for reads and writes. + * A more optimal driver would cache and kill off outstanding urbs that are + * now invalid, and ignore ones that already were in the queue but valid + * as we only have 30 commands for the alphatrack. In particular this is + * key for getting lights to flash in time as otherwise many commands + * can be buffered up before the light change makes it to the interface. +*/ + +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/init.h> +#include <linux/slab.h> +#include <linux/module.h> +#include <linux/kobject.h> +#include <linux/mutex.h> +#include <linux/version.h> + +#include <asm/uaccess.h> +#include <linux/input.h> +#include <linux/usb.h> +#include <linux/poll.h> + +#include "surface_sysfs.h" + +/* make this work on older kernel versions */ + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) +#include "frontier_compat.h" +#endif /* older kernel versions */ + +#include "alphatrack.h" + +#define VENDOR_ID 0x165b +#define PRODUCT_ID 0xfad1 + +#ifdef CONFIG_USB_DYNAMIC_MINORS +#define USB_ALPHATRACK_MINOR_BASE 0 +#else +// FIXME 176 - is another driver's minor - apply for that +// #define USB_ALPHATRACK_MINOR_BASE 177 +#define USB_ALPHATRACK_MINOR_BASE 176 +#endif + +/* table of devices that work with this driver */ +static struct usb_device_id usb_alphatrack_table [] = { + { USB_DEVICE(VENDOR_ID, PRODUCT_ID) }, + { } /* Terminating entry */ +}; + +MODULE_DEVICE_TABLE(usb, usb_alphatrack_table); +MODULE_VERSION("0.40"); +MODULE_AUTHOR("Mike Taht <m@taht.net>"); +MODULE_DESCRIPTION("Alphatrack USB Driver"); +MODULE_LICENSE("GPL"); +MODULE_SUPPORTED_DEVICE("Frontier Designs Alphatrack Control Surface"); + +/* These aren't done yet */ + +#define ALPHATRACK_HAVE_SYSFS 0 +#define SUPPRESS_EXTRA_ONLINE_EVENTS 0 +#define BUFFERED_WRITES 0 +#define SUPPRESS_EXTRA_OFFLINE_EVENTS 0 +#define COMPRESS_FADER_EVENTS 0 + +#define BUFFERED_READS 1 +#define RING_BUFFER_SIZE 512 +#define WRITE_BUFFER_SIZE 34 +#define ALPHATRACK_USB_TIMEOUT 10 +#define OUTPUT_CMD_SIZE 8 +#define INPUT_CMD_SIZE 12 + + +static int debug = 0; + +/* Use our own dbg macro */ +#define dbg_info(dev, format, arg...) do { if (debug) dev_info(dev , format , ## arg); } while (0) + +#if 0 +#define alphatrack_ocmd_info(dev, cmd, format, arg...) do { if (debug) ocmd_info(dev , cmd , format, ## arg); } while (0) + +#define alphatrack_icmd_info(dev, cmd, format, arg...) do { if (debug) icmd_info(dev , cmd, format, ## arg); } while (0) +#else +#define alphatrack_ocmd_info(dev, cmd, format, arg...) + +#define alphatrack_icmd_info(dev, cmd, format, arg...) + +#endif + +/* Module parameters */ + +module_param(debug, int, S_IRUGO | S_IWUSR); +MODULE_PARM_DESC(debug, "Debug enabled or not"); + +/* All interrupt in transfers are collected in a ring buffer to + * avoid racing conditions and get better performance of the driver. + */ + +static int ring_buffer_size = RING_BUFFER_SIZE; + +module_param(ring_buffer_size, int, S_IRUGO); +MODULE_PARM_DESC(ring_buffer_size, "Read ring buffer size"); + +/* The write_buffer can one day contain more than one interrupt out transfer. + */ + +static int write_buffer_size = WRITE_BUFFER_SIZE; +module_param(write_buffer_size, int, S_IRUGO); +MODULE_PARM_DESC(write_buffer_size, "Write buffer size"); + +/* + * Increase the interval for debugging purposes. + * or set to 1 to use the standard interval from the endpoint descriptors. + */ + +static int min_interrupt_in_interval = ALPHATRACK_USB_TIMEOUT; +module_param(min_interrupt_in_interval, int, 0); +MODULE_PARM_DESC(min_interrupt_in_interval, "Minimum interrupt in interval in ms"); + +static int min_interrupt_out_interval = ALPHATRACK_USB_TIMEOUT; +module_param(min_interrupt_out_interval, int, 0); +MODULE_PARM_DESC(min_interrupt_out_interval, "Minimum interrupt out interval in ms"); + + + +/* Structure to hold all of our device specific stuff */ + +struct usb_alphatrack { + struct semaphore sem; /* locks this structure */ + struct usb_interface* intf; /* save off the usb interface pointer */ + int open_count; /* number of times this port has been opened */ + + struct alphatrack_icmd (*ring_buffer)[RING_BUFFER_SIZE]; /* just make c happy */ + struct alphatrack_ocmd (*write_buffer)[WRITE_BUFFER_SIZE]; /* just make c happy */ + unsigned int ring_head; + unsigned int ring_tail; + + wait_queue_head_t read_wait; + wait_queue_head_t write_wait; + + unsigned char* interrupt_in_buffer; + unsigned char* oldi_buffer; + struct usb_endpoint_descriptor* interrupt_in_endpoint; + struct urb* interrupt_in_urb; + int interrupt_in_interval; + size_t interrupt_in_endpoint_size; + int interrupt_in_running; + int interrupt_in_done; + + char* interrupt_out_buffer; + struct usb_endpoint_descriptor* interrupt_out_endpoint; + struct urb* interrupt_out_urb; + int interrupt_out_interval; + size_t interrupt_out_endpoint_size; + int interrupt_out_busy; + + atomic_t writes_pending; + int event; /* alternate interface to events */ + int fader; /* 10 bits */ + int lights; /* 23 bits */ + unsigned char dump_state; /* 0 if disabled 1 if enabled */ + unsigned char enable; /* 0 if disabled 1 if enabled */ + unsigned char offline; /* if the device is out of range or asleep */ + unsigned char verbose; /* be verbose in error reporting */ + unsigned char last_cmd[OUTPUT_CMD_SIZE]; + unsigned char screen[32]; +}; + +/* prevent races between open() and disconnect() */ +static DEFINE_MUTEX(disconnect_mutex); + +/* forward declaration */ + +static struct usb_driver usb_alphatrack_driver; + +static void icmd_info(struct usb_alphatrack *dev, char *cmd, char *str, char *a) { +/* +if (dev->verbose) { +} else { +} +*/ +} + +static void ocmd_info(struct usb_alphatrack *dev, char *cmd, char *str, char* a) { +/* +if (dev->verbose) { +} else { +} +*/ +} + + +/** + * usb_alphatrack_abort_transfers + * aborts transfers and frees associated data structures + */ +static void usb_alphatrack_abort_transfers(struct usb_alphatrack *dev) +{ + /* shutdown transfer */ + if (dev->interrupt_in_running) { + dev->interrupt_in_running = 0; + if (dev->intf) + usb_kill_urb(dev->interrupt_in_urb); + } + if (dev->interrupt_out_busy) + if (dev->intf) + usb_kill_urb(dev->interrupt_out_urb); +} + +#if ALPHATRACK_HAVE_SYSFS +/* lots and lots and lots of sysfs stuff */ +/* Currently borked, probably useless */ +#include "alphatrack_sysfs.c" +#endif + +/** + * usb_alphatrack_delete + */ +static void usb_alphatrack_delete(struct usb_alphatrack *dev) +{ + usb_alphatrack_abort_transfers(dev); + usb_free_urb(dev->interrupt_in_urb); + usb_free_urb(dev->interrupt_out_urb); + kfree(dev->ring_buffer); + kfree(dev->interrupt_in_buffer); + kfree(dev->interrupt_out_buffer); + kfree(dev); // fixme oldi_buffer +} + +/** + * usb_alphatrack_interrupt_in_callback + */ + +static void usb_alphatrack_interrupt_in_callback(struct urb *urb) +{ + struct usb_alphatrack *dev = urb->context; + unsigned int next_ring_head; + int retval = -1; + int *iptr; + + if (urb->status) { + if (urb->status == -ENOENT || + urb->status == -ECONNRESET || + urb->status == -ESHUTDOWN) { + goto exit; + } else { + dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n", + __FUNCTION__, urb->status); + goto resubmit; /* maybe we can recover */ + } + } + + if (urb->actual_length != INPUT_CMD_SIZE) { + dev_warn(&dev->intf->dev, + "Urb length was %d bytes!! Do something intelligent \n", urb->actual_length); + } else { + alphatrack_ocmd_info(&dev->intf->dev,&(*dev->ring_buffer)[dev->ring_tail].cmd,"%s", "bla"); + if(memcmp(dev->interrupt_in_buffer,dev->oldi_buffer,INPUT_CMD_SIZE)==0) { + goto resubmit; + } + memcpy(dev->oldi_buffer,dev->interrupt_in_buffer,INPUT_CMD_SIZE); + +#if SUPPRESS_EXTRA_OFFLINE_EVENTS + if(dev->offline == 2 && dev->interrupt_in_buffer[1] == 0xff) { goto resubmit; } + if(dev->offline == 1 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 2; goto resubmit; } +/* Always pass one offline event up the stack */ + if(dev->offline > 0 && dev->interrupt_in_buffer[1] != 0xff) { dev->offline = 0; } + if(dev->offline == 0 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 1; } +#endif + dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail); + next_ring_head = (dev->ring_head+1) % ring_buffer_size; + + if (next_ring_head != dev->ring_tail) { + memcpy(&((*dev->ring_buffer)[dev->ring_head]), + dev->interrupt_in_buffer, urb->actual_length); + dev->ring_head = next_ring_head; + retval = 0; + memset(dev->interrupt_in_buffer, 0, urb->actual_length); + } else { + dev_warn(&dev->intf->dev, + "Ring buffer overflow, %d bytes dropped\n", + urb->actual_length); + memset(dev->interrupt_in_buffer, 0, urb->actual_length); + } + } + +resubmit: + /* resubmit if we're still running */ + if (dev->interrupt_in_running && dev->intf) { + retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC); + if (retval) + dev_err(&dev->intf->dev, + "usb_submit_urb failed (%d)\n", retval); + } + +exit: + dev->interrupt_in_done = 1; + wake_up_interruptible(&dev->read_wait); +} + +/** + * usb_alphatrack_interrupt_out_callback + */ +static void usb_alphatrack_interrupt_out_callback(struct urb *urb) +{ + struct usb_alphatrack *dev = urb->context; + + /* sync/async unlink faults aren't errors */ + if (urb->status && !(urb->status == -ENOENT || + urb->status == -ECONNRESET || + urb->status == -ESHUTDOWN)) + dbg_info(&dev->intf->dev, + "%s - nonzero write interrupt status received: %d\n", + __FUNCTION__, urb->status); + atomic_dec(&dev->writes_pending); + dev->interrupt_out_busy = 0; + wake_up_interruptible(&dev->write_wait); +} + +/** + * usb_alphatrack_open + */ +static int usb_alphatrack_open(struct inode *inode, struct file *file) +{ + struct usb_alphatrack *dev; + int subminor; + int retval = 0; + struct usb_interface *interface; + + nonseekable_open(inode, file); + subminor = iminor(inode); + + mutex_lock(&disconnect_mutex); + + interface = usb_find_interface(&usb_alphatrack_driver, subminor); + + if (!interface) { + err("%s - error, can't find device for minor %d\n", + __FUNCTION__, subminor); + retval = -ENODEV; + goto unlock_disconnect_exit; + } + + dev = usb_get_intfdata(interface); + + if (!dev) { + retval = -ENODEV; + goto unlock_disconnect_exit; + } + + /* lock this device */ + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto unlock_disconnect_exit; + } + + /* allow opening only once */ + if (dev->open_count) { + retval = -EBUSY; + goto unlock_exit; + } + dev->open_count = 1; + + /* initialize in direction */ + dev->ring_head = 0; + dev->ring_tail = 0; + usb_fill_int_urb(dev->interrupt_in_urb, + interface_to_usbdev(interface), + usb_rcvintpipe(interface_to_usbdev(interface), + dev->interrupt_in_endpoint->bEndpointAddress), + dev->interrupt_in_buffer, + dev->interrupt_in_endpoint_size, + usb_alphatrack_interrupt_in_callback, + dev, + dev->interrupt_in_interval); + + dev->interrupt_in_running = 1; + dev->interrupt_in_done = 0; + dev->enable = 1; + dev->offline = 0; + + retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL); + if (retval) { + dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d\n", retval); + dev->interrupt_in_running = 0; + dev->open_count = 0; + goto unlock_exit; + } + + /* save device in the file's private structure */ + file->private_data = dev; + + +unlock_exit: + up(&dev->sem); + +unlock_disconnect_exit: + mutex_unlock(&disconnect_mutex); + + return retval; +} + +/** + * usb_alphatrack_release + */ +static int usb_alphatrack_release(struct inode *inode, struct file *file) +{ + struct usb_alphatrack *dev; + int retval = 0; + + dev = file->private_data; + + if (dev == NULL) { + retval = -ENODEV; + goto exit; + } + + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto exit; + } + + if (dev->open_count != 1) { + retval = -ENODEV; + goto unlock_exit; + } + + if (dev->intf == NULL) { + /* the device was unplugged before the file was released */ + up(&dev->sem); + /* unlock here as usb_alphatrack_delete frees dev */ + usb_alphatrack_delete(dev); + retval = -ENODEV; + goto exit; + } + + /* wait until write transfer is finished */ + if (dev->interrupt_out_busy) + wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy, 2 * HZ); + usb_alphatrack_abort_transfers(dev); + dev->open_count = 0; + +unlock_exit: + up(&dev->sem); + +exit: + return retval; +} + +/** + * usb_alphatrack_poll + */ +static unsigned int usb_alphatrack_poll(struct file *file, poll_table *wait) +{ + struct usb_alphatrack *dev; + unsigned int mask = 0; + + dev = file->private_data; + + poll_wait(file, &dev->read_wait, wait); + poll_wait(file, &dev->write_wait, wait); + + if (dev->ring_head != dev->ring_tail) + mask |= POLLIN | POLLRDNORM; + if (!dev->interrupt_out_busy) + mask |= POLLOUT | POLLWRNORM; + + return mask; +} + +/** + * usb_alphatrack_read + */ +static ssize_t usb_alphatrack_read(struct file *file, char __user *buffer, size_t count, + loff_t *ppos) +{ + struct usb_alphatrack *dev; + int retval = 0; + + int c = 0; + + dev = file->private_data; + + /* verify that we actually have some data to read */ + if (count == 0) + goto exit; + + /* lock this object */ + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto exit; + } + + /* verify that the device wasn't unplugged */ + if (dev->intf == NULL) { + retval = -ENODEV; + err("No device or device unplugged %d\n", retval); + goto unlock_exit; + } + + while (dev->ring_head == dev->ring_tail) { + if (file->f_flags & O_NONBLOCK) { + retval = -EAGAIN; + goto unlock_exit; + } + dev->interrupt_in_done = 0 ; + retval = wait_event_interruptible(dev->read_wait, dev->interrupt_in_done); + if (retval < 0) { + goto unlock_exit; + } + } + + alphatrack_ocmd_info(&dev->intf->dev, &(*dev->ring_buffer)[dev->ring_tail].cmd, "%s", ": copying to userspace"); + + c = 0; + while((c < count) && (dev->ring_tail != dev->ring_head)) { + if (copy_to_user(&buffer[c], &(*dev->ring_buffer)[dev->ring_tail], INPUT_CMD_SIZE)) { + retval = -EFAULT; + goto unlock_exit; + } + dev->ring_tail = (dev->ring_tail+1) % ring_buffer_size; + c+=INPUT_CMD_SIZE; + dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail); + } + retval = c; + +unlock_exit: + /* unlock the device */ + up(&dev->sem); + +exit: + return retval; +} + +/** + * usb_alphatrack_write + */ +static ssize_t usb_alphatrack_write(struct file *file, const char __user *buffer, + size_t count, loff_t *ppos) +{ + struct usb_alphatrack *dev; + size_t bytes_to_write; + int retval = 0; + + dev = file->private_data; + + /* verify that we actually have some data to write */ + if (count == 0) + goto exit; + + /* lock this object */ + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto exit; + } + + /* verify that the device wasn't unplugged */ + if (dev->intf == NULL) { + retval = -ENODEV; + err("No device or device unplugged %d\n", retval); + goto unlock_exit; + } + + /* wait until previous transfer is finished */ + if (dev->interrupt_out_busy) { + if (file->f_flags & O_NONBLOCK) { + retval = -EAGAIN; + goto unlock_exit; + } + retval = wait_event_interruptible(dev->write_wait, !dev->interrupt_out_busy); + if (retval < 0) { + goto unlock_exit; + } + } + + /* write the data into interrupt_out_buffer from userspace */ + /* FIXME - if you write more than 12 bytes this breaks */ + bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size); + if (bytes_to_write < count) + dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write); + + dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __FUNCTION__, count, bytes_to_write); + + if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) { + retval = -EFAULT; + goto unlock_exit; + } + + if (dev->interrupt_out_endpoint == NULL) { + err("Endpoint should not be be null! \n"); + goto unlock_exit; + } + + /* send off the urb */ + usb_fill_int_urb(dev->interrupt_out_urb, + interface_to_usbdev(dev->intf), + usb_sndintpipe(interface_to_usbdev(dev->intf), + dev->interrupt_out_endpoint->bEndpointAddress), + dev->interrupt_out_buffer, + bytes_to_write, + usb_alphatrack_interrupt_out_callback, + dev, + dev->interrupt_out_interval); + dev->interrupt_out_busy = 1; + atomic_inc(&dev->writes_pending); + wmb(); + + retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL); + if (retval) { + dev->interrupt_out_busy = 0; + err("Couldn't submit interrupt_out_urb %d\n", retval); + atomic_dec(&dev->writes_pending); + goto unlock_exit; + } + retval = bytes_to_write; + +unlock_exit: + /* unlock the device */ + up(&dev->sem); + +exit: + return retval; +} + +/* file operations needed when we register this driver */ +static const struct file_operations usb_alphatrack_fops = { + .owner = THIS_MODULE, + .read = usb_alphatrack_read, + .write = usb_alphatrack_write, + .open = usb_alphatrack_open, + .release = usb_alphatrack_release, + .poll = usb_alphatrack_poll, +}; + +/* + * usb class driver info in order to get a minor number from the usb core, + * and to have the device registered with the driver core + */ + +static struct usb_class_driver usb_alphatrack_class = { + .name = "alphatrack%d", + .fops = &usb_alphatrack_fops, + .minor_base = USB_ALPHATRACK_MINOR_BASE, +}; + + +/** + * usb_alphatrack_probe + * + * Called by the usb core when a new device is connected that it thinks + * this driver might be interested in. + */ +static int usb_alphatrack_probe(struct usb_interface *intf, const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(intf); + struct usb_alphatrack *dev = NULL; + struct usb_host_interface *iface_desc; + struct usb_endpoint_descriptor *endpoint; + int i; + int true_size; + int retval = -ENOMEM; + + /* allocate memory for our device state and intialize it */ + + dev = kzalloc(sizeof(*dev), GFP_KERNEL); + if (dev == NULL) { + dev_err(&intf->dev, "Out of memory\n"); + goto exit; + } + init_MUTEX(&dev->sem); + dev->intf = intf; + init_waitqueue_head(&dev->read_wait); + init_waitqueue_head(&dev->write_wait); + + iface_desc = intf->cur_altsetting; + + /* set up the endpoint information */ + for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { + endpoint = &iface_desc->endpoint[i].desc; + + if (usb_endpoint_is_int_in(endpoint)) + dev->interrupt_in_endpoint = endpoint; + + if (usb_endpoint_is_int_out(endpoint)) + dev->interrupt_out_endpoint = endpoint; + } + if (dev->interrupt_in_endpoint == NULL) { + dev_err(&intf->dev, "Interrupt in endpoint not found\n"); + goto error; + } + if (dev->interrupt_out_endpoint == NULL) + dev_warn(&intf->dev, "Interrupt out endpoint not found (using control endpoint instead)\n"); + + dev->interrupt_in_endpoint_size = le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize); + + if (dev->interrupt_in_endpoint_size != 64) + dev_warn(&intf->dev, "Interrupt in endpoint size is not 64!\n"); + + if(ring_buffer_size == 0) { ring_buffer_size = RING_BUFFER_SIZE; } + + true_size = min(ring_buffer_size,RING_BUFFER_SIZE); + + /* FIXME - there are more usb_alloc routines for dma correctness. Needed? */ + +// dev->ring_buffer = kmalloc((true_size*sizeof(struct alphatrack_icmd))+12, GFP_KERNEL); + dev->ring_buffer = kmalloc((true_size*sizeof(struct alphatrack_icmd)), GFP_KERNEL); + + if (!dev->ring_buffer) { + dev_err(&intf->dev, "Couldn't allocate input ring_buffer of size %d\n",true_size); + goto error; + } + + dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL); + + if (!dev->interrupt_in_buffer) { + dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n"); + goto error; + } + dev->oldi_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL); + if (!dev->oldi_buffer) { + dev_err(&intf->dev, "Couldn't allocate old buffer\n"); + goto error; + } + dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); + if (!dev->interrupt_in_urb) { + dev_err(&intf->dev, "Couldn't allocate interrupt_in_urb\n"); + goto error; + } + + dev->interrupt_out_endpoint_size = dev->interrupt_out_endpoint ? le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize) : + udev->descriptor.bMaxPacketSize0; + + if (dev->interrupt_out_endpoint_size !=64) + dev_warn(&intf->dev, "Interrupt out endpoint size is not 64!)\n"); + + if(write_buffer_size == 0) { write_buffer_size = WRITE_BUFFER_SIZE; } + true_size = min(write_buffer_size,WRITE_BUFFER_SIZE); + + dev->interrupt_out_buffer = kmalloc(true_size*dev->interrupt_out_endpoint_size, GFP_KERNEL); + + if (!dev->interrupt_out_buffer) { + dev_err(&intf->dev, "Couldn't allocate interrupt_out_buffer\n"); + goto error; + } + + dev->write_buffer = kmalloc(sizeof(struct alphatrack_ocmd)*true_size, GFP_KERNEL); + + if (!dev->write_buffer) { + dev_err(&intf->dev, "Couldn't allocate write_buffer \n"); + goto error; + } + + dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); + if (!dev->interrupt_out_urb) { + dev_err(&intf->dev, "Couldn't allocate interrupt_out_urb\n"); + goto error; + } + dev->interrupt_in_interval = min_interrupt_in_interval > dev->interrupt_in_endpoint->bInterval ? min_interrupt_in_interval : dev->interrupt_in_endpoint->bInterval; + if (dev->interrupt_out_endpoint) + dev->interrupt_out_interval = min_interrupt_out_interval > dev->interrupt_out_endpoint->bInterval ? min_interrupt_out_interval : dev->interrupt_out_endpoint->bInterval; + + /* we can register the device now, as it is ready */ + usb_set_intfdata(intf, dev); + + atomic_set(&dev->writes_pending,0); + retval = usb_register_dev(intf, &usb_alphatrack_class); + if (retval) { + /* something prevented us from registering this driver */ + dev_err(&intf->dev, "Not able to get a minor for this device.\n"); + usb_set_intfdata(intf, NULL); + goto error; + } + + /* let the user know what node this device is now attached to */ + dev_info(&intf->dev, "Alphatrack Device #%d now attached to major %d minor %d\n", + (intf->minor - USB_ALPHATRACK_MINOR_BASE), USB_MAJOR, intf->minor); + +#if ALPHATRACK_HAVE_SYSFS + if((retval = device_create_file(&intf->dev, &dev_attr_event))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_dump_state))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_enable))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_offline))) goto error; + + /* exercise sysfs */ + + set_lights("32767"); // turn on all the lights + set_fader0("1023"); // Move fader to max + set_screen("INITIALIZING ALPHATRACK..."); + set_lights("0"); + set_fader0("0"); + set_screen(" "); + +#endif + +exit: + return retval; + +error: + usb_alphatrack_delete(dev); + + return retval; +} + +/** + * usb_alphatrack_disconnect + * + * Called by the usb core when the device is removed from the system. + */ +static void usb_alphatrack_disconnect(struct usb_interface *intf) +{ + struct usb_alphatrack *dev; + int minor; + + mutex_lock(&disconnect_mutex); + + dev = usb_get_intfdata(intf); + usb_set_intfdata(intf, NULL); + + down(&dev->sem); + + minor = intf->minor; + + /* give back our minor */ + usb_deregister_dev(intf, &usb_alphatrack_class); + + /* if the device is not opened, then we clean up right now */ + if (!dev->open_count) { + up(&dev->sem); + usb_alphatrack_delete(dev); + } else { + dev->intf = NULL; + up(&dev->sem); + } + + atomic_set(&dev->writes_pending,0); + mutex_unlock(&disconnect_mutex); + + dev_info(&intf->dev, "Alphatrack Surface #%d now disconnected\n", + (minor - USB_ALPHATRACK_MINOR_BASE)); +} + +/* usb specific object needed to register this driver with the usb subsystem */ +static struct usb_driver usb_alphatrack_driver = { + .name = "alphatrack", + .probe = usb_alphatrack_probe, + .disconnect = usb_alphatrack_disconnect, + .id_table = usb_alphatrack_table, +}; + +/** + * usb_alphatrack_init + */ +static int __init usb_alphatrack_init(void) +{ + int retval; + + /* register this driver with the USB subsystem */ + retval = usb_register(&usb_alphatrack_driver); + if (retval) + err("usb_register failed for the "__FILE__" driver. Error number %d\n", retval); + + return retval; +} + +/** + * usb_alphatrack_exit + */ +static void __exit usb_alphatrack_exit(void) +{ + /* deregister this driver with the USB subsystem */ + usb_deregister(&usb_alphatrack_driver); +} + +module_init(usb_alphatrack_init); +module_exit(usb_alphatrack_exit); + diff --git a/drivers/staging/frontier/alphatrack.h b/drivers/staging/frontier/alphatrack.h new file mode 100644 index 00000000000..3dd7d54f49a --- /dev/null +++ b/drivers/staging/frontier/alphatrack.h @@ -0,0 +1,117 @@ +#define show_set_bit(a) show_set_mbit(alphatrack,a) +#define show_set_cmd(a) show_set_mcmd(alphatrack,a) +#define show_set_int(a) show_set_mint(alphatrack,a) +#define show_set_char(a) show_set_mchar(alphatrack,a) +#define show_set_light(a) show_set_ebit(alphatrack,LightID,lights,a) +#define show_set_button(a) show_set_ebit(alphatrack,ButtonID,button,a) + +struct alphatrack_icmd { + unsigned char cmd[12]; +}; + +struct alphatrack_ocmd { + unsigned char cmd[8]; +}; + +enum LightID { + LIGHT_EQ = 0, + LIGHT_OUT, + LIGHT_F2, + LIGHT_SEND, + LIGHT_IN, + LIGHT_F1, + LIGHT_PAN, + LIGHT_UNDEF1, + LIGHT_UNDEF2, + LIGHT_SHIFT, + LIGHT_TRACKMUTE, + LIGHT_TRACKSOLO, + LIGHT_TRACKREC, + LIGHT_READ, + LIGHT_WRITE, + LIGHT_ANYSOLO, + LIGHT_AUTO, + LIGHT_F4, + LIGHT_RECORD, + LIGHT_WINDOW, + LIGHT_PLUGIN, + LIGHT_F3, + LIGHT_LOOP +}; + +static const char *Lightname[] = { "eq", +"out", +"f2", +"send", +"in", +"f1", +"pan", +"undef1", +"undef2", +"shift", +"mute", +"tracksolo", +"trackrec", +"read", +"write", +"anysolo", +"auto", +"f4", +"record", +"window", +"plugin", +"f3", +"loop", +NULL }; + +#define BUTTONMASK_BATTERY 0x00004000 +#define BUTTONMASK_BACKLIGHT 0x00008000 +#define BUTTONMASK_FASTFORWARD 0x04000000 +#define BUTTONMASK_TRACKMUTE 0x00040000 +#define BUTTONMASK_TRACKSOLO 0x00800000 +#define BUTTONMASK_TRACKLEFT 0x80000000 +#define BUTTONMASK_RECORD 0x02000000 +#define BUTTONMASK_SHIFT 0x20000000 +#define BUTTONMASK_PUNCH 0x00800000 +#define BUTTONMASK_TRACKRIGHT 0x00020000 +#define BUTTONMASK_REWIND 0x01000000 +#define BUTTONMASK_STOP 0x10000000 +#define BUTTONMASK_LOOP 0x00010000 +#define BUTTONMASK_TRACKREC 0x00001000 +#define BUTTONMASK_PLAY 0x08000000 +#define BUTTONMASK_TOUCH1 0x00000008 +#define BUTTONMASK_TOUCH2 0x00000010 +#define BUTTONMASK_TOUCH3 0x00000020 + +#define BUTTONMASK_PRESS1 0x00000009 +#define BUTTONMASK_PRESS2 0x00008010 +#define BUTTONMASK_PRESS3 0x00002020 + +// last 3 bytes are the slider position +// 40 is the actual slider moving, the most sig bits, and 3 lsb + +#define BUTTONMASK_FLIP 0x40000000 +#define BUTTONMASK_F1 0x00100000 +#define BUTTONMASK_F2 0x00400000 +#define BUTTONMASK_F3 0x00200000 +#define BUTTONMASK_F4 0x00080000 +#define BUTTONMASK_PAN 0x00000200 +#define BUTTONMASK_SEND 0x00000800 +#define BUTTONMASK_EQ 0x00004000 +#define BUTTONMASK_PLUGIN 0x00000400 +#define BUTTONMASK_AUTO 0x00000100 + + +// #define BUTTONMASK_FOOTSWITCH FIXME + +// Lookup. name. midi out. midi in. + +struct buttonmap_t { + u32 mask; + short midi_in; + short midi_out; + char *name; +// void (*function) (buttonmap_t *); + void (*function) (void); +}; + diff --git a/drivers/staging/frontier/alphatrack_sysfs.c b/drivers/staging/frontier/alphatrack_sysfs.c new file mode 100644 index 00000000000..21af6a2d70b --- /dev/null +++ b/drivers/staging/frontier/alphatrack_sysfs.c @@ -0,0 +1,279 @@ +/* This was an attempt - ultimately proved pointless - at making a full fledged sysfs interface to the alphatrack */ +/* won't even compile at present */ + +char *alphatrack_sys_margs; +spinlock_t alphatrack_sys_margs_lock; + +struct alphatrack_attr { + struct attribute attr; + ssize_t (*show)(struct device *, char *); + ssize_t (*store)(struct device *, const char *, size_t); +}; + +#define ALPHATRACK_ATTR(name, mode, show, store) \ +static struct alphatrack_attr alphatrack_attr_##name = __ATTR(name, mode, show, store) + +/* now a great deal of callback code generation */ + +// FOREACH_LIGHT(show_set_light) +// FOREACH_BUTTON(show_set_button) + +show_set_light(LIGHT_RECORD); show_set_light(LIGHT_EQ); show_set_light(LIGHT_OUT); +show_set_light(LIGHT_F2); show_set_light(LIGHT_SEND); show_set_light(LIGHT_IN); +show_set_light(LIGHT_F1); show_set_light(LIGHT_PAN); show_set_light(LIGHT_UNDEF1); +show_set_light(LIGHT_UNDEF2); show_set_light(LIGHT_SHIFT); show_set_light(LIGHT_TRACKMUTE); +show_set_light(LIGHT_TRACKSOLO); show_set_light(LIGHT_TRACKREC); show_set_light(LIGHT_READ); +show_set_light(LIGHT_WRITE); show_set_light(LIGHT_ANYSOLO); show_set_light(LIGHT_AUTO); +show_set_light(LIGHT_F4); show_set_light(LIGHT_RECORD); show_set_light(LIGHT_WINDOW); +show_set_light(LIGHT_PLUGIN); show_set_light(LIGHT_F3); show_set_light(LIGHT_LOOP); + +show_set_opt(enable); show_set_opt(offline); show_set_opt(compress_fader); show_set_opt(dump_state); +show_set_int(fader); show_set_int(event); + + +static ssize_t show_lights(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct usb_interface *intf = to_usb_interface(dev); + struct usb_alphatrack *t = usb_get_intfdata(intf); + return sprintf(buf, "%d\n", t->lights); +} + +static ssize_t set_lights(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) +{ + struct usb_interface *intf = to_usb_interface(dev); + struct usb_alphatrack *t = usb_get_intfdata(intf); + int temp = simple_strtoul(buf, NULL, 10); + t->lights = temp; + return count; +} + +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_lights, set_lights); + + +ALPHATRACK_ATTR(LightRecord, 0200, NULL, LightRecord_store); + +static struct attribute *alphatrack_attrs[] = { + &alphatrack_attr_LightRecord.attr, + NULL, +}; + +static ssize_t alphatrack_attr_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct device *sdp = container_of(kobj, struct device, kobj); + struct alphatrack_attr *a = container_of(attr, struct alphatrack_attr, attr); + return a->show ? a->show(sdp, buf) : 0; +} + +static ssize_t alphatrack_attr_store(struct kobject *kobj, struct attribute *attr, + const char *buf, size_t len) +{ + struct device *sdp = container_of(kobj, struct device, kobj); + struct alphatrack_attr *a = container_of(attr, struct alphatrack_attr, attr); + return a->store ? a->store(sdp, buf, len) : len; +} + +static struct sysfs_ops alphatrack_attr_ops = { + .show = alphatrack_attr_show, + .store = alphatrack_attr_store, +}; + +static struct kobj_type alphatrack_ktype = { + .default_attrs = alphatrack_attrs, + .sysfs_ops = &alphatrack_attr_ops, +}; + +static struct kset alphatrack_kset = { + .subsys = &fs_subsys, + .kobj = {.name = "alphatrack"}, + .ktype = &alphatrack_ktype, +}; + + +static struct attribute *lights_attrs[] = { + &tune_attr_demote_secs.attr, + NULL, +}; + + +static struct attribute_group leds_group = { + .name = "leds", + .attrs = lights_attrs, +}; + +static struct attribute_group faders_group = { + .name = "faders", + .attrs = faders_attrs, +}; + +static struct attribute_group lcds_group = { + .name = "lcds", + .attrs = lcds_attrs, +}; + +static struct attribute_group wheels_group = { + .name = "wheels", + .attrs = wheels_attrs, +}; + +static struct attribute_group touchsurfaces_group = { + .name = "touchsurfaces", + .attrs = touchsurfaces_attrs, +}; + +static struct attribute_group buttons_group = { + .name = "buttons", + .attrs = buttons_attrs, +}; + + +int alphatrack_sys_fs_add(struct device *sdp) +{ + int error; + + sdp->kobj.kset = &alphatrack_kset; + sdp->kobj.ktype = &alphatrack_ktype; + +// error = kobject_set_name(&sdp->kobj, "%s", sdp->sd_table_name); + error = kobject_set_name(&sdp->kobj, "%s", "alphatrack"); + if (error) + goto fail; + + error = kobject_register(&sdp->kobj); + if (error) + goto fail; + + error = sysfs_create_group(&sdp->kobj, &lcds_group); + if (error) + goto fail_reg; + + error = sysfs_create_group(&sdp->kobj, &leds_group); + if (error) + goto fail_leds; + + error = sysfs_create_group(&sdp->kobj, &wheels_group); + if (error) + goto fail_wheels; + + error = sysfs_create_group(&sdp->kobj, &faders_group); + if (error) + goto fail_lcds; + + error = sysfs_create_group(&sdp->kobj, &buttons_group); + if (error) + goto fail_faders; + + error = sysfs_create_group(&sdp->kobj, &touchsurfaces_group); + if (error) + goto fail_buttons; + + return 0; + + +fail_buttons: + sysfs_remove_group(&sdp->kobj, &buttons_group); +fail_faders: + sysfs_remove_group(&sdp->kobj, &faders_group); +fail_wheels: + sysfs_remove_group(&sdp->kobj, &wheels_group); +fail_lcds: + sysfs_remove_group(&sdp->kobj, &lcds_group); +fail_leds: + sysfs_remove_group(&sdp->kobj, &leds_group); + + + +fail_reg: + kobject_unregister(&sdp->kobj); +fail: + fs_err(sdp, "error %d adding sysfs files", error); + return error; +} + +// int sysfs_create_link(struct kobject *kobj, +// struct kobject *target, +// char *name); + +void alphatrack_sys_fs_del(struct device *sdp) +{ + sysfs_remove_group(&sdp->kobj, &touchsurfaces_group); + sysfs_remove_group(&sdp->kobj, &buttons_group); + sysfs_remove_group(&sdp->kobj, &faders_group); + sysfs_remove_group(&sdp->kobj, &lcds_group); + sysfs_remove_group(&sdp->kobj, &wheels_group); + sysfs_remove_group(&sdp->kobj, &leds_group) +//void sysfs_remove_link(struct kobject *kobj, char *name); + kobject_unregister(&sdp->kobj); +} + +int alphatrack_sys_init(void) +{ + alphatrack_sys_margs = NULL; + spin_lock_init(&alphatrack_sys_margs_lock); + return kset_register(&alphatrack_kset); +} + +void alphatrack_sys_uninit(void) +{ + kfree(alphatrack_sys_margs); + kset_unregister(&alphatrack_kset); +} + + +//decl_subsys(char *name, struct kobj_type *type, +// struct kset_hotplug_ops *hotplug_ops); + +/* End of all the crazy sysfs stuff */ + +#define SYSEX_INQUIRE signed char *SYSEX_INQUIRE[] = { 0xf0,0x7e,0x00,0x06,0x01,0x17 }; + +#define COMMAND(NAME,CONT_NAME) { BUTTONMASK_##NAME, ((0x90 << 8) | CONT_NAME), ((0x90 << 8) | CONT_NAME), #NAME, NAME ## _set } +#define ROTARY(NAME,CONT_NAME) { FADER_##NAME, ((0xb0 << 8) | CONT_NAME), ((0xb0 << 8) | CONT_NAME), #NAME, NAME ## _set } +#define SPOSITION(NAME,CONT_NAME) { BUTTON_##NAME ((0xe9 << 8) | CONT_NAME), #NAME, NAME ## _set } +#define ENDCOMMAND { 0,NULL,0,NULL,NULL} + +/* Now that we've generated all our callbacks */ + +static struct buttonmap_t buttonmap[] = + { + COMMAND (REWIND,0x5b), + COMMAND (FASTFORWARD,0x5c), + COMMAND (STOP,0x5d), + COMMAND (PLAY,0x5e), + COMMAND (RECORD,0x5f), + COMMAND (SHIFT,0x46), + COMMAND (TRACKLEFT,0x57), + COMMAND (TRACKRIGHT,0x58), + COMMAND (LOOP,0x56), + COMMAND (FLIP,0x32), + COMMAND (MUTE,0x10), + COMMAND (F1,0x36), + COMMAND (F2,0x37), + COMMAND (F3,0x38), + COMMAND (F4,0x39), + COMMAND (SOLO,0x08), + COMMAND (ANY,0x73), + COMMAND (PAN,0x2a), + COMMAND (SEND,0x29), + COMMAND (EQ,0x2c), + COMMAND (PLUGIN,0x2b), + COMMAND (AUTO,0x4a), + COMMAND (TRACKREC,0x00), + COMMAND (FOOTSWITCH1,0x67), + COMMAND (KNOBTOUCH1,0x78), + COMMAND (KNOBPUSH1,0x20), + ROTARY (KNOBTURN1,0x10), + COMMAND (KNOBTOUCH2,0x79), + COMMAND (KNOBPUSH2,0x21), + ROTARY (KNOBTURN2,0x11), + COMMAND (KNOBTOUCH3,0x7a), + COMMAND (KNOBPUSH3,0x22), + ROTARY (KNOBTURN3,0x12), + COMMAND (FADERTOUCH1,0x68), + COMMAND (STRIPTOUCH1,0x74), + COMMAND (STRIPTOUCH2,0x6b), + SPOSITION (STRIPPOS1,0x00), + ENDCOMMAND + }; + + diff --git a/drivers/staging/frontier/frontier_compat.h b/drivers/staging/frontier/frontier_compat.h new file mode 100644 index 00000000000..00450e637ac --- /dev/null +++ b/drivers/staging/frontier/frontier_compat.h @@ -0,0 +1,63 @@ +/* USB defines for older kernels */ + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) + +/** + * usb_endpoint_dir_out - check if the endpoint has OUT direction + * @epd: endpoint to be checked + * + * Returns true if the endpoint is of type OUT, otherwise it returns false. + */ + +static inline int usb_endpoint_dir_out(const struct usb_endpoint_descriptor *epd) +{ + return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT); +} + +static inline int usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd) +{ + return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN); +} + + +/** + * usb_endpoint_xfer_int - check if the endpoint has interrupt transfer type + * @epd: endpoint to be checked + * + * Returns true if the endpoint is of type interrupt, otherwise it returns + * false. + */ +static inline int usb_endpoint_xfer_int(const struct usb_endpoint_descriptor *epd) +{ + return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == + USB_ENDPOINT_XFER_INT); +} + + +/** + * usb_endpoint_is_int_in - check if the endpoint is interrupt IN + * @epd: endpoint to be checked + * + * Returns true if the endpoint has interrupt transfer type and IN direction, + * otherwise it returns false. + */ + +static inline int usb_endpoint_is_int_in(const struct usb_endpoint_descriptor *epd) +{ + return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd)); +} + +/** + * usb_endpoint_is_int_out - check if the endpoint is interrupt OUT + * @epd: endpoint to be checked + * + * Returns true if the endpoint has interrupt transfer type and OUT direction, + * otherwise it returns false. + */ + +static inline int usb_endpoint_is_int_out(const struct usb_endpoint_descriptor *epd) +{ + return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd)); +} + +#endif /* older kernel versions */ diff --git a/drivers/staging/frontier/surface_sysfs.h b/drivers/staging/frontier/surface_sysfs.h new file mode 100644 index 00000000000..d50a562d658 --- /dev/null +++ b/drivers/staging/frontier/surface_sysfs.h @@ -0,0 +1,100 @@ +/* If you are going to abuse the preprocessor, why not ABUSE the preprocessor? + I stuck this header in a separate file so I don't have to look at it */ + +// FIXME Need locking or atomic ops + +#define show_set_mbit(dname,value,bit) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int temp = (1 && (t->value & (1 << bit))); \ + return sprintf(buf, "%d\n", temp); \ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + if(temp > 0) { long b = 1 << bit; t->value |= b; } \ + else { long b = ~(1 << bit); t->value &= b ; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + +#define show_set_ebit(dname,enumname,value,bit) \ +static ssize_t show_##bit(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + enum enumname l = bit; \ + int temp = t->value & (1 << l); \ + return sprintf(buf, "%d\n", temp); \ +} \ +static ssize_t set_##bit(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + enum enumname l = bit;\ + long b = 1 << l; \ + if(temp > 0) { t->value |= b; } \ + else { t->value &= ~b ; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + +// FIXME FOR CORRECTLY SETTING HEX from a string +#define show_set_mcmd(dname,value) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int count = 0;\ + int i; \ + for (i = 0,i<sizeof(dname); i++) count += snprintf(buf, "%02x",t->dname[i]); \ + return(count);\ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + t->value = temp; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + +#define show_set_mint(dname,value) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + return sprintf(buf, "%d\n", t->value); \ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + t->value = temp; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + +#define show_set_mchar(dname,value) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + return sprintf(buf, "%c\n", t->value); \ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_##dname *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + t->value = temp; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); diff --git a/drivers/staging/frontier/tranzport.c b/drivers/staging/frontier/tranzport.c new file mode 100644 index 00000000000..32d9c5084c8 --- /dev/null +++ b/drivers/staging/frontier/tranzport.c @@ -0,0 +1,1017 @@ +/* + * Frontier Designs Tranzport driver + * + * Copyright (C) 2007 Michael Taht (m@taht.net) + * + * Based on the usbled driver and ldusb drivers by + * + * Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com) + * Copyright (C) 2005 Michael Hund <mhund@ld-didactic.de> + * + * The ldusb driver was, in turn, derived from Lego USB Tower driver + * Copyright (C) 2003 David Glance <advidgsf@sourceforge.net> + * 2001-2004 Juergen Stuber <starblue@users.sourceforge.net> + * + * 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, version 2. + * + */ + +/** + * This driver uses a ring buffer for time critical reading of + * interrupt in reports and provides read and write methods for + * raw interrupt reports. + */ + +/* Note: this currently uses a dumb ringbuffer for reads and writes. + * A more optimal driver would cache and kill off outstanding urbs that are + * now invalid, and ignore ones that already were in the queue but valid + * as we only have 17 commands for the tranzport. In particular this is + * key for getting lights to flash in time as otherwise many commands + * can be buffered up before the light change makes it to the interface. +*/ + +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/init.h> +#include <linux/slab.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/version.h> + +#include <asm/uaccess.h> +#include <linux/input.h> +#include <linux/usb.h> +#include <linux/poll.h> + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) +#include frontier_compat.h +#endif + +/* Define these values to match your devices */ +#define VENDOR_ID 0x165b +#define PRODUCT_ID 0x8101 + +#ifdef CONFIG_USB_DYNAMIC_MINORS +#define USB_TRANZPORT_MINOR_BASE 0 +#else +// FIXME 176 - is the ldusb driver's minor - apply for a minor soon +#define USB_TRANZPORT_MINOR_BASE 177 +#endif + +/* table of devices that work with this driver */ +static struct usb_device_id usb_tranzport_table [] = { + { USB_DEVICE(VENDOR_ID, PRODUCT_ID) }, + { } /* Terminating entry */ +}; + +MODULE_DEVICE_TABLE(usb, usb_tranzport_table); +MODULE_VERSION("0.33"); +MODULE_AUTHOR("Mike Taht <m@taht.net>"); +MODULE_DESCRIPTION("Tranzport USB Driver"); +MODULE_LICENSE("GPL"); +MODULE_SUPPORTED_DEVICE("Frontier Designs Tranzport Control Surface"); + +/* These two aren't done yet */ + +#define SUPPRESS_EXTRA_ONLINE_EVENTS 0 +#define BUFFERED_WRITES 0 + +#define SUPPRESS_EXTRA_OFFLINE_EVENTS 1 +#define COMPRESS_WHEEL_EVENTS 1 +#define BUFFERED_READS 1 +#define RING_BUFFER_SIZE 1000 +#define WRITE_BUFFER_SIZE 34 +#define TRANZPORT_USB_TIMEOUT 10 + + +static int debug = 0; + +/* Use our own dbg macro */ +#define dbg_info(dev, format, arg...) do { if (debug) dev_info(dev , format , ## arg); } while (0) + +/* Module parameters */ + +module_param(debug, int, S_IRUGO | S_IWUSR); +MODULE_PARM_DESC(debug, "Debug enabled or not"); + +/* All interrupt in transfers are collected in a ring buffer to + * avoid racing conditions and get better performance of the driver. + */ + +static int ring_buffer_size = RING_BUFFER_SIZE; + +module_param(ring_buffer_size, int, S_IRUGO); +MODULE_PARM_DESC(ring_buffer_size, "Read ring buffer size in reports"); + +/* The write_buffer can one day contain more than one interrupt out transfer. + */ +static int write_buffer_size = WRITE_BUFFER_SIZE; +module_param(write_buffer_size, int, S_IRUGO); +MODULE_PARM_DESC(write_buffer_size, "Write buffer size"); + +/* + * Increase the interval for debugging purposes. + * or set to 1 to use the standard interval from the endpoint descriptors. + */ + +static int min_interrupt_in_interval = TRANZPORT_USB_TIMEOUT; +module_param(min_interrupt_in_interval, int, 0); +MODULE_PARM_DESC(min_interrupt_in_interval, "Minimum interrupt in interval in ms"); + +static int min_interrupt_out_interval = TRANZPORT_USB_TIMEOUT; +module_param(min_interrupt_out_interval, int, 0); +MODULE_PARM_DESC(min_interrupt_out_interval, "Minimum interrupt out interval in ms"); + +struct tranzport_cmd { + unsigned char cmd[8]; +}; + +enum LightID { + LightRecord = 0, + LightTrackrec, + LightTrackmute, + LightTracksolo, + LightAnysolo, + LightLoop, + LightPunch + }; + +static const char *Lightname[8] = { "LightRecord", + "LightTracrec", + "LightTrackmute", + "LightTrackSolo", + "LightAnySolo", + "LightLoop", + "LightPunch", + NULL }; + + +/* Structure to hold all of our device specific stuff */ + +struct usb_tranzport { + struct semaphore sem; /* locks this structure */ + struct usb_interface* intf; /* save off the usb interface pointer */ + + int open_count; /* number of times this port has been opened */ + + struct tranzport_cmd (*ring_buffer)[RING_BUFFER_SIZE]; /* just make c happy */ + unsigned int ring_head; + unsigned int ring_tail; + + wait_queue_head_t read_wait; + wait_queue_head_t write_wait; + + unsigned char* interrupt_in_buffer; + struct usb_endpoint_descriptor* interrupt_in_endpoint; + struct urb* interrupt_in_urb; + int interrupt_in_interval; + size_t interrupt_in_endpoint_size; + int interrupt_in_running; + int interrupt_in_done; + + char* interrupt_out_buffer; + struct usb_endpoint_descriptor* interrupt_out_endpoint; + struct urb* interrupt_out_urb; + int interrupt_out_interval; + size_t interrupt_out_endpoint_size; + int interrupt_out_busy; + + /* Sysfs and translation support */ + + int event; /* alternate interface to events */ + int wheel; /* - for negative, 0 for none, + for positive */ + unsigned char dump_state; /* 0 if disabled 1 if enabled */ + unsigned char enable; /* 0 if disabled 1 if enabled */ + unsigned char offline; /* if the device is out of range or asleep */ + unsigned char compress_wheel; /* flag to compress wheel events */ + unsigned char light; /* 7 bits used */ + unsigned char last_cmd[8]; + unsigned char last_input[8]; + unsigned char screen[40]; // We'll also have cells + +}; + +/* prevent races between open() and disconnect() */ +static DEFINE_MUTEX(disconnect_mutex); + +static struct usb_driver usb_tranzport_driver; + +/** + * usb_tranzport_abort_transfers + * aborts transfers and frees associated data structures + */ +static void usb_tranzport_abort_transfers(struct usb_tranzport *dev) +{ + /* shutdown transfer */ + if (dev->interrupt_in_running) { + dev->interrupt_in_running = 0; + if (dev->intf) + usb_kill_urb(dev->interrupt_in_urb); + } + if (dev->interrupt_out_busy) + if (dev->intf) + usb_kill_urb(dev->interrupt_out_urb); +} + +// FIXME ~light not good enough or correct - need atomic set_bit + +#define show_set_light(value) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_tranzport *t = usb_get_intfdata(intf); \ + enum LightID light = value; \ + int temp = (1 && (t->light & (1 << light))); \ + return sprintf(buf, "%d\n", temp ); \ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_tranzport *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + enum LightID light = (temp << value) & (t->light << value); \ + t->light = (t->light & ~light) ; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + +show_set_light(LightRecord); +show_set_light(LightTrackrec); +show_set_light(LightTrackmute); +show_set_light(LightTracksolo); +show_set_light(LightAnysolo); +show_set_light(LightLoop); +show_set_light(LightPunch); + + +#define show_set_int(value) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_tranzport *t = usb_get_intfdata(intf); \ + \ + return sprintf(buf, "%d\n", t->value); \ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_tranzport *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + \ + t->value = temp; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + +show_set_int(enable); +show_set_int(offline); +show_set_int(compress_wheel); +show_set_int(dump_state); +show_set_int(wheel); +show_set_int(event); + +#define show_set_cmd(value) \ +static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_tranzport *t = usb_get_intfdata(intf); \ + \ + return sprintf(buf, "%d\n", t->value); \ +} \ +static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +{ \ + struct usb_interface *intf = to_usb_interface(dev); \ + struct usb_tranzport *t = usb_get_intfdata(intf); \ + int temp = simple_strtoul(buf, NULL, 10); \ + \ + t->value = temp; \ + return count; \ +} \ +static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value); + + + + +/** + * usb_tranzport_delete + */ +static void usb_tranzport_delete(struct usb_tranzport *dev) +{ + usb_tranzport_abort_transfers(dev); + /* This is just too twisted to be correct */ + if(dev->intf != NULL) { + device_remove_file(&dev->intf->dev, &dev_attr_LightRecord); + device_remove_file(&dev->intf->dev, &dev_attr_LightTrackrec); + device_remove_file(&dev->intf->dev, &dev_attr_LightTrackmute); + device_remove_file(&dev->intf->dev, &dev_attr_LightTracksolo); + device_remove_file(&dev->intf->dev, &dev_attr_LightTrackmute); + device_remove_file(&dev->intf->dev, &dev_attr_LightAnysolo); + device_remove_file(&dev->intf->dev, &dev_attr_LightLoop); + device_remove_file(&dev->intf->dev, &dev_attr_LightPunch); + device_remove_file(&dev->intf->dev, &dev_attr_wheel); + device_remove_file(&dev->intf->dev, &dev_attr_enable); + device_remove_file(&dev->intf->dev, &dev_attr_event); + device_remove_file(&dev->intf->dev, &dev_attr_offline); + device_remove_file(&dev->intf->dev, &dev_attr_compress_wheel); + + device_remove_file(&dev->intf->dev, &dev_attr_dump_state); + } + + /* free data structures */ + usb_free_urb(dev->interrupt_in_urb); + usb_free_urb(dev->interrupt_out_urb); + kfree(dev->ring_buffer); + kfree(dev->interrupt_in_buffer); + kfree(dev->interrupt_out_buffer); + kfree(dev); +} + +/** + * usb_tranzport_interrupt_in_callback + */ + +static void usb_tranzport_interrupt_in_callback(struct urb *urb) +{ + struct usb_tranzport *dev = urb->context; + unsigned int next_ring_head; + int retval = -1; + + if (urb->status) { + if (urb->status == -ENOENT || + urb->status == -ECONNRESET || + urb->status == -ESHUTDOWN) { + goto exit; + } else { + dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n", + __FUNCTION__, urb->status); + goto resubmit; /* maybe we can recover */ + } + } + + if (urb->actual_length != 8) { + dev_warn(&dev->intf->dev, + "Urb length was %d bytes!! Do something intelligent \n", urb->actual_length); + } else { + dbg_info(&dev->intf->dev, "%s: received: %02x%02x%02x%02x%02x%02x%02x%02x\n", + __FUNCTION__, dev->interrupt_in_buffer[0],dev->interrupt_in_buffer[1],dev->interrupt_in_buffer[2],dev->interrupt_in_buffer[3],dev->interrupt_in_buffer[4],dev->interrupt_in_buffer[5],dev->interrupt_in_buffer[6],dev->interrupt_in_buffer[7]); +#if SUPPRESS_EXTRA_OFFLINE_EVENTS + if(dev->offline == 2 && dev->interrupt_in_buffer[1] == 0xff) { goto resubmit; } + if(dev->offline == 1 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 2; goto resubmit; } + +/* Always pass one offline event up the stack */ + if(dev->offline > 0 && dev->interrupt_in_buffer[1] != 0xff) { dev->offline = 0; } + if(dev->offline == 0 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 1; } + +#endif + dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail); + + next_ring_head = (dev->ring_head+1) % ring_buffer_size; + + if (next_ring_head != dev->ring_tail) { + memcpy(&((*dev->ring_buffer)[dev->ring_head]), dev->interrupt_in_buffer, urb->actual_length); + dev->ring_head = next_ring_head; + retval = 0; + memset(dev->interrupt_in_buffer, 0, urb->actual_length); + } else { + dev_warn(&dev->intf->dev, + "Ring buffer overflow, %d bytes dropped\n", + urb->actual_length); + memset(dev->interrupt_in_buffer, 0, urb->actual_length); + } + } + +resubmit: + /* resubmit if we're still running */ + if (dev->interrupt_in_running && dev->intf) { + retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC); + if (retval) + dev_err(&dev->intf->dev, + "usb_submit_urb failed (%d)\n", retval); + } + +exit: + dev->interrupt_in_done = 1; + wake_up_interruptible(&dev->read_wait); +} + +/** + * usb_tranzport_interrupt_out_callback + */ +static void usb_tranzport_interrupt_out_callback(struct urb *urb) +{ + struct usb_tranzport *dev = urb->context; + + /* sync/async unlink faults aren't errors */ + if (urb->status && !(urb->status == -ENOENT || + urb->status == -ECONNRESET || + urb->status == -ESHUTDOWN)) + dbg_info(&dev->intf->dev, + "%s - nonzero write interrupt status received: %d\n", + __FUNCTION__, urb->status); + + dev->interrupt_out_busy = 0; + wake_up_interruptible(&dev->write_wait); +} + +/** + * usb_tranzport_open + */ +static int usb_tranzport_open(struct inode *inode, struct file *file) +{ + struct usb_tranzport *dev; + int subminor; + int retval = 0; + struct usb_interface *interface; + + nonseekable_open(inode, file); + subminor = iminor(inode); + + mutex_lock(&disconnect_mutex); + + interface = usb_find_interface(&usb_tranzport_driver, subminor); + + if (!interface) { + err("%s - error, can't find device for minor %d\n", + __FUNCTION__, subminor); + retval = -ENODEV; + goto unlock_disconnect_exit; + } + + dev = usb_get_intfdata(interface); + + if (!dev) { + retval = -ENODEV; + goto unlock_disconnect_exit; + } + + /* lock this device */ + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto unlock_disconnect_exit; + } + + /* allow opening only once */ + if (dev->open_count) { + retval = -EBUSY; + goto unlock_exit; + } + dev->open_count = 1; + + /* initialize in direction */ + dev->ring_head = 0; + dev->ring_tail = 0; + usb_fill_int_urb(dev->interrupt_in_urb, + interface_to_usbdev(interface), + usb_rcvintpipe(interface_to_usbdev(interface), + dev->interrupt_in_endpoint->bEndpointAddress), + dev->interrupt_in_buffer, + dev->interrupt_in_endpoint_size, + usb_tranzport_interrupt_in_callback, + dev, + dev->interrupt_in_interval); + + dev->interrupt_in_running = 1; + dev->interrupt_in_done = 0; + dev->enable = 1; + dev->offline = 0; + dev->compress_wheel = 1; + + retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL); + if (retval) { + dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d\n", retval); + dev->interrupt_in_running = 0; + dev->open_count = 0; + goto unlock_exit; + } + + /* save device in the file's private structure */ + file->private_data = dev; + + +unlock_exit: + up(&dev->sem); + +unlock_disconnect_exit: + mutex_unlock(&disconnect_mutex); + + return retval; +} + +/** + * usb_tranzport_release + */ +static int usb_tranzport_release(struct inode *inode, struct file *file) +{ + struct usb_tranzport *dev; + int retval = 0; + + dev = file->private_data; + + if (dev == NULL) { + retval = -ENODEV; + goto exit; + } + + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto exit; + } + + if (dev->open_count != 1) { + retval = -ENODEV; + goto unlock_exit; + } + + if (dev->intf == NULL) { + /* the device was unplugged before the file was released */ + up(&dev->sem); + /* unlock here as usb_tranzport_delete frees dev */ + usb_tranzport_delete(dev); + retval = -ENODEV; + goto exit; + } + + /* wait until write transfer is finished */ + if (dev->interrupt_out_busy) + wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy, 2 * HZ); + usb_tranzport_abort_transfers(dev); + dev->open_count = 0; + +unlock_exit: + up(&dev->sem); + +exit: + return retval; +} + +/** + * usb_tranzport_poll + */ +static unsigned int usb_tranzport_poll(struct file *file, poll_table *wait) +{ + struct usb_tranzport *dev; + unsigned int mask = 0; + + dev = file->private_data; + + poll_wait(file, &dev->read_wait, wait); + poll_wait(file, &dev->write_wait, wait); + + if (dev->ring_head != dev->ring_tail) + mask |= POLLIN | POLLRDNORM; + if (!dev->interrupt_out_busy) + mask |= POLLOUT | POLLWRNORM; + + return mask; +} + +/** + * usb_tranzport_read + */ +static ssize_t usb_tranzport_read(struct file *file, char __user *buffer, size_t count, + loff_t *ppos) +{ + struct usb_tranzport *dev; + size_t bytes_to_read; + int retval = 0; + +#if BUFFERED_READS + int c = 0; +#endif + +#if COMPRESS_WHEEL_EVENTS + signed char oldwheel; + signed char newwheel; + int cancompress = 1; + int next_tail; +#endif + +/* do I have such a thing as a null event? */ + + dev = file->private_data; + + /* verify that we actually have some data to read */ + if (count == 0) + goto exit; + + /* lock this object */ + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto exit; + } + + /* verify that the device wasn't unplugged */ + if (dev->intf == NULL) { + retval = -ENODEV; + err("No device or device unplugged %d\n", retval); + goto unlock_exit; + } + + while (dev->ring_head == dev->ring_tail) { + + if (file->f_flags & O_NONBLOCK) { + retval = -EAGAIN; + goto unlock_exit; + } + // atomic_cmp_exchange(&dev->interrupt_in_done,0,0); + dev->interrupt_in_done = 0 ; /* tiny race - FIXME: make atomic? */ + retval = wait_event_interruptible(dev->read_wait, dev->interrupt_in_done); + if (retval < 0) { + goto unlock_exit; + } + } + + dbg_info(&dev->intf->dev, "%s: copying to userspace: %02x%02x%02x%02x%02x%02x%02x%02x\n", + __FUNCTION__, (*dev->ring_buffer)[dev->ring_tail].cmd[0],(*dev->ring_buffer)[dev->ring_tail].cmd[1],(*dev->ring_buffer)[dev->ring_tail].cmd[2],(*dev->ring_buffer)[dev->ring_tail].cmd[3],(*dev->ring_buffer)[dev->ring_tail].cmd[4],(*dev->ring_buffer)[dev->ring_tail].cmd[5],(*dev->ring_buffer)[dev->ring_tail].cmd[6],(*dev->ring_buffer)[dev->ring_tail].cmd[7]); + +#if BUFFERED_READS + c = 0; + while((c < count) && (dev->ring_tail != dev->ring_head)) { + +/* This started off in the lower level service routine, and I moved it here. Then my brain died. Not done yet. */ +#if COMPRESS_WHEEL_EVENTS + next_tail = (dev->ring_tail+1) % ring_buffer_size; + if(dev->compress_wheel) cancompress = 1; + while(dev->ring_head != next_tail && cancompress == 1 ) { + newwheel = (*dev->ring_buffer)[next_tail].cmd[6]; + oldwheel = (*dev->ring_buffer)[dev->ring_tail].cmd[6]; + // if both are wheel events, and no buttons have changes (FIXME, do I have to check?), + // and we are the same sign, we can compress +- 7F + // FIXME: saner check for overflow! - max of +- 7F + // FIXME the math is wrong for going in reverse, actually, as the midi spec doesn't allow signed chars + + dbg_info(&dev->intf->dev, "%s: trying to compress: %02x%02x%02x%02x%02x %02x %02x %02x\n", + __FUNCTION__, (*dev->ring_buffer)[dev->ring_tail].cmd[0],(*dev->ring_buffer)[dev->ring_tail].cmd[1],(*dev->ring_buffer)[dev->ring_tail].cmd[2],(*dev->ring_buffer)[dev->ring_tail].cmd[3],(*dev->ring_buffer)[dev->ring_tail].cmd[4],(*dev->ring_buffer)[dev->ring_tail].cmd[5],(*dev->ring_buffer)[dev->ring_tail].cmd[6],(*dev->ring_buffer)[dev->ring_tail].cmd[7]); + + + if(((*dev->ring_buffer)[dev->ring_tail].cmd[6] != 0 && + (*dev->ring_buffer)[next_tail].cmd[6] != 0 ) && + ((newwheel > 0 && oldwheel > 0) || + (newwheel < 0 && oldwheel < 0)) && + ((*dev->ring_buffer)[dev->ring_tail].cmd[2] == (*dev->ring_buffer)[next_tail].cmd[2]) && + ((*dev->ring_buffer)[dev->ring_tail].cmd[3] == (*dev->ring_buffer)[next_tail].cmd[3]) && + ((*dev->ring_buffer)[dev->ring_tail].cmd[4] == (*dev->ring_buffer)[next_tail].cmd[4]) && + ((*dev->ring_buffer)[dev->ring_tail].cmd[5] == (*dev->ring_buffer)[next_tail].cmd[5])) + { + dbg_info(&dev->intf->dev, "%s: should compress: %02x%02x%02x%02x%02x%02x%02x%02x\n", + __FUNCTION__, (*dev->ring_buffer)[dev->ring_tail].cmd[0],(*dev->ring_buffer)[dev->ring_tail].cmd[1],(*dev->ring_buffer)[dev->ring_tail].cmd[2],(*dev->ring_buffer)[dev->ring_tail].cmd[3],(*dev->ring_buffer)[dev->ring_tail].cmd[4],(*dev->ring_buffer)[dev->ring_tail].cmd[5],(*dev->ring_buffer)[dev->ring_tail].cmd[6],(*dev->ring_buffer)[dev->ring_tail].cmd[7]); + + newwheel += oldwheel; + if(oldwheel > 0 && !(newwheel > 0)) { + newwheel = 0x7f; + cancompress = 0; + } + if(oldwheel < 0 && !(newwheel < 0)) { + newwheel = 0x80; + cancompress = 0; + } + + (*dev->ring_buffer)[next_tail].cmd[6] = newwheel; + dev->ring_tail = next_tail; + next_tail = (dev->ring_tail+1) % ring_buffer_size; + } else { + cancompress = 0; + } + } +#endif /* COMPRESS_WHEEL_EVENTS */ + + if (copy_to_user(&buffer[c], &(*dev->ring_buffer)[dev->ring_tail], 8)) { + retval = -EFAULT; + goto unlock_exit; + } + + dev->ring_tail = (dev->ring_tail+1) % ring_buffer_size; + c+=8; + dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail); + } + retval = c; + +#else + if (copy_to_user(buffer, &(*dev->ring_buffer)[dev->ring_tail], 8)) { + retval = -EFAULT; + goto unlock_exit; + } + + dev->ring_tail = (dev->ring_tail+1) % ring_buffer_size; + dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail); + + retval = 8; +#endif /* BUFFERED_READS */ + +unlock_exit: + /* unlock the device */ + up(&dev->sem); + +exit: + return retval; +} + +/** + * usb_tranzport_write + */ +static ssize_t usb_tranzport_write(struct file *file, const char __user *buffer, + size_t count, loff_t *ppos) +{ + struct usb_tranzport *dev; + size_t bytes_to_write; + int retval = 0; + + dev = file->private_data; + + /* verify that we actually have some data to write */ + if (count == 0) + goto exit; + + /* lock this object */ + if (down_interruptible(&dev->sem)) { + retval = -ERESTARTSYS; + goto exit; + } + + /* verify that the device wasn't unplugged */ + if (dev->intf == NULL) { + retval = -ENODEV; + err("No device or device unplugged %d\n", retval); + goto unlock_exit; + } + + /* wait until previous transfer is finished */ + if (dev->interrupt_out_busy) { + if (file->f_flags & O_NONBLOCK) { + retval = -EAGAIN; + goto unlock_exit; + } + retval = wait_event_interruptible(dev->write_wait, !dev->interrupt_out_busy); + if (retval < 0) { + goto unlock_exit; + } + } + + /* write the data into interrupt_out_buffer from userspace */ + bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size); + if (bytes_to_write < count) + dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write); + + dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __FUNCTION__, count, bytes_to_write); + + if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) { + retval = -EFAULT; + goto unlock_exit; + } + + if (dev->interrupt_out_endpoint == NULL) { + err("Endpoint should not be be null! \n"); + goto unlock_exit; + } + + /* send off the urb */ + usb_fill_int_urb(dev->interrupt_out_urb, + interface_to_usbdev(dev->intf), + usb_sndintpipe(interface_to_usbdev(dev->intf), + dev->interrupt_out_endpoint->bEndpointAddress), + dev->interrupt_out_buffer, + bytes_to_write, + usb_tranzport_interrupt_out_callback, + dev, + dev->interrupt_out_interval); + + dev->interrupt_out_busy = 1; + wmb(); + + retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL); + if (retval) { + dev->interrupt_out_busy = 0; + err("Couldn't submit interrupt_out_urb %d\n", retval); + goto unlock_exit; + } + retval = bytes_to_write; + +unlock_exit: + /* unlock the device */ + up(&dev->sem); + +exit: + return retval; +} + +/* file operations needed when we register this driver */ +static const struct file_operations usb_tranzport_fops = { + .owner = THIS_MODULE, + .read = usb_tranzport_read, + .write = usb_tranzport_write, + .open = usb_tranzport_open, + .release = usb_tranzport_release, + .poll = usb_tranzport_poll, +}; + +/* + * usb class driver info in order to get a minor number from the usb core, + * and to have the device registered with the driver core + */ +static struct usb_class_driver usb_tranzport_class = { + .name = "tranzport%d", + .fops = &usb_tranzport_fops, + .minor_base = USB_TRANZPORT_MINOR_BASE, +}; + + +/** + * usb_tranzport_probe + * + * Called by the usb core when a new device is connected that it thinks + * this driver might be interested in. + */ +static int usb_tranzport_probe(struct usb_interface *intf, const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(intf); + struct usb_tranzport *dev = NULL; + struct usb_host_interface *iface_desc; + struct usb_endpoint_descriptor *endpoint; + int i; + int true_size; + int retval = -ENOMEM; + + /* allocate memory for our device state and intialize it */ + + dev = kzalloc(sizeof(*dev), GFP_KERNEL); + if (dev == NULL) { + dev_err(&intf->dev, "Out of memory\n"); + goto exit; + } + init_MUTEX(&dev->sem); + dev->intf = intf; + init_waitqueue_head(&dev->read_wait); + init_waitqueue_head(&dev->write_wait); + + iface_desc = intf->cur_altsetting; + + /* set up the endpoint information */ + for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { + endpoint = &iface_desc->endpoint[i].desc; + + if (usb_endpoint_is_int_in(endpoint)) + dev->interrupt_in_endpoint = endpoint; + + if (usb_endpoint_is_int_out(endpoint)) + dev->interrupt_out_endpoint = endpoint; + } + if (dev->interrupt_in_endpoint == NULL) { + dev_err(&intf->dev, "Interrupt in endpoint not found\n"); + goto error; + } + if (dev->interrupt_out_endpoint == NULL) + dev_warn(&intf->dev, "Interrupt out endpoint not found (using control endpoint instead)\n"); + + + dev->interrupt_in_endpoint_size = le16_to_cpu(dev->interrupt_in_endpoint->wMaxPacketSize); + + if (dev->interrupt_in_endpoint_size != 8) + dev_warn(&intf->dev, "Interrupt in endpoint size is not 8!\n"); + + if(ring_buffer_size == 0) { ring_buffer_size = RING_BUFFER_SIZE; } + true_size = min(ring_buffer_size,RING_BUFFER_SIZE); + /* FIXME - there are more usb_alloc routines for dma correctness. Needed? */ + + dev->ring_buffer = kmalloc((true_size*sizeof(struct tranzport_cmd))+8, GFP_KERNEL); + + if (!dev->ring_buffer) { + dev_err(&intf->dev, "Couldn't allocate ring_buffer of size %d\n",true_size); + goto error; + } + dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL); + if (!dev->interrupt_in_buffer) { + dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n"); + goto error; + } + dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); + if (!dev->interrupt_in_urb) { + dev_err(&intf->dev, "Couldn't allocate interrupt_in_urb\n"); + goto error; + } + dev->interrupt_out_endpoint_size = dev->interrupt_out_endpoint ? le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize) : + udev->descriptor.bMaxPacketSize0; + + if (dev->interrupt_out_endpoint_size !=8) + dev_warn(&intf->dev, "Interrupt out endpoint size is not 8!)\n"); + + dev->interrupt_out_buffer = kmalloc(write_buffer_size*dev->interrupt_out_endpoint_size, GFP_KERNEL); + if (!dev->interrupt_out_buffer) { + dev_err(&intf->dev, "Couldn't allocate interrupt_out_buffer\n"); + goto error; + } + dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); + if (!dev->interrupt_out_urb) { + dev_err(&intf->dev, "Couldn't allocate interrupt_out_urb\n"); + goto error; + } + dev->interrupt_in_interval = min_interrupt_in_interval > dev->interrupt_in_endpoint->bInterval ? min_interrupt_in_interval : dev->interrupt_in_endpoint->bInterval; + if (dev->interrupt_out_endpoint) + dev->interrupt_out_interval = min_interrupt_out_interval > dev->interrupt_out_endpoint->bInterval ? min_interrupt_out_interval : dev->interrupt_out_endpoint->bInterval; + + /* we can register the device now, as it is ready */ + usb_set_intfdata(intf, dev); + + retval = usb_register_dev(intf, &usb_tranzport_class); + if (retval) { + /* something prevented us from registering this driver */ + dev_err(&intf->dev, "Not able to get a minor for this device.\n"); + usb_set_intfdata(intf, NULL); + goto error; + } + + if((retval = device_create_file(&intf->dev, &dev_attr_LightRecord))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_LightTrackrec))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_LightTrackmute))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_LightTracksolo))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_LightAnysolo))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_LightLoop))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_LightPunch))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_wheel))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_event))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_dump_state))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_compress_wheel))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_enable))) goto error; + if((retval = device_create_file(&intf->dev, &dev_attr_offline))) goto error; + + /* let the user know what node this device is now attached to */ + dev_info(&intf->dev, "Tranzport Device #%d now attached to major %d minor %d\n", + (intf->minor - USB_TRANZPORT_MINOR_BASE), USB_MAJOR, intf->minor); + +exit: + return retval; + +error: + usb_tranzport_delete(dev); + + return retval; +} + +/** + * usb_tranzport_disconnect + * + * Called by the usb core when the device is removed from the system. + */ +static void usb_tranzport_disconnect(struct usb_interface *intf) +{ + struct usb_tranzport *dev; + int minor; + mutex_lock(&disconnect_mutex); + dev = usb_get_intfdata(intf); + usb_set_intfdata(intf, NULL); + down(&dev->sem); + minor = intf->minor; + /* give back our minor */ + usb_deregister_dev(intf, &usb_tranzport_class); + + /* if the device is not opened, then we clean up right now */ + if (!dev->open_count) { + up(&dev->sem); + usb_tranzport_delete(dev); + } else { + dev->intf = NULL; + up(&dev->sem); + } + + mutex_unlock(&disconnect_mutex); + + dev_info(&intf->dev, "Tranzport Surface #%d now disconnected\n", + (minor - USB_TRANZPORT_MINOR_BASE)); +} + +/* usb specific object needed to register this driver with the usb subsystem */ +static struct usb_driver usb_tranzport_driver = { + .name = "tranzport", + .probe = usb_tranzport_probe, + .disconnect = usb_tranzport_disconnect, + .id_table = usb_tranzport_table, +}; + +/** + * usb_tranzport_init + */ +static int __init usb_tranzport_init(void) +{ + int retval; + + /* register this driver with the USB subsystem */ + retval = usb_register(&usb_tranzport_driver); + if (retval) + err("usb_register failed for the "__FILE__" driver. Error number %d\n", retval); + + return retval; +} + +/** + * usb_tranzport_exit + */ +static void __exit usb_tranzport_exit(void) +{ + /* deregister this driver with the USB subsystem */ + usb_deregister(&usb_tranzport_driver); +} + +module_init(usb_tranzport_init); +module_exit(usb_tranzport_exit); + |