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