[deliverable/linux.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/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)
		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)
		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)
		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)
		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)
		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)
		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)
		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)
		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");
}

module_usb_driver(cytherm_driver);

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>
1da177e4 LT	18	#include <linux/errno.h>
5a0e3ad6	19	#include <linux/slab.h>
1da177e4 LT	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
33b9e162	30	static const struct usb_device_id id_table[] = {
1da177e4 LT	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 = {
1da177e4 LT	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
060b8845	86	static ssize_t show_brightness(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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
060b8845	94	static ssize_t set_brightness(struct device dev, struct device_attribute attr, const char *buf,
1da177e4 LT	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);
29a99df1	104	if (!buffer)
1da177e4	105	return 0;
1da177e4 LT	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);
96de0e25	119	/* Inform µC that we have changed the brightness setting */
1da177e4 LT	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
	130	static 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
060b8845	137	static ssize_t show_temp(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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);
29a99df1	149	if (!buffer)
1da177e4	150	return 0;
1da177e4 LT	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
060b8845	171	static ssize_t set_temp(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	172	{
	173	return count;
	174	}
	175
	176	static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp);
	177
	178
	179	#define BUTTON 0x7a
	180
060b8845	181	static ssize_t show_button(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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);
29a99df1	191	if (!buffer)
1da177e4	192	return 0;
1da177e4 LT	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
060b8845	210	static ssize_t set_button(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	211	{
	212	return count;
	213	}
	214
	215	static DEVICE_ATTR(button, S_IRUGO, show_button, set_button);
	216
	217
060b8845	218	static ssize_t show_port0(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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);
29a99df1	227	if (!buffer)
1da177e4	228	return 0;
1da177e4 LT	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
060b8845	242	static ssize_t set_port0(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	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);
29a99df1	252	if (!buffer)
1da177e4	253	return 0;
1da177e4 LT	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
	272	static DEVICE_ATTR(port0, S_IRUGO \| S_IWUSR \| S_IWGRP, show_port0, set_port0);
	273
060b8845	274	static ssize_t show_port1(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	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);
29a99df1	283	if (!buffer)
1da177e4	284	return 0;
1da177e4 LT	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
060b8845	298	static ssize_t set_port1(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	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);
29a99df1	308	if (!buffer)
1da177e4	309	return 0;
1da177e4 LT	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
	328	static DEVICE_ATTR(port1, S_IRUGO \| S_IWUSR \| S_IWGRP, show_port1, set_port1);
	329
	330
	331
	332	static 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
5f748133	339	dev = kzalloc (sizeof(struct usb_cytherm), GFP_KERNEL);
29a99df1	340	if (!dev)
4d42e1bb	341	goto error_mem;
1da177e4 LT	342
	343	dev->udev = usb_get_dev(udev);
	344
	345	usb_set_intfdata (interface, dev);
	346
	347	dev->brightness = 0xFF;
	348
4d42e1bb GKH	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;
1da177e4	364
4d42e1bb	365	dev_info (&interface->dev,
1da177e4 LT	366	"Cypress thermometer device now attached\n");
1da177e4 LT	367	return 0;
4d42e1bb GKH	368	error:
	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);
1da177e4	376	kfree(dev);
4d42e1bb	377	error_mem:
1da177e4 LT	378	return retval;
	379	}
	380
	381	static void cytherm_disconnect(struct usb_interface *interface)
	382	{
	383	struct usb_cytherm *dev;
	384
	385	dev = usb_get_intfdata (interface);
1da177e4 LT	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
d718d2b1 ON	393	/* first remove the files, then NULL the pointer */
	394	usb_set_intfdata (interface, NULL);
	395
1da177e4 LT	396	usb_put_dev(dev->udev);
	397
	398	kfree(dev);
	399
	400	dev_info(&interface->dev, "Cypress thermometer now disconnected\n");
	401	}
	402
65db4305	403	module_usb_driver(cytherm_driver);
1da177e4 LT	404
	405	MODULE_AUTHOR(DRIVER_AUTHOR);
	406	MODULE_DESCRIPTION(DRIVER_DESC);
	407	MODULE_LICENSE("GPL");