[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / usb / misc / cytherm.c

/* -*- linux-c -*-
 * Cypress USB Thermometer driver 
 * 
 * Copyright (c) 2004 Erik Rigtorp <erkki@linux.nu> <erik@rigtorp.com>
 * 
 * This driver works with Elektor magazine USB Interface as published in 
 * issue #291. It should also work with the original starter kit/demo board
 * from Cypress.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, version 2.
 *
 */


#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/usb.h>

#define DRIVER_VERSION "v1.0"
#define DRIVER_AUTHOR "Erik Rigtorp"
#define DRIVER_DESC "Cypress USB Thermometer driver"

#define USB_SKEL_VENDOR_ID	0x04b4
#define USB_SKEL_PRODUCT_ID	0x0002

static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
	{ }
};
MODULE_DEVICE_TABLE (usb, id_table);

/* Structure to hold all of our device specific stuff */
struct usb_cytherm {
	struct usb_device    *udev;	 /* save off the usb device pointer */
	struct usb_interface *interface; /* the interface for this device */
	int brightness;
};


/* local function prototypes */
static int cytherm_probe(struct usb_interface *interface, 
			 const struct usb_device_id *id);
static void cytherm_disconnect(struct usb_interface *interface);


/* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver cytherm_driver = {
	.name =		"cytherm",
	.probe =	cytherm_probe,
	.disconnect =	cytherm_disconnect,
	.id_table =	id_table,
};

/* Vendor requests */
/* They all operate on one byte at a time */
#define PING       0x00
#define READ_ROM   0x01 /* Reads form ROM, value = address */
#define READ_RAM   0x02 /* Reads form RAM, value = address */
#define WRITE_RAM  0x03 /* Write to RAM, value = address, index = data */
#define READ_PORT  0x04 /* Reads from port, value = address */
#define WRITE_PORT 0x05 /* Write to port, value = address, index = data */ 


/* Send a vendor command to device */
static int vendor_command(struct usb_device *dev, unsigned char request, 
			  unsigned char value, unsigned char index,
			  void *buf, int size)
{
	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			       request, 
			       USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
			       value, 
			       index, buf, size,
			       USB_CTRL_GET_TIMEOUT);
}


#define BRIGHTNESS 0x2c     /* RAM location for brightness value */
#define BRIGHTNESS_SEM 0x2b /* RAM location for brightness semaphore */

static ssize_t show_brightness(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct usb_interface *intf = to_usb_interface(dev);    
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);     

	return sprintf(buf, "%i", cytherm->brightness);
}

static ssize_t set_brightness(struct device *dev, struct device_attribute *attr, const char *buf,
			      size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	unsigned char *buffer;
	int retval;
   
	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	cytherm->brightness = simple_strtoul(buf, NULL, 10);
   
	if (cytherm->brightness > 0xFF)
		cytherm->brightness = 0xFF;
	else if (cytherm->brightness < 0)
		cytherm->brightness = 0;
   
	/* Set brightness */
	retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS, 
				cytherm->brightness, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
	/* Inform µC that we have changed the brightness setting */
	retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS_SEM,
				0x01, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
   
	kfree(buffer);
   
	return count;
}

static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR | S_IWGRP, 
		   show_brightness, set_brightness);


#define TEMP 0x33 /* RAM location for temperature */
#define SIGN 0x34 /* RAM location for temperature sign */

