Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 430 insertions, 0 deletions

diff --git a/drivers/usb/misc/cytherm.c b/drivers/usb/misc/cytherm.c
new file mode 100644
index 000000000000..626e2b05f719
--- /dev/null
+++ b/drivers/usb/misc/cytherm.c
@@ -0,0 +1,430 @@
+/* -*- linux-c -*-
+ * Cypress USB Thermometer driver 
+ * 
+ * Copyright (c) 2004 Erik Rigtorp <erkki@linux.nu> <erik@rigtorp.com>
+ * 
+ * This driver works with Elektor magazine USB Interface as published in 
+ * issue #291. It should also work with the original starter kit/demo board
+ * from Cypress.
+ *
+ * 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.
+ *
+ */
+
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+#define DRIVER_VERSION "v1.0"
+#define DRIVER_AUTHOR "Erik Rigtorp"
+#define DRIVER_DESC "Cypress USB Thermometer driver"
+
+#define USB_SKEL_VENDOR_ID      0x04b4
+#define USB_SKEL_PRODUCT_ID     0x0002
+
+static struct usb_device_id id_table [] = {
+        { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
+        { }
+};
+MODULE_DEVICE_TABLE (usb, id_table);
+
+/* Structure to hold all of our device specific stuff */
+struct usb_cytherm {
+        struct usb_device    *udev;      /* save off the usb device pointer */
+        struct usb_interface *interface; /* the interface for this device */
+        int brightness;
+};
+
+
+/* local function prototypes */
+static int cytherm_probe(struct usb_interface *interface, 
+                         const struct usb_device_id *id);
+static void cytherm_disconnect(struct usb_interface *interface);
+
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver cytherm_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "cytherm",
+        .probe =        cytherm_probe,
+        .disconnect =   cytherm_disconnect,
+        .id_table =     id_table,
+};
+
+/* Vendor requests */
+/* They all operate on one byte at a time */
+#define PING       0x00
+#define READ_ROM   0x01 /* Reads form ROM, value = address */
+#define READ_RAM   0x02 /* Reads form RAM, value = address */
+#define WRITE_RAM  0x03 /* Write to RAM, value = address, index = data */
+#define READ_PORT  0x04 /* Reads from port, value = address */
+#define WRITE_PORT 0x05 /* Write to port, value = address, index = data */ 
+
+
+/* Send a vendor command to device */
+static int vendor_command(struct usb_device *dev, unsigned char request, 
+                          unsigned char value, unsigned char index,
+                          void *buf, int size)
+{
+        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                               request, 
+                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
+                               value, 
+                               index, buf, size,
+                               USB_CTRL_GET_TIMEOUT);
+}
+
+
+
+#define BRIGHTNESS 0x2c     /* RAM location for brightness value */
+#define BRIGHTNESS_SEM 0x2b /* RAM location for brightness semaphore */
+
+static ssize_t show_brightness(struct device *dev, char *buf)
+{
+        struct usb_interface *intf = to_usb_interface(dev);    
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);     
+
+        return sprintf(buf, "%i", cytherm->brightness);
+}
+
+static ssize_t set_brightness(struct device *dev, const char *buf, 
+                              size_t count)
+{
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        unsigned char *buffer;
+        int retval;
+   
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        cytherm->brightness = simple_strtoul(buf, NULL, 10);
+   
+        if (cytherm->brightness > 0xFF)
+                cytherm->brightness = 0xFF;
+        else if (cytherm->brightness < 0)
+                cytherm->brightness = 0;
+   
+        /* Set brightness */
+        retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS, 
+                                cytherm->brightness, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+        /* Inform µC that we have changed the brightness setting */
+        retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS_SEM,
+                                0x01, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+   
+        kfree(buffer);
+   
+        return count;
+}
+
+static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR | S_IWGRP, 
+                   show_brightness, set_brightness);
+
+
+#define TEMP 0x33 /* RAM location for temperature */
+#define SIGN 0x34 /* RAM location for temperature sign */
+
+static ssize_t show_temp(struct device *dev, char *buf)
+{
+
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        int retval;
+        unsigned char *buffer;
+
+        int temp, sign;
+   
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        /* read temperature */
+        retval = vendor_command(cytherm->udev, READ_RAM, TEMP, 0, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+        temp = buffer[1];
+   
+        /* read sign */
+        retval = vendor_command(cytherm->udev, READ_RAM, SIGN, 0, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+        sign = buffer[1];
+
+        kfree(buffer);
+   
+        return sprintf(buf, "%c%i.%i", sign ? '-' : '+', temp >> 1,
+                       5*(temp - ((temp >> 1) << 1)));
+}
+
+
+static ssize_t set_temp(struct device *dev, const char *buf, size_t count)
+{
+        return count;
+}
+
+static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);
+
+
+#define BUTTON 0x7a
+
+static ssize_t show_button(struct device *dev, char *buf)
+{
+
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        int retval;
+        unsigned char *buffer;
+
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        /* check button */
+        retval = vendor_command(cytherm->udev, READ_RAM, BUTTON, 0, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+   
+        retval = buffer[1];
+
+        kfree(buffer);
+
+        if (retval)
+                return sprintf(buf, "1");
+        else
+                return sprintf(buf, "0");
+}
+
+
+static ssize_t set_button(struct device *dev, const char *buf, size_t count)
+{
+        return count;
+}
+
+static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);
+
+
+static ssize_t show_port0(struct device *dev, char *buf)
+{
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        int retval;
+        unsigned char *buffer;
+
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        retval = vendor_command(cytherm->udev, READ_PORT, 0, 0, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+
+        retval = buffer[1];
+
+        kfree(buffer);
+
+        return sprintf(buf, "%d", retval);
+}
+
+
+static ssize_t set_port0(struct device *dev, const char *buf, size_t count)
+{
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        unsigned char *buffer;
+        int retval;
+        int tmp;
+   
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        tmp = simple_strtoul(buf, NULL, 10);
+   
+        if (tmp > 0xFF)
+                tmp = 0xFF;
+        else if (tmp < 0)
+                tmp = 0;
+   
+        retval = vendor_command(cytherm->udev, WRITE_PORT, 0,
+                                tmp, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+
+        kfree(buffer);
+
+        return count;
+}
+
+static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR | S_IWGRP, show_port0, set_port0);
+
+static ssize_t show_port1(struct device *dev, char *buf)
+{
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        int retval;
+        unsigned char *buffer;
+
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        retval = vendor_command(cytherm->udev, READ_PORT, 1, 0, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+   
+        retval = buffer[1];
+
+        kfree(buffer);
+
+        return sprintf(buf, "%d", retval);
+}
+
+
+static ssize_t set_port1(struct device *dev, const char *buf, size_t count)
+{
+        struct usb_interface *intf = to_usb_interface(dev);
+        struct usb_cytherm *cytherm = usb_get_intfdata(intf);
+
+        unsigned char *buffer;
+        int retval;
+        int tmp;
+   
+        buffer = kmalloc(8, GFP_KERNEL);
+        if (!buffer) {
+                dev_err(&cytherm->udev->dev, "out of memory\n");
+                return 0;
+        }
+
+        tmp = simple_strtoul(buf, NULL, 10);
+   
+        if (tmp > 0xFF)
+                tmp = 0xFF;
+        else if (tmp < 0)
+                tmp = 0;
+   
+        retval = vendor_command(cytherm->udev, WRITE_PORT, 1,
+                                tmp, buffer, 8);
+        if (retval)
+                dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
+
+        kfree(buffer);
+
+        return count;
+}
+
+static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR | S_IWGRP, show_port1, set_port1);
+
+
+
+static int cytherm_probe(struct usb_interface *interface, 
+                         const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(interface);
+        struct usb_cytherm *dev = NULL;
+        int retval = -ENOMEM;
+
+        dev = kmalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
+        if (dev == NULL) {
+                dev_err (&interface->dev, "Out of memory\n");
+                goto error;
+        }
+        memset (dev, 0x00, sizeof (*dev));
+
+        dev->udev = usb_get_dev(udev);
+
+        usb_set_intfdata (interface, dev);
+
+        dev->brightness = 0xFF;
+
+        device_create_file(&interface->dev, &dev_attr_brightness);   
+        device_create_file(&interface->dev, &dev_attr_temp);
+        device_create_file(&interface->dev, &dev_attr_button);
+        device_create_file(&interface->dev, &dev_attr_port0);
+        device_create_file(&interface->dev, &dev_attr_port1);
+
+        dev_info (&interface->dev, 
+                  "Cypress thermometer device now attached\n");
+        return 0;
+
+ error:
+        kfree(dev);
+        return retval;
+}
+
+static void cytherm_disconnect(struct usb_interface *interface)
+{
+        struct usb_cytherm *dev;
+
+        dev = usb_get_intfdata (interface);
+        usb_set_intfdata (interface, NULL);
+
+        device_remove_file(&interface->dev, &dev_attr_brightness);
+        device_remove_file(&interface->dev, &dev_attr_temp);
+        device_remove_file(&interface->dev, &dev_attr_button);
+        device_remove_file(&interface->dev, &dev_attr_port0);
+        device_remove_file(&interface->dev, &dev_attr_port1);
+
+        usb_put_dev(dev->udev);
+
+        kfree(dev);
+
+        dev_info(&interface->dev, "Cypress thermometer now disconnected\n");
+}
+
+
+static int __init usb_cytherm_init(void)
+{
+        int result;
+
+        result = usb_register(&cytherm_driver);
+        if (result) 
+        {       
+                err("usb_register failed. Error number %d", result);
+                return result;
+        }
+
+        info(DRIVER_VERSION ":" DRIVER_DESC);
+        return 0;
+}
+
+static void __exit usb_cytherm_exit(void)
+{
+        usb_deregister(&cytherm_driver);
+}
+
+
+module_init (usb_cytherm_init);
+module_exit (usb_cytherm_exit);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");