Merge 'for-linus' branch of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/shaggy...
[linux-2.6] / 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/config.h>
18 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/init.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 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         .owner =        THIS_MODULE,
54         .name =         "cytherm",
55         .probe =        cytherm_probe,
56         .disconnect =   cytherm_disconnect,
57         .id_table =     id_table,
58 };
59
60 /* Vendor requests */
61 /* They all operate on one byte at a time */
62 #define PING       0x00
63 #define READ_ROM   0x01 /* Reads form ROM, value = address */
64 #define READ_RAM   0x02 /* Reads form RAM, value = address */
65 #define WRITE_RAM  0x03 /* Write to RAM, value = address, index = data */
66 #define READ_PORT  0x04 /* Reads from port, value = address */
67 #define WRITE_PORT 0x05 /* Write to port, value = address, index = data */ 
68
69
70 /* Send a vendor command to device */
71 static int vendor_command(struct usb_device *dev, unsigned char request, 
72                           unsigned char value, unsigned char index,
73                           void *buf, int size)
74 {
75         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
76                                request, 
77                                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
78                                value, 
79                                index, buf, size,
80                                USB_CTRL_GET_TIMEOUT);
81 }
82
83
84
85 #define BRIGHTNESS 0x2c     /* RAM location for brightness value */
86 #define BRIGHTNESS_SEM 0x2b /* RAM location for brightness semaphore */
87
88 static ssize_t show_brightness(struct device *dev, struct device_attribute *attr, char *buf)
89 {
90         struct usb_interface *intf = to_usb_interface(dev);    
91         struct usb_cytherm *cytherm = usb_get_intfdata(intf);     
92
93         return sprintf(buf, "%i", cytherm->brightness);
94 }
95
96 static ssize_t set_brightness(struct device *dev, struct device_attribute *attr, const char *buf,
97                               size_t count)
98 {
99         struct usb_interface *intf = to_usb_interface(dev);
100         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
101
102         unsigned char *buffer;
103         int retval;
104    
105         buffer = kmalloc(8, GFP_KERNEL);
106         if (!buffer) {
107                 dev_err(&cytherm->udev->dev, "out of memory\n");
108                 return 0;
109         }
110
111         cytherm->brightness = simple_strtoul(buf, NULL, 10);
112    
113         if (cytherm->brightness > 0xFF)
114                 cytherm->brightness = 0xFF;
115         else if (cytherm->brightness < 0)
116                 cytherm->brightness = 0;
117    
118         /* Set brightness */
119         retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS, 
120                                 cytherm->brightness, buffer, 8);
121         if (retval)
122                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
123         /* Inform µC that we have changed the brightness setting */
124         retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS_SEM,
125                                 0x01, buffer, 8);
126         if (retval)
127                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
128    
129         kfree(buffer);
130    
131         return count;
132 }
133
134 static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR | S_IWGRP, 
135                    show_brightness, set_brightness);
136
137
138 #define TEMP 0x33 /* RAM location for temperature */
139 #define SIGN 0x34 /* RAM location for temperature sign */
140
141 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
142 {
143
144         struct usb_interface *intf = to_usb_interface(dev);
145         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
146
147         int retval;
148         unsigned char *buffer;
149
150         int temp, sign;
151    
152         buffer = kmalloc(8, GFP_KERNEL);
153         if (!buffer) {
154                 dev_err(&cytherm->udev->dev, "out of memory\n");
155                 return 0;
156         }
157
158         /* read temperature */
159         retval = vendor_command(cytherm->udev, READ_RAM, TEMP, 0, buffer, 8);
160         if (retval)
161                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
162         temp = buffer[1];
163    
164         /* read sign */
165         retval = vendor_command(cytherm->udev, READ_RAM, SIGN, 0, buffer, 8);
166         if (retval)
167                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
168         sign = buffer[1];
169
170         kfree(buffer);
171    
172         return sprintf(buf, "%c%i.%i", sign ? '-' : '+', temp >> 1,
173                        5*(temp - ((temp >> 1) << 1)));
174 }
175
176
177 static ssize_t set_temp(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
178 {
179         return count;
180 }
181
182 static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);
183
184
185 #define BUTTON 0x7a
186
187 static ssize_t show_button(struct device *dev, struct device_attribute *attr, char *buf)
188 {
189
190         struct usb_interface *intf = to_usb_interface(dev);
191         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
192
193         int retval;
194         unsigned char *buffer;
195
196         buffer = kmalloc(8, GFP_KERNEL);
197         if (!buffer) {
198                 dev_err(&cytherm->udev->dev, "out of memory\n");
199                 return 0;
200         }
201
202         /* check button */
203         retval = vendor_command(cytherm->udev, READ_RAM, BUTTON, 0, buffer, 8);
204         if (retval)
205                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
206    
207         retval = buffer[1];
208
209         kfree(buffer);
210
211         if (retval)
212                 return sprintf(buf, "1");
213         else
214                 return sprintf(buf, "0");
215 }
216
217
218 static ssize_t set_button(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
219 {
220         return count;
221 }
222
223 static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);
224
225
226 static ssize_t show_port0(struct device *dev, struct device_attribute *attr, char *buf)
227 {
228         struct usb_interface *intf = to_usb_interface(dev);
229         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
230
231         int retval;
232         unsigned char *buffer;
233
234         buffer = kmalloc(8, GFP_KERNEL);
235         if (!buffer) {
236                 dev_err(&cytherm->udev->dev, "out of memory\n");
237                 return 0;
238         }
239
240         retval = vendor_command(cytherm->udev, READ_PORT, 0, 0, buffer, 8);
241         if (retval)
242                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
243
244         retval = buffer[1];
245
246         kfree(buffer);
247
248         return sprintf(buf, "%d", retval);
249 }
250
251
252 static ssize_t set_port0(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
253 {
254         struct usb_interface *intf = to_usb_interface(dev);
255         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
256
257         unsigned char *buffer;
258         int retval;
259         int tmp;
260    
261         buffer = kmalloc(8, GFP_KERNEL);
262         if (!buffer) {
263                 dev_err(&cytherm->udev->dev, "out of memory\n");
264                 return 0;
265         }
266
267         tmp = simple_strtoul(buf, NULL, 10);
268    
269         if (tmp > 0xFF)
270                 tmp = 0xFF;
271         else if (tmp < 0)
272                 tmp = 0;
273    
274         retval = vendor_command(cytherm->udev, WRITE_PORT, 0,
275                                 tmp, buffer, 8);
276         if (retval)
277                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
278
279         kfree(buffer);
280
281         return count;
282 }
283
284 static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR | S_IWGRP, show_port0, set_port0);
285
286 static ssize_t show_port1(struct device *dev, struct device_attribute *attr, char *buf)
287 {
288         struct usb_interface *intf = to_usb_interface(dev);
289         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
290
291         int retval;
292         unsigned char *buffer;
293
294         buffer = kmalloc(8, GFP_KERNEL);
295         if (!buffer) {
296                 dev_err(&cytherm->udev->dev, "out of memory\n");
297                 return 0;
298         }
299
300         retval = vendor_command(cytherm->udev, READ_PORT, 1, 0, buffer, 8);
301         if (retval)
302                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
303    
304         retval = buffer[1];
305
306         kfree(buffer);
307
308         return sprintf(buf, "%d", retval);
309 }
310
311
312 static ssize_t set_port1(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
313 {
314         struct usb_interface *intf = to_usb_interface(dev);
315         struct usb_cytherm *cytherm = usb_get_intfdata(intf);
316
317         unsigned char *buffer;
318         int retval;
319         int tmp;
320    
321         buffer = kmalloc(8, GFP_KERNEL);
322         if (!buffer) {
323                 dev_err(&cytherm->udev->dev, "out of memory\n");
324                 return 0;
325         }
326
327         tmp = simple_strtoul(buf, NULL, 10);
328    
329         if (tmp > 0xFF)
330                 tmp = 0xFF;
331         else if (tmp < 0)
332                 tmp = 0;
333    
334         retval = vendor_command(cytherm->udev, WRITE_PORT, 1,
335                                 tmp, buffer, 8);
336         if (retval)
337                 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
338
339         kfree(buffer);
340
341         return count;
342 }
343
344 static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR | S_IWGRP, show_port1, set_port1);
345
346
347
348 static int cytherm_probe(struct usb_interface *interface, 
349                          const struct usb_device_id *id)
350 {
351         struct usb_device *udev = interface_to_usbdev(interface);
352         struct usb_cytherm *dev = NULL;
353         int retval = -ENOMEM;
354
355         dev = kmalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
356         if (dev == NULL) {
357                 dev_err (&interface->dev, "Out of memory\n");
358                 goto error;
359         }
360         memset (dev, 0x00, sizeof (*dev));
361
362         dev->udev = usb_get_dev(udev);
363
364         usb_set_intfdata (interface, dev);
365
366         dev->brightness = 0xFF;
367
368         device_create_file(&interface->dev, &dev_attr_brightness);   
369         device_create_file(&interface->dev, &dev_attr_temp);
370         device_create_file(&interface->dev, &dev_attr_button);
371         device_create_file(&interface->dev, &dev_attr_port0);
372         device_create_file(&interface->dev, &dev_attr_port1);
373
374         dev_info (&interface->dev, 
375                   "Cypress thermometer device now attached\n");
376         return 0;
377
378  error:
379         kfree(dev);
380         return retval;
381 }
382
383 static void cytherm_disconnect(struct usb_interface *interface)
384 {
385         struct usb_cytherm *dev;
386
387         dev = usb_get_intfdata (interface);
388         usb_set_intfdata (interface, NULL);
389
390         device_remove_file(&interface->dev, &dev_attr_brightness);
391         device_remove_file(&interface->dev, &dev_attr_temp);
392         device_remove_file(&interface->dev, &dev_attr_button);
393         device_remove_file(&interface->dev, &dev_attr_port0);
394         device_remove_file(&interface->dev, &dev_attr_port1);
395
396         usb_put_dev(dev->udev);
397
398         kfree(dev);
399
400         dev_info(&interface->dev, "Cypress thermometer now disconnected\n");
401 }
402
403
404 static int __init usb_cytherm_init(void)
405 {
406         int result;
407
408         result = usb_register(&cytherm_driver);
409         if (result) 
410         {       
411                 err("usb_register failed. Error number %d", result);
412                 return result;
413         }
414
415         info(DRIVER_VERSION ":" DRIVER_DESC);
416         return 0;
417 }
418
419 static void __exit usb_cytherm_exit(void)
420 {
421         usb_deregister(&cytherm_driver);
422 }
423
424
425 module_init (usb_cytherm_init);
426 module_exit (usb_cytherm_exit);
427
428 MODULE_AUTHOR(DRIVER_AUTHOR);
429 MODULE_DESCRIPTION(DRIVER_DESC);
430 MODULE_LICENSE("GPL");