static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
{

	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	int retval;
	unsigned char *buffer;

	int temp, sign;
   
	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	/* read temperature */
	retval = vendor_command(cytherm->udev, READ_RAM, TEMP, 0, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
	temp = buffer[1];
   
	/* read sign */
	retval = vendor_command(cytherm->udev, READ_RAM, SIGN, 0, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
	sign = buffer[1];

	kfree(buffer);
   
	return sprintf(buf, "%c%i.%i", sign ? '-' : '+', temp >> 1,
		       5*(temp - ((temp >> 1) << 1)));
}


static ssize_t set_temp(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	return count;
}

static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);


#define BUTTON 0x7a

static ssize_t show_button(struct device *dev, struct device_attribute *attr, char *buf)
{

	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	int retval;
	unsigned char *buffer;

	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	/* check button */
	retval = vendor_command(cytherm->udev, READ_RAM, BUTTON, 0, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
   
	retval = buffer[1];

	kfree(buffer);

	if (retval)
		return sprintf(buf, "1");
	else
		return sprintf(buf, "0");
}


static ssize_t set_button(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	return count;
}

static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);


static ssize_t show_port0(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	int retval;
	unsigned char *buffer;

	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	retval = vendor_command(cytherm->udev, READ_PORT, 0, 0, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);

	retval = buffer[1];

	kfree(buffer);

	return sprintf(buf, "%d", retval);
}


static ssize_t set_port0(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	unsigned char *buffer;
	int retval;
	int tmp;
   
	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	tmp = simple_strtoul(buf, NULL, 10);
   
	if (tmp > 0xFF)
		tmp = 0xFF;
	else if (tmp < 0)
		tmp = 0;
   
	retval = vendor_command(cytherm->udev, WRITE_PORT, 0,
				tmp, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);

	kfree(buffer);

	return count;
}

static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR | S_IWGRP, show_port0, set_port0);

static ssize_t show_port1(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	int retval;
	unsigned char *buffer;

	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	retval = vendor_command(cytherm->udev, READ_PORT, 1, 0, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);
   
	retval = buffer[1];

	kfree(buffer);

	return sprintf(buf, "%d", retval);
}


static ssize_t set_port1(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_cytherm *cytherm = usb_get_intfdata(intf);

	unsigned char *buffer;
	int retval;
	int tmp;
   
	buffer = kmalloc(8, GFP_KERNEL);
	if (!buffer) {
		dev_err(&cytherm->udev->dev, "out of memory\n");
		return 0;
	}

	tmp = simple_strtoul(buf, NULL, 10);
   
	if (tmp > 0xFF)
		tmp = 0xFF;
	else if (tmp < 0)
		tmp = 0;
   
	retval = vendor_command(cytherm->udev, WRITE_PORT, 1,
				tmp, buffer, 8);
	if (retval)
		dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval);

	kfree(buffer);

	return count;
}

static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR | S_IWGRP, show_port1, set_port1);


static int cytherm_probe(struct usb_interface *interface, 
			 const struct usb_device_id *id)
{
	struct usb_device *udev = interface_to_usbdev(interface);
	struct usb_cytherm *dev = NULL;
	int retval = -ENOMEM;

	dev = kzalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
	if (dev == NULL) {
		dev_err (&interface->dev, "Out of memory\n");
		goto error_mem;
	}

	dev->udev = usb_get_dev(udev);

	usb_set_intfdata (interface, dev);

	dev->brightness = 0xFF;

	retval = device_create_file(&interface->dev, &dev_attr_brightness);
	if (retval)
		goto error;
	retval = device_create_file(&interface->dev, &dev_attr_temp);
	if (retval)
		goto error;
	retval = device_create_file(&interface->dev, &dev_attr_button);
	if (retval)
		goto error;
	retval = device_create_file(&interface->dev, &dev_attr_port0);
	if (retval)
		goto error;
	retval = device_create_file(&interface->dev, &dev_attr_port1);
	if (retval)
		goto error;

	dev_info (&interface->dev,
		  "Cypress thermometer device now attached\n");
	return 0;
error:
	device_remove_file(&interface->dev, &dev_attr_brightness);
	device_remove_file(&interface->dev, &dev_attr_temp);
	device_remove_file(&interface->dev, &dev_attr_button);
	device_remove_file(&interface->dev, &dev_attr_port0);
	device_remove_file(&interface->dev, &dev_attr_port1);
	usb_set_intfdata (interface, NULL);
	usb_put_dev(dev->udev);
	kfree(dev);
error_mem:
	return retval;
}

