Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/usb/misc/usbled.c

  1 /*
  2  * USB LED driver
  3  *
  4  * Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com)
  5  *
  6  *      This program is free software; you can redistribute it and/or
  7  *      modify it under the terms of the GNU General Public License as
  8  *      published by the Free Software Foundation, version 2.
  9  *
 10  */
 11 
 12 #include <linux/kernel.h>
 13 #include <linux/errno.h>
 14 #include <linux/slab.h>
 15 #include <linux/module.h>
 16 #include <linux/usb.h>
 17 
 18 
 19 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com"
 20 #define DRIVER_DESC "USB LED Driver"
 21 
 22 enum led_type {
 23         DELCOM_VISUAL_SIGNAL_INDICATOR,
 24         DREAM_CHEEKY_WEBMAIL_NOTIFIER,
 25 };
 26 
 27 /* table of devices that work with this driver */
 28 static const struct usb_device_id id_table[] = {
 29         { USB_DEVICE(0x0fc5, 0x1223),
 30                         .driver_info = DELCOM_VISUAL_SIGNAL_INDICATOR },
 31         { USB_DEVICE(0x1d34, 0x0004),
 32                         .driver_info = DREAM_CHEEKY_WEBMAIL_NOTIFIER },
 33         { USB_DEVICE(0x1d34, 0x000a),
 34                         .driver_info = DREAM_CHEEKY_WEBMAIL_NOTIFIER },
 35         { },
 36 };
 37 MODULE_DEVICE_TABLE(usb, id_table);
 38 
 39 struct usb_led {
 40         struct usb_device       *udev;
 41         unsigned char           blue;
 42         unsigned char           red;
 43         unsigned char           green;
 44         enum led_type           type;
 45 };
 46 
 47 static void change_color(struct usb_led *led)
 48 {
 49         int retval = 0;
 50         unsigned char *buffer;
 51 
 52         buffer = kmalloc(8, GFP_KERNEL);
 53         if (!buffer) {
 54                 dev_err(&led->udev->dev, "out of memory\n");
 55                 return;
 56         }
 57 
 58         switch (led->type) {
 59         case DELCOM_VISUAL_SIGNAL_INDICATOR: {
 60                 unsigned char color = 0x07;
 61 
 62                 if (led->blue)
 63                         color &= ~0x04;
 64                 if (led->red)
 65                         color &= ~0x02;
 66                 if (led->green)
 67                         color &= ~0x01;
 68                 dev_dbg(&led->udev->dev,
 69                         "blue = %d, red = %d, green = %d, color = %.2x\n",
 70                         led->blue, led->red, led->green, color);
 71 
 72                 retval = usb_control_msg(led->udev,
 73                                         usb_sndctrlpipe(led->udev, 0),
 74                                         0x12,
 75                                         0xc8,
 76                                         (0x02 * 0x100) + 0x0a,
 77                                         (0x00 * 0x100) + color,
 78                                         buffer,
 79                                         8,
 80                                         2000);
 81                 break;
 82         }
 83 
 84         case DREAM_CHEEKY_WEBMAIL_NOTIFIER:
 85                 dev_dbg(&led->udev->dev,
 86                         "red = %d, green = %d, blue = %d\n",
 87                         led->red, led->green, led->blue);
 88 
 89                 buffer[0] = led->red;
 90                 buffer[1] = led->green;
 91                 buffer[2] = led->blue;
 92                 buffer[3] = buffer[4] = buffer[5] = 0;
 93                 buffer[6] = 0x1a;
 94                 buffer[7] = 0x05;
 95 
 96                 retval = usb_control_msg(led->udev,
 97                                         usb_sndctrlpipe(led->udev, 0),
 98                                         0x09,
 99                                         0x21,
100                                         0x200,
101                                         0,
102                                         buffer,
103                                         8,
104                                         2000);
105                 break;
106 
107         default:
108                 dev_err(&led->udev->dev, "unknown device type %d\n", led->type);
109         }
110 
111         if (retval)
112                 dev_dbg(&led->udev->dev, "retval = %d\n", retval);
113         kfree(buffer);
114 }
115 
116 #define show_set(value) \
117 static ssize_t show_##value(struct device *dev, struct device_attribute *attr,\
118                             char *buf)                                  \
119 {                                                                       \
120         struct usb_interface *intf = to_usb_interface(dev);             \
121         struct usb_led *led = usb_get_intfdata(intf);                   \
122                                                                         \
123         return sprintf(buf, "%d\n", led->value);                        \
124 }                                                                       \
125 static ssize_t set_##value(struct device *dev, struct device_attribute *attr,\
126                            const char *buf, size_t count)               \
127 {                                                                       \
128         struct usb_interface *intf = to_usb_interface(dev);             \
129         struct usb_led *led = usb_get_intfdata(intf);                   \
130         int temp = simple_strtoul(buf, NULL, 10);                       \
131                                                                         \
132         led->value = temp;                                              \
133         change_color(led);                                              \
134         return count;                                                   \
135 }                                                                       \
136 static DEVICE_ATTR(value, S_IRUGO | S_IWUSR, show_##value, set_##value);
137 show_set(blue);
138 show_set(red);
139 show_set(green);
140 
141 static int led_probe(struct usb_interface *interface,
142                      const struct usb_device_id *id)
143 {
144         struct usb_device *udev = interface_to_usbdev(interface);
145         struct usb_led *dev = NULL;
146         int retval = -ENOMEM;
147 
148         dev = kzalloc(sizeof(struct usb_led), GFP_KERNEL);
149         if (dev == NULL) {
150                 dev_err(&interface->dev, "out of memory\n");
151                 goto error_mem;
152         }
153 
154         dev->udev = usb_get_dev(udev);
155         dev->type = id->driver_info;
156 
157         usb_set_intfdata(interface, dev);
158 
159         retval = device_create_file(&interface->dev, &dev_attr_blue);
160         if (retval)
161                 goto error;
162         retval = device_create_file(&interface->dev, &dev_attr_red);
163         if (retval)
164                 goto error;
165         retval = device_create_file(&interface->dev, &dev_attr_green);
166         if (retval)
167                 goto error;
168 
169         if (dev->type == DREAM_CHEEKY_WEBMAIL_NOTIFIER) {
170                 unsigned char *enable;
171 
172                 enable = kmemdup("\x1f\x02\0\x5f\0\0\x1a\x03", 8, GFP_KERNEL);
173                 if (!enable) {
174                         dev_err(&interface->dev, "out of memory\n");
175                         retval = -ENOMEM;
176                         goto error;
177                 }
178 
179                 retval = usb_control_msg(udev,
180                                         usb_sndctrlpipe(udev, 0),
181                                         0x09,
182                                         0x21,
183                                         0x200,
184                                         0,
185                                         enable,
186                                         8,
187                                         2000);
188 
189                 kfree(enable);
190                 if (retval != 8)
191                         goto error;
192         }
193 
194         dev_info(&interface->dev, "USB LED device now attached\n");
195         return 0;
196 
197 error:
198         device_remove_file(&interface->dev, &dev_attr_blue);
199         device_remove_file(&interface->dev, &dev_attr_red);
200         device_remove_file(&interface->dev, &dev_attr_green);
201         usb_set_intfdata(interface, NULL);
202         usb_put_dev(dev->udev);
203         kfree(dev);
204 error_mem:
205         return retval;
206 }
207 
208 static void led_disconnect(struct usb_interface *interface)
209 {
210         struct usb_led *dev;
211 
212         dev = usb_get_intfdata(interface);
213 
214         device_remove_file(&interface->dev, &dev_attr_blue);
215         device_remove_file(&interface->dev, &dev_attr_red);
216         device_remove_file(&interface->dev, &dev_attr_green);
217 
218         /* first remove the files, then set the pointer to NULL */
219         usb_set_intfdata(interface, NULL);
220 
221         usb_put_dev(dev->udev);
222 
223         kfree(dev);
224 
225         dev_info(&interface->dev, "USB LED now disconnected\n");
226 }
227 
228 static struct usb_driver led_driver = {
229         .name =         "usbled",
230         .probe =        led_probe,
231         .disconnect =   led_disconnect,
232         .id_table =     id_table,
233 };
234 
235 module_usb_driver(led_driver);
236 
237 MODULE_AUTHOR(DRIVER_AUTHOR);
238 MODULE_DESCRIPTION(DRIVER_DESC);
239 MODULE_LICENSE("GPL");
240 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us