[deliverable/linux.git] / drivers / usb / misc / ezusb.c

/*
 * EZ-USB specific functions used by some of the USB to Serial drivers.
 *
 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/firmware.h>
#include <linux/ihex.h>
#include <linux/usb/ezusb.h>

struct ezusb_fx_type {
	/* EZ-USB Control and Status Register.  Bit 0 controls 8051 reset */
	unsigned short cpucs_reg;
	unsigned short max_internal_adress;
};

static struct ezusb_fx_type ezusb_fx1 = {
	.cpucs_reg = 0x7F92,
	.max_internal_adress = 0x1B3F,
};

/* Commands for writing to memory */
#define WRITE_INT_RAM 0xA0
#define WRITE_EXT_RAM 0xA3

static int ezusb_writememory(struct usb_device *dev, int address,
				unsigned char *data, int length, __u8 request)
{
	int result;
	unsigned char *transfer_buffer;

	if (!dev)
		return -ENODEV;

	transfer_buffer = kmemdup(data, length, GFP_KERNEL);
	if (!transfer_buffer) {
		dev_err(&dev->dev, "%s - kmalloc(%d) failed.\n",
							__func__, length);
		return -ENOMEM;
	}
	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
				 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
				 address, 0, transfer_buffer, length, 3000);

	kfree(transfer_buffer);
	return result;
}

static int ezusb_set_reset(struct usb_device *dev, unsigned short cpucs_reg,
			   unsigned char reset_bit)
{
	int response = ezusb_writememory(dev, cpucs_reg, &reset_bit, 1, WRITE_INT_RAM);
	if (response < 0)
		dev_err(&dev->dev, "%s-%d failed: %d\n",
						__func__, reset_bit, response);
	return response;
}

int ezusb_fx1_set_reset(struct usb_device *dev, unsigned char reset_bit)
{
	return ezusb_set_reset(dev, ezusb_fx1.cpucs_reg, reset_bit);
}
EXPORT_SYMBOL_GPL(ezusb_fx1_set_reset);

static int ezusb_ihex_firmware_download(struct usb_device *dev,
					struct ezusb_fx_type fx,
					const char *firmware_path)
{
	int ret = -ENOENT;
	const struct firmware *firmware = NULL;
	const struct ihex_binrec *record;

	if (request_ihex_firmware(&firmware, firmware_path,
				  &dev->dev)) {
		dev_err(&dev->dev,
			"%s - request \"%s\" failed\n",
			__func__, firmware_path);
		goto out;
	}

	ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
	if (ret < 0)
		goto out;

	record = (const struct ihex_binrec *)firmware->data;
	for (; record; record = ihex_next_binrec(record)) {
		if (be32_to_cpu(record->addr) > fx.max_internal_adress) {
			ret = ezusb_writememory(dev, be32_to_cpu(record->addr),
						(unsigned char *)record->data,
						be16_to_cpu(record->len), WRITE_EXT_RAM);
			if (ret < 0) {
				dev_err(&dev->dev, "%s - ezusb_writememory "
					"failed writing internal memory "
					"(%d %04X %p %d)\n", __func__, ret,
					be32_to_cpu(record->addr), record->data,
					be16_to_cpu(record->len));
				goto out;
			}
		}
	}

	ret = ezusb_set_reset(dev, fx.cpucs_reg, 1);
	if (ret < 0)
		goto out;
	record = (const struct ihex_binrec *)firmware->data;
	for (; record; record = ihex_next_binrec(record)) {
		if (be32_to_cpu(record->addr) <= fx.max_internal_adress) {
			ret = ezusb_writememory(dev, be32_to_cpu(record->addr),
						(unsigned char *)record->data,
						be16_to_cpu(record->len), WRITE_INT_RAM);
			if (ret < 0) {
				dev_err(&dev->dev, "%s - ezusb_writememory "
					"failed writing external memory "
					"(%d %04X %p %d)\n", __func__, ret,
					be32_to_cpu(record->addr), record->data,
					be16_to_cpu(record->len));
				goto out;
			}
		}
	}
	ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
out:
	release_firmware(firmware);
	return ret;
}