static void cytherm_disconnect(struct usb_interface *interface)
{
	struct usb_cytherm *dev;

	dev = usb_get_intfdata (interface);

	device_remove_file(&interface->dev, &dev_attr_brightness);
	device_remove_file(&interface->dev, &dev_attr_temp);
	device_remove_file(&interface->dev, &dev_attr_button);
	device_remove_file(&interface->dev, &dev_attr_port0);
	device_remove_file(&interface->dev, &dev_attr_port1);

	/* first remove the files, then NULL the pointer */
	usb_set_intfdata (interface, NULL);

	usb_put_dev(dev->udev);

	kfree(dev);

	dev_info(&interface->dev, "Cypress thermometer now disconnected\n");
}


static int __init usb_cytherm_init(void)
{
	int result;

	result = usb_register(&cytherm_driver);
	if (result) {
		printk(KERN_ERR KBUILD_MODNAME ": usb_register failed! "
		       "Error number: %d\n", result);
		return result;
	}

	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
	       DRIVER_DESC "\n");
	return 0;
}

static void __exit usb_cytherm_exit(void)
{
	usb_deregister(&cytherm_driver);
}


module_init (usb_cytherm_init);
module_exit (usb_cytherm_exit);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	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
1da177e4 LT	17	#include <linux/kernel.h>
	18	#include <linux/errno.h>
	19	#include <linux/init.h>
5a0e3ad6	20	#include <linux/slab.h>
1da177e4 LT	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
33b9e162	31	static const struct usb_device_id id_table[] = {
1da177e4 LT	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 = {
1da177e4 LT	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
060b8845	87	static ssize_t show_brightness(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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
060b8845	95	static ssize_t set_brightness(struct device dev, struct device_attribute attr, const char *buf,
1da177e4 LT	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);
96de0e25	122	/* Inform µC that we have changed the brightness setting */
1da177e4 LT	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
060b8845	140	static ssize_t show_temp(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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
060b8845	176	static ssize_t set_temp(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	177	{
	178	return count;
	179	}
	180
	181	static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);
	182
	183
	184	#define BUTTON 0x7a
	185
060b8845	186	static ssize_t show_button(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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
060b8845	217	static ssize_t set_button(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	218	{
	219	return count;
	220	}
	221
	222	static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);
	223
	224
060b8845	225	static ssize_t show_port0(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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
060b8845	251	static ssize_t set_port0(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	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
060b8845	285	static ssize_t show_port1(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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
060b8845	311	static ssize_t set_port1(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	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
5f748133	354	dev = kzalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
1da177e4 LT	355	if (dev == NULL) {
1da177e4 LT	356	dev_err (&interface->dev, "Out of memory\n");
4d42e1bb	357	goto error_mem;
1da177e4	358	}
1da177e4 LT	359
	360	dev->udev = usb_get_dev(udev);
	361
	362	usb_set_intfdata (interface, dev);
	363
	364	dev->brightness = 0xFF;
	365
4d42e1bb GKH	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;
1da177e4	381
4d42e1bb	382	dev_info (&interface->dev,
1da177e4 LT	383	"Cypress thermometer device now attached\n");
1da177e4 LT	384	return 0;
4d42e1bb GKH	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);
1da177e4	393	kfree(dev);
4d42e1bb	394	error_mem:
1da177e4 LT	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);
1da177e4 LT	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
d718d2b1 ON	410	/* first remove the files, then NULL the pointer */
	411	usb_set_intfdata (interface, NULL);
	412
1da177e4 LT	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);
fd3f1917 GKH	426	if (result) {
	427	printk(KERN_ERR KBUILD_MODNAME ": usb_register failed! "
	428	"Error number: %d\n", result);
1da177e4 LT	429	return result;
	430	}
	431
1b29a375 GKH	432	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1b29a375 GKH	433	DRIVER_DESC "\n");
1da177e4 LT	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");