Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-2.6.git] / drivers / usb / misc / cytherm.c
1 /* -*- linux-c -*-
2  * Cypress USB Thermometer driver 
3  * 
4  * Copyright (c) 2004 Erik Rigtorp <erkki@linux.nu> <erik@rigtorp.com>
5  * 
6  * This driver works with Elektor magazine USB Interface as published in 
7  * issue #291. It should also work with the original starter kit/demo board
8  * from Cypress.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation, version 2.
13  *
14  */
15
16
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/module.h>
22 #include <linux/usb.h>
23
24 #define DRIVER_VERSION "v1.0"
25 #define DRIVER_AUTHOR "Erik Rigtorp"
26 #define DRIVER_DESC "Cypress USB Thermometer driver"
27
28 #define USB_SKEL_VENDOR_ID      0x04b4
29 #define USB_SKEL_PRODUCT_ID     0x0002
30
31 static const struct usb_device_id id_table[] = {
32         { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
33         { }
34 };
35 MODULE_DEVICE_TABLE (usb, id_table);
36
37 /* Structure to hold all of our device specific stuff */
38 struct usb_cytherm {
39         struct usb_device    *udev;      /* save off the usb device pointer */
40         struct usb_interface *interface; /* the interface for this device */
41         int brightness;
42 };
43
44
45 /* local function prototypes */
46 static int cytherm_probe(struct usb_interface *interface, 
47                          const struct usb_device_id *id);
48 static void cytherm_disconnect(struct usb_interface *interface);
49
50
51 /* usb specific object needed to register this driver with the usb subsystem */
52 static struct usb_driver cytherm_driver = {
53         .name =         "cytherm",
54         .probe =        cytherm_probe,
55         .disconnect =   cytherm_disconnect,
56         .id_table =     id_table,
57 };
58
59 /* Vendor requests */
60 /* They all operate on one byte at a time */
61 #define PING       0x00
62 #define READ_ROM   0x01 /* Reads form ROM, value = address */
63 #define READ_RAM   0x02 /* Reads form RAM, value = address */
64 #define WRITE_RAM  0x03 /* Write to RAM, value = address, index = data */
65 #define READ_PORT  0x04 /* Reads from port, value = address */
66 #define WRITE_PORT 0x05 /* Write to port, value = address, index = data */ 
67
68
69 /* Send a vendor command to device */
70 static int vendor_command(struct usb_device *dev, unsigned char request, 
71                           unsigned char value, unsigned char index,
72                           void *buf, int size)
73 {
74         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
75                                request, 
76                                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
77                                value, 
78                                index, buf, size,
79                                USB_CTRL_GET_TIMEOUT);
80 }
81
82
83
84 #define BRIGHTNESS 0x2c     /* RAM location for brightness value */
85 #define BRIGHTNESS_SEM 0x2b /* RAM location for brightness semaphore */
86
87 static ssize_t show_brightness(struct device *dev, struct device_attribute *attr, char *buf)
88 {
89         struct usb_interface *intf = to_usb_interface(dev);    
90         struct usb_cytherm *cytherm = usb_get_intfdata(intf);     
91
92         return sprintf(buf, "%i", cytherm->brightness);
93 }
94
95 static ssize_t set_brightness(struct device *dev, struct device_attribute *attr, const char *buf,
96                               size_t count)
97 {
98         struct usb_interface *intf = to_usb_interface(dev);
99         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
100
101         unsigned char *buffer;
102         int retval;
103    
104         buffer = kmalloc(8, GFP_KERNEL);
105         if (!buffer) {
106                 dev_err(&cytherm->udev->dev, "out of memory\n");
107                 return 0;
108         }
109
110         cytherm->brightness = simple_strtoul(buf, NULL, 10);
111    
112         if (cytherm->brightness > 0xFF)
113                 cytherm->brightness = 0xFF;
114         else if (cytherm->brightness < 0)
115                 cytherm->brightness = 0;
116    
117         /* Set brightness */
118         retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS, 
119                                 cytherm->brightness, buffer, 8);
120         if (retval)
121                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
122         /* Inform ┬ÁC that we have changed the brightness setting */
123         retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS_SEM,
124                                 0x01, buffer, 8);
125         if (retval)
126                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
127    
128         kfree(buffer);
129    
130         return count;
131 }
132
133 static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR | S_IWGRP, 
134                    show_brightness, set_brightness);
135
136
137 #define TEMP 0x33 /* RAM location for temperature */
138 #define SIGN 0x34 /* RAM location for temperature sign */
139
140 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
141 {
142
143         struct usb_interface *intf = to_usb_interface(dev);
144         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
145
146         int retval;
147         unsigned char *buffer;
148
149         int temp, sign;
150    
151         buffer = kmalloc(8, GFP_KERNEL);
152         if (!buffer) {
153                 dev_err(&cytherm->udev->dev, "out of memory\n");
154                 return 0;
155         }
156
157         /* read temperature */
158         retval = vendor_command(cytherm->udev, READ_RAM, TEMP, 0, buffer, 8);
159         if (retval)
160                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
161         temp = buffer[1];
162    
163         /* read sign */
164         retval = vendor_command(cytherm->udev, READ_RAM, SIGN, 0, buffer, 8);
165         if (retval)
166                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
167         sign = buffer[1];
168
169         kfree(buffer);
170    
171         return sprintf(buf, "%c%i.%i", sign ? '-' : '+', temp >> 1,
172                        5*(temp - ((temp >> 1) << 1)));
173 }
174
175
176 static ssize_t set_temp(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
177 {
178         return count;
179 }
180
181 static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);
182
183
184 #define BUTTON 0x7a
185
186 static ssize_t show_button(struct device *dev, struct device_attribute *attr, char *buf)
187 {
188
189         struct usb_interface *intf = to_usb_interface(dev);
190         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
191
192         int retval;
193         unsigned char *buffer;
194
195         buffer = kmalloc(8, GFP_KERNEL);
196         if (!buffer) {
197                 dev_err(&cytherm->udev->dev, "out of memory\n");
198                 return 0;
199         }
200
201         /* check button */
202         retval = vendor_command(cytherm->udev, READ_RAM, BUTTON, 0, buffer, 8);
203         if (retval)
204                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
205    
206         retval = buffer[1];
207
208         kfree(buffer);
209
210         if (retval)
211                 return sprintf(buf, "1");
212         else
213                 return sprintf(buf, "0");
214 }
215
216
217 static ssize_t set_button(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
218 {
219         return count;
220 }
221
222 static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);
223
224
225 static ssize_t show_port0(struct device *dev, struct device_attribute *attr, char *buf)
226 {
227         struct usb_interface *intf = to_usb_interface(dev);
228         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
229
230         int retval;
231         unsigned char *buffer;
232
233         buffer = kmalloc(8, GFP_KERNEL);
234         if (!buffer) {
235                 dev_err(&cytherm->udev->dev, "out of memory\n");
236                 return 0;
237         }
238
239         retval = vendor_command(cytherm->udev, READ_PORT, 0, 0, buffer, 8);
240         if (retval)
241                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
242
243         retval = buffer[1];
244
245         kfree(buffer);
246
247         return sprintf(buf, "%d", retval);
248 }
249
250
251 static ssize_t set_port0(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
252 {
253         struct usb_interface *intf = to_usb_interface(dev);
254         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
255
256         unsigned char *buffer;
257         int retval;
258         int tmp;
259    
260         buffer = kmalloc(8, GFP_KERNEL);
261         if (!buffer) {
262                 dev_err(&cytherm->udev->dev, "out of memory\n");
263                 return 0;
264         }
265
266         tmp = simple_strtoul(buf, NULL, 10);
267    
268         if (tmp > 0xFF)
269                 tmp = 0xFF;
270         else if (tmp < 0)
271                 tmp = 0;
272    
273         retval = vendor_command(cytherm->udev, WRITE_PORT, 0,
274                                 tmp, buffer, 8);
275         if (retval)
276                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
277
278         kfree(buffer);
279
280         return count;
281 }
282
283 static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR | S_IWGRP, show_port0, set_port0);
284
285 static ssize_t show_port1(struct device *dev, struct device_attribute *attr, char *buf)
286 {
287         struct usb_interface *intf = to_usb_interface(dev);
288         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
289
290         int retval;
291         unsigned char *buffer;
292
293         buffer = kmalloc(8, GFP_KERNEL);
294         if (!buffer) {
295                 dev_err(&cytherm->udev->dev, "out of memory\n");
296                 return 0;
297         }
298
299         retval = vendor_command(cytherm->udev, READ_PORT, 1, 0, buffer, 8);
300         if (retval)
301                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
302    
303         retval = buffer[1];
304
305         kfree(buffer);
306
307         return sprintf(buf, "%d", retval);
308 }
309
310
311 static ssize_t set_port1(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
312 {
313         struct usb_interface *intf = to_usb_interface(dev);
314         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
315
316         unsigned char *buffer;
317         int retval;
318         int tmp;
319    
320         buffer = kmalloc(8, GFP_KERNEL);
321         if (!buffer) {
322                 dev_err(&cytherm->udev->dev, "out of memory\n");
323                 return 0;
324         }
325
326         tmp = simple_strtoul(buf, NULL, 10);
327    
328         if (tmp > 0xFF)
329                 tmp = 0xFF;
330         else if (tmp < 0)
331                 tmp = 0;
332    
333         retval = vendor_command(cytherm->udev, WRITE_PORT, 1,
334                                 tmp, buffer, 8);
335         if (retval)
336                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
337
338         kfree(buffer);
339
340         return count;
341 }
342
343 static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR | S_IWGRP, show_port1, set_port1);
344
345
346
347 static int cytherm_probe(struct usb_interface *interface, 
348                          const struct usb_device_id *id)
349 {
350         struct usb_device *udev = interface_to_usbdev(interface);
351         struct usb_cytherm *dev = NULL;
352         int retval = -ENOMEM;
353
354         dev = kzalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
355         if (dev == NULL) {
356                 dev_err (&interface->dev, "Out of memory\n");
357                 goto error_mem;
358         }
359
360         dev->udev = usb_get_dev(udev);
361
362         usb_set_intfdata (interface, dev);
363
364         dev->brightness = 0xFF;
365
366         retval = device_create_file(&interface->dev, &dev_attr_brightness);
367         if (retval)
368                 goto error;
369         retval = device_create_file(&interface->dev, &dev_attr_temp);
370         if (retval)
371                 goto error;
372         retval = device_create_file(&interface->dev, &dev_attr_button);
373         if (retval)
374                 goto error;
375         retval = device_create_file(&interface->dev, &dev_attr_port0);
376         if (retval)
377                 goto error;
378         retval = device_create_file(&interface->dev, &dev_attr_port1);
379         if (retval)
380                 goto error;
381
382         dev_info (&interface->dev,
383                   "Cypress thermometer device now attached\n");
384         return 0;
385 error:
386         device_remove_file(&interface->dev, &dev_attr_brightness);
387         device_remove_file(&interface->dev, &dev_attr_temp);
388         device_remove_file(&interface->dev, &dev_attr_button);
389         device_remove_file(&interface->dev, &dev_attr_port0);
390         device_remove_file(&interface->dev, &dev_attr_port1);
391         usb_set_intfdata (interface, NULL);
392         usb_put_dev(dev->udev);
393         kfree(dev);
394 error_mem:
395         return retval;
396 }
397
398 static void cytherm_disconnect(struct usb_interface *interface)
399 {
400         struct usb_cytherm *dev;
401
402         dev = usb_get_intfdata (interface);
403
404         device_remove_file(&interface->dev, &dev_attr_brightness);
405         device_remove_file(&interface->dev, &dev_attr_temp);
406         device_remove_file(&interface->dev, &dev_attr_button);
407         device_remove_file(&interface->dev, &dev_attr_port0);
408         device_remove_file(&interface->dev, &dev_attr_port1);
409
410         /* first remove the files, then NULL the pointer */
411         usb_set_intfdata (interface, NULL);
412
413         usb_put_dev(dev->udev);
414
415         kfree(dev);
416
417         dev_info(&interface->dev, "Cypress thermometer now disconnected\n");
418 }
419
420
421 static int __init usb_cytherm_init(void)
422 {
423         int result;
424
425         result = usb_register(&cytherm_driver);
426         if (result) {
427                 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed! "
428                        "Error number: %d\n", result);
429                 return result;
430         }
431
432         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
433                DRIVER_DESC "\n");
434         return 0;
435 }
436
437 static void __exit usb_cytherm_exit(void)
438 {
439         usb_deregister(&cytherm_driver);
440 }
441
442
443 module_init (usb_cytherm_init);
444 module_exit (usb_cytherm_exit);
445
446 MODULE_AUTHOR(DRIVER_AUTHOR);
447 MODULE_DESCRIPTION(DRIVER_DESC);
448 MODULE_LICENSE("GPL");