int ezusb_fx1_ihex_firmware_download(struct usb_device *dev,
				     const char *firmware_path)
{
	return ezusb_ihex_firmware_download(dev, ezusb_fx1, firmware_path);
}
EXPORT_SYMBOL_GPL(ezusb_fx1_ihex_firmware_download);

#if 0
/*
 * Once someone one needs these fx2 functions, uncomment them
 * and add them to ezusb.h and all should be good.
 */
static struct ezusb_fx_type ezusb_fx2 = {
	.cpucs_reg = 0xE600,
	.max_internal_adress = 0x3FFF,
};

int ezusb_fx2_set_reset(struct usb_device *dev, unsigned char reset_bit)
{
	return ezusb_set_reset(dev, ezusb_fx2.cpucs_reg, reset_bit);
}
EXPORT_SYMBOL_GPL(ezusb_fx2_set_reset);

int ezusb_fx2_ihex_firmware_download(struct usb_device *dev,
				     const char *firmware_path)
{
	return ezusb_ihex_firmware_download(dev, ezusb_fx2, firmware_path);
}
EXPORT_SYMBOL_GPL(ezusb_fx2_ihex_firmware_download);
#endif

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* EZ-USB specific functions used by some of the USB to Serial drivers.
	3	*
	4	* Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License version
	8	* 2 as published by the Free Software Foundation.
	9	*/
	10
1da177e4	11	#include <linux/kernel.h>
1da177e4 LT	12	#include <linux/init.h>
1da177e4 LT	13	#include <linux/slab.h>
1da177e4 LT	14	#include <linux/module.h>
1da177e4 LT	15	#include <linux/usb.h>
8d733e26 RB	16	#include <linux/firmware.h>
8d733e26 RB	17	#include <linux/ihex.h>
c30186e5	18	#include <linux/usb/ezusb.h>
1da177e4	19
cc183e2a RB	20	struct ezusb_fx_type {
	21	/* EZ-USB Control and Status Register. Bit 0 controls 8051 reset */
	22	unsigned short cpucs_reg;
	23	unsigned short max_internal_adress;
	24	};
1da177e4	25
c30186e5	26	static struct ezusb_fx_type ezusb_fx1 = {
cc183e2a RB	27	.cpucs_reg = 0x7F92,
	28	.max_internal_adress = 0x1B3F,
	29	};
	30
cc183e2a	31	/* Commands for writing to memory */
99495c70	32	#define WRITE_INT_RAM 0xA0
cc183e2a	33	#define WRITE_EXT_RAM 0xA3
99495c70	34
c30186e5	35	static int ezusb_writememory(struct usb_device *dev, int address,
80359a9c	36	unsigned char *data, int length, __u8 request)
1da177e4 LT	37	{
	38	int result;
	39	unsigned char *transfer_buffer;
	40
c6ab0158	41	if (!dev)
1da177e4	42	return -ENODEV;
1da177e4	43
5d7efe5b	44	transfer_buffer = kmemdup(data, length, GFP_KERNEL);
1da177e4	45	if (!transfer_buffer) {
99495c70	46	dev_err(&dev->dev, "%s - kmalloc(%d) failed.\n",
80359a9c	47	__func__, length);
1da177e4 LT	48	return -ENOMEM;
1da177e4 LT	49	}
99495c70 RB	50	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
	51	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	52	address, 0, transfer_buffer, length, 3000);
	53
80359a9c	54	kfree(transfer_buffer);
1da177e4 LT	55	return result;
	56	}
	57
c30186e5 GKH	58	static int ezusb_set_reset(struct usb_device *dev, unsigned short cpucs_reg,
c30186e5 GKH	59	unsigned char reset_bit)
1da177e4	60	{
cc183e2a	61	int response = ezusb_writememory(dev, cpucs_reg, &reset_bit, 1, WRITE_INT_RAM);
1da177e4	62	if (response < 0)
99495c70 RB	63	dev_err(&dev->dev, "%s-%d failed: %d\n",
99495c70 RB	64	__func__, reset_bit, response);
1da177e4 LT	65	return response;
1da177e4 LT	66	}
1da177e4	67
cc183e2a RB	68	int ezusb_fx1_set_reset(struct usb_device *dev, unsigned char reset_bit)
	69	{
	70	return ezusb_set_reset(dev, ezusb_fx1.cpucs_reg, reset_bit);
	71	}
	72	EXPORT_SYMBOL_GPL(ezusb_fx1_set_reset);
	73
