xref: /openbmc/linux/drivers/usb/misc/cytherm.c (revision 9ac8d3fb)
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/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 
30 static struct usb_device_id id_table [] = {
31 	{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
32 	{ }
33 };
34 MODULE_DEVICE_TABLE (usb, id_table);
35 
36 /* Structure to hold all of our device specific stuff */
37 struct 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 */
45 static int cytherm_probe(struct usb_interface *interface,
46 			 const struct usb_device_id *id);
47 static void cytherm_disconnect(struct usb_interface *interface);
48 
49 
50 /* usb specific object needed to register this driver with the usb subsystem */
51 static 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 */
69 static 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 
86 static 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 
94 static 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 		dev_err(&cytherm->udev->dev, "out of memory\n");
106 		return 0;
107 	}
108 
109 	cytherm->brightness = simple_strtoul(buf, NULL, 10);
110 
111 	if (cytherm->brightness > 0xFF)
112 		cytherm->brightness = 0xFF;
113 	else if (cytherm->brightness < 0)
114 		cytherm->brightness = 0;
115 
116 	/* Set brightness */
117 	retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS,
118 				cytherm->brightness, buffer, 8);
119 	if (retval)
120 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
121 	/* Inform µC that we have changed the brightness setting */
122 	retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS_SEM,
123 				0x01, buffer, 8);
124 	if (retval)
125 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
126 
127 	kfree(buffer);
128 
129 	return count;
130 }
131 
132 static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR | S_IWGRP,
133 		   show_brightness, set_brightness);
134 
135 
136 #define TEMP 0x33 /* RAM location for temperature */
137 #define SIGN 0x34 /* RAM location for temperature sign */
138 
139 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
140 {
141 
142 	struct usb_interface *intf = to_usb_interface(dev);
143 	struct usb_cytherm *cytherm = usb_get_intfdata(intf);
144 
145 	int retval;
146 	unsigned char *buffer;
147 
148 	int temp, sign;
149 
150 	buffer = kmalloc(8, GFP_KERNEL);
151 	if (!buffer) {
152 		dev_err(&cytherm->udev->dev, "out of memory\n");
153 		return 0;
154 	}
155 
156 	/* read temperature */
157 	retval = vendor_command(cytherm->udev, READ_RAM, TEMP, 0, buffer, 8);
158 	if (retval)
159 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
160 	temp = buffer[1];
161 
162 	/* read sign */
163 	retval = vendor_command(cytherm->udev, READ_RAM, SIGN, 0, buffer, 8);
164 	if (retval)
165 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
166 	sign = buffer[1];
167 
168 	kfree(buffer);
169 
170 	return sprintf(buf, "%c%i.%i", sign ? '-' : '+', temp >> 1,
171 		       5*(temp - ((temp >> 1) << 1)));
172 }
173 
174 
175 static ssize_t set_temp(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
176 {
177 	return count;
178 }
179 
180 static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);
181 
182 
183 #define BUTTON 0x7a
184 
185 static ssize_t show_button(struct device *dev, struct device_attribute *attr, char *buf)
186 {
187 
188 	struct usb_interface *intf = to_usb_interface(dev);
189 	struct usb_cytherm *cytherm = usb_get_intfdata(intf);
190 
191 	int retval;
192 	unsigned char *buffer;
193 
194 	buffer = kmalloc(8, GFP_KERNEL);
195 	if (!buffer) {
196 		dev_err(&cytherm->udev->dev, "out of memory\n");
197 		return 0;
198 	}
199 
200 	/* check button */
201 	retval = vendor_command(cytherm->udev, READ_RAM, BUTTON, 0, buffer, 8);
202 	if (retval)
203 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
204 
205 	retval = buffer[1];
206 
207 	kfree(buffer);
208 
209 	if (retval)
210 		return sprintf(buf, "1");
211 	else
212 		return sprintf(buf, "0");
213 }
214 
215 
216 static ssize_t set_button(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
217 {
218 	return count;
219 }
220 
221 static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);
222 
223 
224 static ssize_t show_port0(struct device *dev, struct device_attribute *attr, char *buf)
225 {
226 	struct usb_interface *intf = to_usb_interface(dev);
227 	struct usb_cytherm *cytherm = usb_get_intfdata(intf);
228 
229 	int retval;
230 	unsigned char *buffer;
231 
232 	buffer = kmalloc(8, GFP_KERNEL);
233 	if (!buffer) {
234 		dev_err(&cytherm->udev->dev, "out of memory\n");
235 		return 0;
236 	}
237 
238 	retval = vendor_command(cytherm->udev, READ_PORT, 0, 0, buffer, 8);
239 	if (retval)
240 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
241 
242 	retval = buffer[1];
243 
244 	kfree(buffer);
245 
246 	return sprintf(buf, "%d", retval);
247 }
248 
249 
250 static ssize_t set_port0(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
251 {
252 	struct usb_interface *intf = to_usb_interface(dev);
253 	struct usb_cytherm *cytherm = usb_get_intfdata(intf);
254 
255 	unsigned char *buffer;
256 	int retval;
257 	int tmp;
258 
259 	buffer = kmalloc(8, GFP_KERNEL);
260 	if (!buffer) {
261 		dev_err(&cytherm->udev->dev, "out of memory\n");
262 		return 0;
263 	}
264 
265 	tmp = simple_strtoul(buf, NULL, 10);
266 
267 	if (tmp > 0xFF)
268 		tmp = 0xFF;
269 	else if (tmp < 0)
270 		tmp = 0;
271 
272 	retval = vendor_command(cytherm->udev, WRITE_PORT, 0,
273 				tmp, buffer, 8);
274 	if (retval)
275 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
276 
277 	kfree(buffer);
278 
279 	return count;
280 }
281 
282 static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR | S_IWGRP, show_port0, set_port0);
283 
284 static ssize_t show_port1(struct device *dev, struct device_attribute *attr, char *buf)
285 {
286 	struct usb_interface *intf = to_usb_interface(dev);
287 	struct usb_cytherm *cytherm = usb_get_intfdata(intf);
288 
289 	int retval;
290 	unsigned char *buffer;
291 
292 	buffer = kmalloc(8, GFP_KERNEL);
293 	if (!buffer) {
294 		dev_err(&cytherm->udev->dev, "out of memory\n");
295 		return 0;
296 	}
297 
298 	retval = vendor_command(cytherm->udev, READ_PORT, 1, 0, buffer, 8);
299 	if (retval)
300 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
301 
302 	retval = buffer[1];
303 
304 	kfree(buffer);
305 
306 	return sprintf(buf, "%d", retval);
307 }
308 
309 
310 static ssize_t set_port1(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
311 {
312 	struct usb_interface *intf = to_usb_interface(dev);
313 	struct usb_cytherm *cytherm = usb_get_intfdata(intf);
314 
315 	unsigned char *buffer;
316 	int retval;
317 	int tmp;
318 
319 	buffer = kmalloc(8, GFP_KERNEL);
320 	if (!buffer) {
321 		dev_err(&cytherm->udev->dev, "out of memory\n");
322 		return 0;
323 	}
324 
325 	tmp = simple_strtoul(buf, NULL, 10);
326 
327 	if (tmp > 0xFF)
328 		tmp = 0xFF;
329 	else if (tmp < 0)
330 		tmp = 0;
331 
332 	retval = vendor_command(cytherm->udev, WRITE_PORT, 1,
333 				tmp, buffer, 8);
334 	if (retval)
335 		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
336 
337 	kfree(buffer);
338 
339 	return count;
340 }
341 
342 static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR | S_IWGRP, show_port1, set_port1);
343 
344 
345 
346 static int cytherm_probe(struct usb_interface *interface,
347 			 const struct usb_device_id *id)
348 {
349 	struct usb_device *udev = interface_to_usbdev(interface);
350 	struct usb_cytherm *dev = NULL;
351 	int retval = -ENOMEM;
352 
353 	dev = kzalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
354 	if (dev == NULL) {
355 		dev_err (&interface->dev, "Out of memory\n");
356 		goto error_mem;
357 	}
358 
359 	dev->udev = usb_get_dev(udev);
360 
361 	usb_set_intfdata (interface, dev);
362 
363 	dev->brightness = 0xFF;
364 
365 	retval = device_create_file(&interface->dev, &dev_attr_brightness);
366 	if (retval)
367 		goto error;
368 	retval = device_create_file(&interface->dev, &dev_attr_temp);
369 	if (retval)
370 		goto error;
371 	retval = device_create_file(&interface->dev, &dev_attr_button);
372 	if (retval)
373 		goto error;
374 	retval = device_create_file(&interface->dev, &dev_attr_port0);
375 	if (retval)
376 		goto error;
377 	retval = device_create_file(&interface->dev, &dev_attr_port1);
378 	if (retval)
379 		goto error;
380 
381 	dev_info (&interface->dev,
382 		  "Cypress thermometer device now attached\n");
383 	return 0;
384 error:
385 	device_remove_file(&interface->dev, &dev_attr_brightness);
386 	device_remove_file(&interface->dev, &dev_attr_temp);
387 	device_remove_file(&interface->dev, &dev_attr_button);
388 	device_remove_file(&interface->dev, &dev_attr_port0);
389 	device_remove_file(&interface->dev, &dev_attr_port1);
390 	usb_set_intfdata (interface, NULL);
391 	usb_put_dev(dev->udev);
392 	kfree(dev);
393 error_mem:
394 	return retval;
395 }
396 
397 static void cytherm_disconnect(struct usb_interface *interface)
398 {
399 	struct usb_cytherm *dev;
400 
401 	dev = usb_get_intfdata (interface);
402 
403 	device_remove_file(&interface->dev, &dev_attr_brightness);
404 	device_remove_file(&interface->dev, &dev_attr_temp);
405 	device_remove_file(&interface->dev, &dev_attr_button);
406 	device_remove_file(&interface->dev, &dev_attr_port0);
407 	device_remove_file(&interface->dev, &dev_attr_port1);
408 
409 	/* first remove the files, then NULL the pointer */
410 	usb_set_intfdata (interface, NULL);
411 
412 	usb_put_dev(dev->udev);
413 
414 	kfree(dev);
415 
416 	dev_info(&interface->dev, "Cypress thermometer now disconnected\n");
417 }
418 
419 
420 static int __init usb_cytherm_init(void)
421 {
422 	int result;
423 
424 	result = usb_register(&cytherm_driver);
425 	if (result) {
426 		printk(KERN_ERR KBUILD_MODNAME ": usb_register failed! "
427 		       "Error number: %d\n", result);
428 		return result;
429 	}
430 
431 	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
432 	       DRIVER_DESC "\n");
433 	return 0;
434 }
435 
436 static void __exit usb_cytherm_exit(void)
437 {
438 	usb_deregister(&cytherm_driver);
439 }
440 
441 
442 module_init (usb_cytherm_init);
443 module_exit (usb_cytherm_exit);
444 
445 MODULE_AUTHOR(DRIVER_AUTHOR);
446 MODULE_DESCRIPTION(DRIVER_DESC);
447 MODULE_LICENSE("GPL");
448