8d733e26 RB	74	static int ezusb_ihex_firmware_download(struct usb_device *dev,
	75	struct ezusb_fx_type fx,
	76	const char *firmware_path)
	77	{
	78	int ret = -ENOENT;
	79	const struct firmware *firmware = NULL;
	80	const struct ihex_binrec *record;
	81
	82	if (request_ihex_firmware(&firmware, firmware_path,
	83	&dev->dev)) {
	84	dev_err(&dev->dev,
	85	"%s - request \"%s\" failed\n",
	86	__func__, firmware_path);
	87	goto out;
	88	}
	89
	90	ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
	91	if (ret < 0)
	92	goto out;
	93
	94	record = (const struct ihex_binrec *)firmware->data;
	95	for (; record; record = ihex_next_binrec(record)) {
	96	if (be32_to_cpu(record->addr) > fx.max_internal_adress) {
	97	ret = ezusb_writememory(dev, be32_to_cpu(record->addr),
	98	(unsigned char *)record->data,
	99	be16_to_cpu(record->len), WRITE_EXT_RAM);
	100	if (ret < 0) {
	101	dev_err(&dev->dev, "%s - ezusb_writememory "
	102	"failed writing internal memory "
	103	"(%d %04X %p %d)\n", __func__, ret,
	104	be32_to_cpu(record->addr), record->data,
	105	be16_to_cpu(record->len));
	106	goto out;
	107	}
	108	}
	109	}
	110
	111	ret = ezusb_set_reset(dev, fx.cpucs_reg, 1);
	112	if (ret < 0)
	113	goto out;
	114	record = (const struct ihex_binrec *)firmware->data;
	115	for (; record; record = ihex_next_binrec(record)) {
	116	if (be32_to_cpu(record->addr) <= fx.max_internal_adress) {
	117	ret = ezusb_writememory(dev, be32_to_cpu(record->addr),
	118	(unsigned char *)record->data,
	119	be16_to_cpu(record->len), WRITE_INT_RAM);
	120	if (ret < 0) {
	121	dev_err(&dev->dev, "%s - ezusb_writememory "
	122	"failed writing external memory "
	123	"(%d %04X %p %d)\n", __func__, ret,
	124	be32_to_cpu(record->addr), record->data,
	125	be16_to_cpu(record->len));
	126	goto out;
	127	}
	128	}
	129	}
	130	ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
	131	out:
	132	release_firmware(firmware);
	133	return ret;
	134	}
	135
	136	int ezusb_fx1_ihex_firmware_download(struct usb_device *dev,
	137	const char *firmware_path)
138	{
139	return ezusb_ihex_firmware_download(dev, ezusb_fx1, firmware_path);
140	}
141	EXPORT_SYMBOL_GPL(ezusb_fx1_ihex_firmware_download);
142
c30186e5 GKH	143	#if 0
	144	/*
	145	* Once someone one needs these fx2 functions, uncomment them
	146	* and add them to ezusb.h and all should be good.
	147	*/
	148	static struct ezusb_fx_type ezusb_fx2 = {
	149	.cpucs_reg = 0xE600,
	150	.max_internal_adress = 0x3FFF,
	151	};
	152
	153	int ezusb_fx2_set_reset(struct usb_device *dev, unsigned char reset_bit)
	154	{
	155	return ezusb_set_reset(dev, ezusb_fx2.cpucs_reg, reset_bit);
	156	}
	157	EXPORT_SYMBOL_GPL(ezusb_fx2_set_reset);
	158
8d733e26 RB	159	int ezusb_fx2_ihex_firmware_download(struct usb_device *dev,
	160	const char *firmware_path)
	161	{
	162	return ezusb_ihex_firmware_download(dev, ezusb_fx2, firmware_path);
	163	}
	164	EXPORT_SYMBOL_GPL(ezusb_fx2_ihex_firmware_download);
c30186e5	165	#endif
8d733e26	166
197ef5ef	167	MODULE_LICENSE("GPL");