[linux.git] / drivers / mtd / nand / alauda.c

/*
 * MTD driver for Alauda chips
 *
 * Copyright (C) 2007 Joern Engel <[email protected]>
 *
 * Based on drivers/usb/usb-skeleton.c which is:
 * Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])
 * and on drivers/usb/storage/alauda.c, which is:
 *   (c) 2005 Daniel Drake <[email protected]>
 *
 * Idea and initial work by Arnd Bergmann <[email protected]>
 */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/usb.h>
#include <linux/mutex.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand_ecc.h>

/* Control commands */
#define ALAUDA_GET_XD_MEDIA_STATUS	0x08
#define ALAUDA_ACK_XD_MEDIA_CHANGE	0x0a
#define ALAUDA_GET_XD_MEDIA_SIG		0x86

/* Common prefix */
#define ALAUDA_BULK_CMD			0x40

/* The two ports */
#define ALAUDA_PORT_XD			0x00
#define ALAUDA_PORT_SM			0x01

/* Bulk commands */
#define ALAUDA_BULK_READ_PAGE		0x84
#define ALAUDA_BULK_READ_OOB		0x85 /* don't use, there's a chip bug */
#define ALAUDA_BULK_READ_BLOCK		0x94
#define ALAUDA_BULK_ERASE_BLOCK		0xa3
#define ALAUDA_BULK_WRITE_PAGE		0xa4
#define ALAUDA_BULK_WRITE_BLOCK		0xb4
#define ALAUDA_BULK_RESET_MEDIA		0xe0

/* Address shifting */
#define PBA_LO(pba) ((pba & 0xF) << 5)
#define PBA_HI(pba) (pba >> 3)
#define PBA_ZONE(pba) (pba >> 11)

#define TIMEOUT HZ

static const struct usb_device_id alauda_table[] = {
	{ USB_DEVICE(0x0584, 0x0008) },	/* Fujifilm DPC-R1 */
	{ USB_DEVICE(0x07b4, 0x010a) },	/* Olympus MAUSB-10 */
	{ }
};
MODULE_DEVICE_TABLE(usb, alauda_table);

struct alauda_card {
	u8	id;		/* id byte */
	u8	chipshift;	/* 1<<chipshift total size */
	u8	pageshift;	/* 1<<pageshift page size */
	u8	blockshift;	/* 1<<blockshift block size */
};

struct alauda {
	struct usb_device	*dev;
	struct usb_interface	*interface;
	struct mtd_info		*mtd;
	struct alauda_card	*card;
	struct mutex		card_mutex;
	u32			pagemask;
	u32			bytemask;
	u32			blockmask;
	unsigned int		write_out;
	unsigned int		bulk_in;
	unsigned int		bulk_out;
	u8			port;
	struct kref		kref;
};

static struct alauda_card alauda_card_ids[] = {
	/* NAND flash */
	{ 0x6e, 20, 8, 12},	/* 1 MB */
	{ 0xe8, 20, 8, 12},	/* 1 MB */
	{ 0xec, 20, 8, 12},	/* 1 MB */
	{ 0x64, 21, 8, 12},	/* 2 MB */
	{ 0xea, 21, 8, 12},	/* 2 MB */
	{ 0x6b, 22, 9, 13},	/* 4 MB */
	{ 0xe3, 22, 9, 13},	/* 4 MB */
	{ 0xe5, 22, 9, 13},	/* 4 MB */
	{ 0xe6, 23, 9, 13},	/* 8 MB */
	{ 0x73, 24, 9, 14},	/* 16 MB */
	{ 0x75, 25, 9, 14},	/* 32 MB */
	{ 0x76, 26, 9, 14},	/* 64 MB */
	{ 0x79, 27, 9, 14},	/* 128 MB */
	{ 0x71, 28, 9, 14},	/* 256 MB */

	/* MASK ROM */
	{ 0x5d, 21, 9, 13},	/* 2 MB */
	{ 0xd5, 22, 9, 13},	/* 4 MB */
	{ 0xd6, 23, 9, 13},	/* 8 MB */
	{ 0x57, 24, 9, 13},	/* 16 MB */
	{ 0x58, 25, 9, 13},	/* 32 MB */
	{ }
};

static struct alauda_card *get_card(u8 id)
{
	struct alauda_card *card;

	for (card = alauda_card_ids; card->id; card++)
		if (card->id == id)
			return card;
	return NULL;
}

static void alauda_delete(struct kref *kref)
{
	struct alauda *al = container_of(kref, struct alauda, kref);

	if (al->mtd) {
		mtd_device_unregister(al->mtd);
		kfree(al->mtd);
	}
	usb_put_dev(al->dev);
	kfree(al);
}

static int alauda_get_media_status(struct alauda *al, void *buf)
{
	int ret;

	mutex_lock(&al->card_mutex);
	ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
			ALAUDA_GET_XD_MEDIA_STATUS, 0xc0, 0, 1, buf, 2, HZ);
	mutex_unlock(&al->card_mutex);
	return ret;
}

static int alauda_ack_media(struct alauda *al)
{
	int ret;

	mutex_lock(&al->card_mutex);
	ret = usb_control_msg(al->dev, usb_sndctrlpipe(al->dev, 0),
			ALAUDA_ACK_XD_MEDIA_CHANGE, 0x40, 0, 1, NULL, 0, HZ);
	mutex_unlock(&al->card_mutex);
	return ret;
}

static int alauda_get_media_signatures(struct alauda *al, void *buf)
{
	int ret;

	mutex_lock(&al->card_mutex);
	ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
			ALAUDA_GET_XD_MEDIA_SIG, 0xc0, 0, 0, buf, 4, HZ);
	mutex_unlock(&al->card_mutex);
	return ret;
}

static void alauda_reset(struct alauda *al)
{
	u8 command[] = {
		ALAUDA_BULK_CMD, ALAUDA_BULK_RESET_MEDIA, 0, 0,
		0, 0, 0, 0, al->port
	};
	mutex_lock(&al->card_mutex);
	usb_bulk_msg(al->dev, al->bulk_out, command, 9, NULL, HZ);
	mutex_unlock(&al->card_mutex);
}

static void correct_data(void *buf, void *read_ecc,
		int *corrected, int *uncorrected)
{
	u8 calc_ecc[3];
	int err;

	nand_calculate_ecc(NULL, buf, calc_ecc);
	err = nand_correct_data(NULL, buf, read_ecc, calc_ecc);
	if (err) {
		if (err > 0)
			(*corrected)++;
		else
			(*uncorrected)++;
	}
}

struct alauda_sg_request {
	struct urb *urb[3];
	struct completion comp;
};

static void alauda_complete(struct urb *urb)
{
	struct completion *comp = urb->context;

	if (comp)
		complete(comp);
}

static int __alauda_read_page(struct mtd_info *mtd, loff_t from, void *buf,
		void *oob)
{
	struct alauda_sg_request sg;
	struct alauda *al = mtd->priv;
	u32 pba = from >> al->card->blockshift;
	u32 page = (from >> al->card->pageshift) & al->pagemask;
	u8 command[] = {
		ALAUDA_BULK_CMD, ALAUDA_BULK_READ_PAGE, PBA_HI(pba),
		PBA_ZONE(pba), 0, PBA_LO(pba) + page, 1, 0, al->port
	};
	int i, err;

	for (i=0; i<3; i++)
		sg.urb[i] = NULL;

	err = -ENOMEM;
	for (i=0; i<3; i++) {
		sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
		if (!sg.urb[i])
			goto out;
	}
	init_completion(&sg.comp);
	usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
			alauda_complete, NULL);
	usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, mtd->writesize,
			alauda_complete, NULL);
	usb_fill_bulk_urb(sg.urb[2], al->dev, al->bulk_in, oob, 16,
			alauda_complete, &sg.comp);

	mutex_lock(&al->card_mutex);
	for (i=0; i<3; i++) {
		err = usb_submit_urb(sg.urb[i], GFP_NOIO);
		if (err)
			goto cancel;
	}
	if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
		err = -ETIMEDOUT;
cancel:
		for (i=0; i<3; i++) {
			usb_kill_urb(sg.urb[i]);
		}
	}
	mutex_unlock(&al->card_mutex);

out:
	usb_free_urb(sg.urb[0]);
	usb_free_urb(sg.urb[1]);
	usb_free_urb(sg.urb[2]);
	return err;
}

static int alauda_read_page(struct mtd_info *mtd, loff_t from,
		void *buf, u8 *oob, int *corrected, int *uncorrected)
{
	int err;

	err = __alauda_read_page(mtd, from, buf, oob);
	if (err)
		return err;
	correct_data(buf, oob+13, corrected, uncorrected);
	correct_data(buf+256, oob+8, corrected, uncorrected);
	return 0;
}

static int alauda_write_page(struct mtd_info *mtd, loff_t to, void *buf,
		void *oob)
{
	struct alauda_sg_request sg;
	struct alauda *al = mtd->priv;
	u32 pba = to >> al->card->blockshift;
	u32 page = (to >> al->card->pageshift) & al->pagemask;
	u8 command[] = {
		ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_PAGE, PBA_HI(pba),
		PBA_ZONE(pba), 0, PBA_LO(pba) + page, 32, 0, al->port
	};
	int i, err;

	for (i=0; i<3; i++)
		sg.urb[i] = NULL;

	err = -ENOMEM;
	for (i=0; i<3; i++) {
		sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
		if (!sg.urb[i])
			goto out;
	}
	init_completion(&sg.comp);
	usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
			alauda_complete, NULL);
	usb_fill_bulk_urb(sg.urb[1], al->dev, al->write_out, buf,mtd->writesize,
			alauda_complete, NULL);
	usb_fill_bulk_urb(sg.urb[2], al->dev, al->write_out, oob, 16,
			alauda_complete, &sg.comp);

	mutex_lock(&al->card_mutex);
	for (i=0; i<3; i++) {
		err = usb_submit_urb(sg.urb[i], GFP_NOIO);
		if (err)
			goto cancel;
	}
	if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
		err = -ETIMEDOUT;
cancel:
		for (i=0; i<3; i++) {
			usb_kill_urb(sg.urb[i]);
		}
	}
	mutex_unlock(&al->card_mutex);

out:
	usb_free_urb(sg.urb[0]);
	usb_free_urb(sg.urb[1]);
	usb_free_urb(sg.urb[2]);
	return err;
}

static int alauda_erase_block(struct mtd_info *mtd, loff_t ofs)
{
	struct alauda_sg_request sg;
	struct alauda *al = mtd->priv;
	u32 pba = ofs >> al->card->blockshift;
	u8 command[] = {
		ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba),
		PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, al->port
	};
	u8 buf[2];
	int i, err;

	for (i=0; i<2; i++)
		sg.urb[i] = NULL;

	err = -ENOMEM;
	for (i=0; i<2; i++) {
		sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
		if (!sg.urb[i])
			goto out;
	}
	init_completion(&sg.comp);
	usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
			alauda_complete, NULL);
	usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, 2,
			alauda_complete, &sg.comp);

	mutex_lock(&al->card_mutex);
	for (i=0; i<2; i++) {
		err = usb_submit_urb(sg.urb[i], GFP_NOIO);
		if (err)
			goto cancel;
	}
	if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
		err = -ETIMEDOUT;
cancel:
		for (i=0; i<2; i++) {
			usb_kill_urb(sg.urb[i]);
		}
	}
	mutex_unlock(&al->card_mutex);

out:
	usb_free_urb(sg.urb[0]);
	usb_free_urb(sg.urb[1]);
	return err;
}

static int alauda_read_oob(struct mtd_info *mtd, loff_t from, void *oob)
{
	static u8 ignore_buf[512]; /* write only */

	return __alauda_read_page(mtd, from, ignore_buf, oob);
}

static int alauda_isbad(struct mtd_info *mtd, loff_t ofs)
{
	u8 oob[16];
	int err;

	err = alauda_read_oob(mtd, ofs, oob);
	if (err)
		return err;

	/* A block is marked bad if two or more bits are zero */
	return hweight8(oob[5]) >= 7 ? 0 : 1;
}

static int alauda_bounce_read(struct mtd_info *mtd, loff_t from, size_t len,
		size_t *retlen, u_char *buf)
{
	struct alauda *al = mtd->priv;
	void *bounce_buf;
	int err, corrected=0, uncorrected=0;

	bounce_buf = kmalloc(mtd->writesize, GFP_KERNEL);
	if (!bounce_buf)
		return -ENOMEM;

	*retlen = len;
	while (len) {
		u8 oob[16];
		size_t byte = from & al->bytemask;
		size_t cplen = min(len, mtd->writesize - byte);

		err = alauda_read_page(mtd, from, bounce_buf, oob,
				&corrected, &uncorrected);
		if (err)
			goto out;

		memcpy(buf, bounce_buf + byte, cplen);
		buf += cplen;
		from += cplen;
		len -= cplen;
	}
	err = 0;
	if (corrected)
		err = 1;	/* return max_bitflips per ecc step */
	if (uncorrected)
		err = -EBADMSG;
out:
	kfree(bounce_buf);
	return err;
}

static int alauda_read(struct mtd_info *mtd, loff_t from, size_t len,
		size_t *retlen, u_char *buf)
{
	struct alauda *al = mtd->priv;
	int err, corrected=0, uncorrected=0;

	if ((from & al->bytemask) || (len & al->bytemask))
		return alauda_bounce_read(mtd, from, len, retlen, buf);

	*retlen = len;
	while (len) {
		u8 oob[16];

		err = alauda_read_page(mtd, from, buf, oob,
				&corrected, &uncorrected);
		if (err)
			return err;

		buf += mtd->writesize;
		from += mtd->writesize;
		len -= mtd->writesize;
	}
	err = 0;
	if (corrected)
		err = 1;	/* return max_bitflips per ecc step */
	if (uncorrected)
		err = -EBADMSG;
	return err;
}

static int alauda_write(struct mtd_info *mtd, loff_t to, size_t len,
		size_t *retlen, const u_char *buf)
{
	struct alauda *al = mtd->priv;
	int err;

	if ((to & al->bytemask) || (len & al->bytemask))
		return -EINVAL;

	*retlen = len;
	while (len) {
		u32 page = (to >> al->card->pageshift) & al->pagemask;
		u8 oob[16] = {	'h', 'e', 'l', 'l', 'o', 0xff, 0xff, 0xff,
				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

		/* don't write to bad blocks */
		if (page == 0) {
			err = alauda_isbad(mtd, to);
			if (err) {
				return -EIO;
			}
		}
		nand_calculate_ecc(mtd, buf, &oob[13]);
		nand_calculate_ecc(mtd, buf+256, &oob[8]);

		err = alauda_write_page(mtd, to, (void*)buf, oob);
		if (err)
			return err;

		buf += mtd->writesize;
		to += mtd->writesize;
		len -= mtd->writesize;
	}
	return 0;
}

static int __alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
{
	struct alauda *al = mtd->priv;
	u32 ofs = instr->addr;
	u32 len = instr->len;
	int err;

	if ((ofs & al->blockmask) || (len & al->blockmask))
		return -EINVAL;

	while (len) {
		/* don't erase bad blocks */
		err = alauda_isbad(mtd, ofs);
		if (err > 0)
			err = -EIO;
		if (err < 0)
			return err;

		err = alauda_erase_block(mtd, ofs);
		if (err < 0)
			return err;

		ofs += mtd->erasesize;
		len -= mtd->erasesize;
	}
	return 0;
}

static int alauda_erase(struct mtd_info *mtd, struct erase_info *instr)
{
	int err;

	err = __alauda_erase(mtd, instr);
	instr->state = err ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
	mtd_erase_callback(instr);
	return err;
}

static int alauda_init_media(struct alauda *al)
{
	u8 buf[4], *b0=buf, *b1=buf+1;
	struct alauda_card *card;
	struct mtd_info *mtd;
	int err;

	mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
	if (!mtd)
		return -ENOMEM;

	for (;;) {
		err = alauda_get_media_status(al, buf);
		if (err < 0)
			goto error;
		if (*b0 & 0x10)
			break;
		msleep(20);
	}

	err = alauda_ack_media(al);
	if (err)
		goto error;

	msleep(10);

	err = alauda_get_media_status(al, buf);
	if (err < 0)
		goto error;

	if (*b0 != 0x14) {
		/* media not ready */
		err = -EIO;
		goto error;
	}
	err = alauda_get_media_signatures(al, buf);
	if (err < 0)
		goto error;

	card = get_card(*b1);
	if (!card) {
		printk(KERN_ERR"Alauda: unknown card id %02x\n", *b1);
		err = -EIO;
		goto error;
	}
	printk(KERN_INFO"pagesize=%x\nerasesize=%x\nsize=%xMiB\n",
			1<<card->pageshift, 1<<card->blockshift,
			1<<(card->chipshift-20));
	al->card = card;
	al->pagemask = (1 << (card->blockshift - card->pageshift)) - 1;
	al->bytemask = (1 << card->pageshift) - 1;
	al->blockmask = (1 << card->blockshift) - 1;

	mtd->name = "alauda";
	mtd->size = 1<<card->chipshift;
	mtd->erasesize = 1<<card->blockshift;
	mtd->writesize = 1<<card->pageshift;
	mtd->type = MTD_NANDFLASH;
	mtd->flags = MTD_CAP_NANDFLASH;
	mtd->_read = alauda_read;
	mtd->_write = alauda_write;
	mtd->_erase = alauda_erase;
	mtd->_block_isbad = alauda_isbad;
	mtd->priv = al;
	mtd->owner = THIS_MODULE;
	mtd->ecc_strength = 1;

	err = mtd_device_register(mtd, NULL, 0);
	if (err) {
		err = -ENFILE;
		goto error;
	}

	al->mtd = mtd;
	alauda_reset(al); /* no clue whether this is necessary */
	return 0;
error:
	kfree(mtd);
	return err;
}

static int alauda_check_media(struct alauda *al)
{
	u8 buf[2], *b0 = buf, *b1 = buf+1;
	int err;

	err = alauda_get_media_status(al, buf);
	if (err < 0)
		return err;

	if ((*b1 & 0x01) == 0) {
		/* door open */
		return -EIO;
	}
	if ((*b0 & 0x80) || ((*b0 & 0x1F) == 0x10)) {
		/* no media ? */
		return -EIO;
	}
	if (*b0 & 0x08) {
		/* media change ? */
		return alauda_init_media(al);
	}
	return 0;
}

static int alauda_probe(struct usb_interface *interface,
		const struct usb_device_id *id)
{
	struct alauda *al;
	struct usb_host_interface *iface;
	struct usb_endpoint_descriptor *ep,
			*ep_in=NULL, *ep_out=NULL, *ep_wr=NULL;
	int i, err = -ENOMEM;

	al = kzalloc(2*sizeof(*al), GFP_KERNEL);
	if (!al)
		goto error;

	kref_init(&al->kref);
	usb_set_intfdata(interface, al);

	al->dev = usb_get_dev(interface_to_usbdev(interface));
	al->interface = interface;

	iface = interface->cur_altsetting;
	for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
		ep = &iface->endpoint[i].desc;

		if (usb_endpoint_is_bulk_in(ep)) {
			ep_in = ep;
		} else if (usb_endpoint_is_bulk_out(ep)) {
			if (i==0)
				ep_wr = ep;
			else
				ep_out = ep;
		}
	}
	err = -EIO;
	if (!ep_wr || !ep_in || !ep_out)
		goto error;

	al->write_out = usb_sndbulkpipe(al->dev,
			usb_endpoint_num(ep_wr));
	al->bulk_in = usb_rcvbulkpipe(al->dev,
			usb_endpoint_num(ep_in));
	al->bulk_out = usb_sndbulkpipe(al->dev,
			usb_endpoint_num(ep_out));

	/* second device is identical up to now */
	memcpy(al+1, al, sizeof(*al));

	mutex_init(&al[0].card_mutex);
	mutex_init(&al[1].card_mutex);

	al[0].port = ALAUDA_PORT_XD;
	al[1].port = ALAUDA_PORT_SM;

	dev_info(&interface->dev, "alauda probed\n");
	alauda_check_media(al);
	alauda_check_media(al+1);

	return 0;

error:
	if (al)
		kref_put(&al->kref, alauda_delete);
	return err;
}

static void alauda_disconnect(struct usb_interface *interface)
{
	struct alauda *al;

	al = usb_get_intfdata(interface);
	usb_set_intfdata(interface, NULL);

	/* FIXME: prevent more I/O from starting */

	/* decrement our usage count */
	if (al)
		kref_put(&al->kref, alauda_delete);

	dev_info(&interface->dev, "alauda gone");
}

static struct usb_driver alauda_driver = {
	.name =		"alauda",
	.probe =	alauda_probe,
	.disconnect =	alauda_disconnect,
	.id_table =	alauda_table,
};

module_usb_driver(alauda_driver);

MODULE_LICENSE("GPL");
Commit	Line	Data
e208520e JE	1	/*
	2	* MTD driver for Alauda chips
	3	*
	4	* Copyright (C) 2007 Joern Engel <[email protected]>
	5	*
	6	* Based on drivers/usb/usb-skeleton.c which is:
	7	* Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])
	8	* and on drivers/usb/storage/alauda.c, which is:
	9	* (c) 2005 Daniel Drake <[email protected]>
	10	*
	11	* Idea and initial work by Arnd Bergmann <[email protected]>
	12	*/
	13	#include <linux/kernel.h>
	14	#include <linux/errno.h>
	15	#include <linux/init.h>
	16	#include <linux/slab.h>
	17	#include <linux/module.h>
	18	#include <linux/kref.h>
	19	#include <linux/usb.h>
	20	#include <linux/mutex.h>
	21	#include <linux/mtd/mtd.h>
	22	#include <linux/mtd/nand_ecc.h>
	23
	24	/* Control commands */
	25	#define ALAUDA_GET_XD_MEDIA_STATUS 0x08
	26	#define ALAUDA_ACK_XD_MEDIA_CHANGE 0x0a
	27	#define ALAUDA_GET_XD_MEDIA_SIG 0x86
	28
	29	/* Common prefix */
	30	#define ALAUDA_BULK_CMD 0x40
	31
	32	/* The two ports */
	33	#define ALAUDA_PORT_XD 0x00
	34	#define ALAUDA_PORT_SM 0x01
	35
	36	/* Bulk commands */
	37	#define ALAUDA_BULK_READ_PAGE 0x84
	38	#define ALAUDA_BULK_READ_OOB 0x85 /* don't use, there's a chip bug */
	39	#define ALAUDA_BULK_READ_BLOCK 0x94
	40	#define ALAUDA_BULK_ERASE_BLOCK 0xa3
	41	#define ALAUDA_BULK_WRITE_PAGE 0xa4
	42	#define ALAUDA_BULK_WRITE_BLOCK 0xb4
	43	#define ALAUDA_BULK_RESET_MEDIA 0xe0
	44
	45	/* Address shifting */
	46	#define PBA_LO(pba) ((pba & 0xF) << 5)
	47	#define PBA_HI(pba) (pba >> 3)
	48	#define PBA_ZONE(pba) (pba >> 11)
	49
	50	#define TIMEOUT HZ
	51
b3acd638	52	static const struct usb_device_id alauda_table[] = {
e208520e JE	53	{ USB_DEVICE(0x0584, 0x0008) }, /* Fujifilm DPC-R1 */
	54	{ USB_DEVICE(0x07b4, 0x010a) }, /* Olympus MAUSB-10 */
	55	{ }
	56	};
	57	MODULE_DEVICE_TABLE(usb, alauda_table);
	58
	59	struct alauda_card {
	60	u8 id; /* id byte */
	61	u8 chipshift; /* 1<<chipshift total size */
	62	u8 pageshift; /* 1<<pageshift page size */
	63	u8 blockshift; /* 1<<blockshift block size */
	64	};
	65
	66	struct alauda {
	67	struct usb_device *dev;
	68	struct usb_interface *interface;
	69	struct mtd_info *mtd;
	70	struct alauda_card *card;
	71	struct mutex card_mutex;
	72	u32 pagemask;
	73	u32 bytemask;
	74	u32 blockmask;
	75	unsigned int write_out;
	76	unsigned int bulk_in;
	77	unsigned int bulk_out;
	78	u8 port;
	79	struct kref kref;
	80	};
	81
	82	static struct alauda_card alauda_card_ids[] = {
	83	/* NAND flash */
	84	{ 0x6e, 20, 8, 12}, /* 1 MB */
	85	{ 0xe8, 20, 8, 12}, /* 1 MB */
	86	{ 0xec, 20, 8, 12}, /* 1 MB */
	87	{ 0x64, 21, 8, 12}, /* 2 MB */
	88	{ 0xea, 21, 8, 12}, /* 2 MB */
	89	{ 0x6b, 22, 9, 13}, /* 4 MB */
	90	{ 0xe3, 22, 9, 13}, /* 4 MB */
	91	{ 0xe5, 22, 9, 13}, /* 4 MB */
	92	{ 0xe6, 23, 9, 13}, /* 8 MB */
	93	{ 0x73, 24, 9, 14}, /* 16 MB */
	94	{ 0x75, 25, 9, 14}, /* 32 MB */
	95	{ 0x76, 26, 9, 14}, /* 64 MB */
	96	{ 0x79, 27, 9, 14}, /* 128 MB */
	97	{ 0x71, 28, 9, 14}, /* 256 MB */
	98
	99	/* MASK ROM */
	100	{ 0x5d, 21, 9, 13}, /* 2 MB */
	101	{ 0xd5, 22, 9, 13}, /* 4 MB */
	102	{ 0xd6, 23, 9, 13}, /* 8 MB */
	103	{ 0x57, 24, 9, 13}, /* 16 MB */
	104	{ 0x58, 25, 9, 13}, /* 32 MB */
	105	{ }
	106	};
	107
	108	static struct alauda_card *get_card(u8 id)
	109	{
	110	struct alauda_card *card;
	111
	112	for (card = alauda_card_ids; card->id; card++)
	113	if (card->id == id)
	114	return card;
	115	return NULL;
	116	}
117
118	static void alauda_delete(struct kref *kref)
119	{
120	struct alauda *al = container_of(kref, struct alauda, kref);
121
122	if (al->mtd) {
ee0e87b1	123	mtd_device_unregister(al->mtd);
e208520e JE	124	kfree(al->mtd);
	125	}
	126	usb_put_dev(al->dev);
	127	kfree(al);
	128	}
	129
	130	static int alauda_get_media_status(struct alauda al, void buf)
	131	{
	132	int ret;
	133
	134	mutex_lock(&al->card_mutex);
	135	ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
	136	ALAUDA_GET_XD_MEDIA_STATUS, 0xc0, 0, 1, buf, 2, HZ);
	137	mutex_unlock(&al->card_mutex);
	138	return ret;
	139	}
	140
	141	static int alauda_ack_media(struct alauda *al)
	142	{
	143	int ret;
	144
	145	mutex_lock(&al->card_mutex);
	146	ret = usb_control_msg(al->dev, usb_sndctrlpipe(al->dev, 0),
	147	ALAUDA_ACK_XD_MEDIA_CHANGE, 0x40, 0, 1, NULL, 0, HZ);
	148	mutex_unlock(&al->card_mutex);
	149	return ret;
	150	}
	151
	152	static int alauda_get_media_signatures(struct alauda al, void buf)
	153	{
	154	int ret;
	155
	156	mutex_lock(&al->card_mutex);
	157	ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0),
	158	ALAUDA_GET_XD_MEDIA_SIG, 0xc0, 0, 0, buf, 4, HZ);
	159	mutex_unlock(&al->card_mutex);
	160	return ret;
	161	}
	162
	163	static void alauda_reset(struct alauda *al)
	164	{
	165	u8 command[] = {
	166	ALAUDA_BULK_CMD, ALAUDA_BULK_RESET_MEDIA, 0, 0,
	167	0, 0, 0, 0, al->port
	168	};
	169	mutex_lock(&al->card_mutex);
	170	usb_bulk_msg(al->dev, al->bulk_out, command, 9, NULL, HZ);
	171	mutex_unlock(&al->card_mutex);
	172	}
	173
	174	static void correct_data(void buf, void read_ecc,
	175	int corrected, int uncorrected)
	176	{
	177	u8 calc_ecc[3];
	178	int err;
	179
	180	nand_calculate_ecc(NULL, buf, calc_ecc);
	181	err = nand_correct_data(NULL, buf, read_ecc, calc_ecc);
	182	if (err) {
	183	if (err > 0)
	184	(*corrected)++;
	185	else
	186	(*uncorrected)++;
	187	}
188	}
189
190	struct alauda_sg_request {
191	struct urb *urb[3];
192	struct completion comp;
193	};
194
195	static void alauda_complete(struct urb *urb)
196	{
197	struct completion *comp = urb->context;
198
199	if (comp)
200	complete(comp);
201	}
202
203	static int __alauda_read_page(struct mtd_info mtd, loff_t from, void buf,
204	void *oob)
205	{
206	struct alauda_sg_request sg;
207	struct alauda *al = mtd->priv;
208	u32 pba = from >> al->card->blockshift;
209	u32 page = (from >> al->card->pageshift) & al->pagemask;
210	u8 command[] = {
211	ALAUDA_BULK_CMD, ALAUDA_BULK_READ_PAGE, PBA_HI(pba),
212	PBA_ZONE(pba), 0, PBA_LO(pba) + page, 1, 0, al->port
213	};
214	int i, err;
215
216	for (i=0; i<3; i++)
217	sg.urb[i] = NULL;
218
219	err = -ENOMEM;
220	for (i=0; i<3; i++) {
221	sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
222	if (!sg.urb[i])
223	goto out;
224	}
225	init_completion(&sg.comp);
226	usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
227	alauda_complete, NULL);
228	usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, mtd->writesize,
229	alauda_complete, NULL);
230	usb_fill_bulk_urb(sg.urb[2], al->dev, al->bulk_in, oob, 16,
231	alauda_complete, &sg.comp);
232
233	mutex_lock(&al->card_mutex);
234	for (i=0; i<3; i++) {
235	err = usb_submit_urb(sg.urb[i], GFP_NOIO);
236	if (err)
237	goto cancel;
238	}
239	if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
240	err = -ETIMEDOUT;
241	cancel:
242	for (i=0; i<3; i++) {
243	usb_kill_urb(sg.urb[i]);
244	}
245	}
246	mutex_unlock(&al->card_mutex);
247
248	out:
249	usb_free_urb(sg.urb[0]);
250	usb_free_urb(sg.urb[1]);
251	usb_free_urb(sg.urb[2]);
252	return err;
253	}
254
255	static int alauda_read_page(struct mtd_info *mtd, loff_t from,
256	void buf, u8 oob, int corrected, int uncorrected)
257	{
258	int err;
259
260	err = __alauda_read_page(mtd, from, buf, oob);
261	if (err)
262	return err;
263	correct_data(buf, oob+13, corrected, uncorrected);
264	correct_data(buf+256, oob+8, corrected, uncorrected);
265	return 0;
266	}
267
268	static int alauda_write_page(struct mtd_info mtd, loff_t to, void buf,
269	void *oob)
270	{
271	struct alauda_sg_request sg;
272	struct alauda *al = mtd->priv;
273	u32 pba = to >> al->card->blockshift;
274	u32 page = (to >> al->card->pageshift) & al->pagemask;
275	u8 command[] = {
276	ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_PAGE, PBA_HI(pba),
277	PBA_ZONE(pba), 0, PBA_LO(pba) + page, 32, 0, al->port
278	};
279	int i, err;
280
281	for (i=0; i<3; i++)
282	sg.urb[i] = NULL;
283
284	err = -ENOMEM;
285	for (i=0; i<3; i++) {
286	sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
287	if (!sg.urb[i])
288	goto out;
289	}
290	init_completion(&sg.comp);
291	usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
292	alauda_complete, NULL);
293	usb_fill_bulk_urb(sg.urb[1], al->dev, al->write_out, buf,mtd->writesize,
294	alauda_complete, NULL);
295	usb_fill_bulk_urb(sg.urb[2], al->dev, al->write_out, oob, 16,
296	alauda_complete, &sg.comp);
297
298	mutex_lock(&al->card_mutex);
299	for (i=0; i<3; i++) {
300	err = usb_submit_urb(sg.urb[i], GFP_NOIO);
301	if (err)
302	goto cancel;
303	}
304	if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
305	err = -ETIMEDOUT;
306	cancel:
307	for (i=0; i<3; i++) {
308	usb_kill_urb(sg.urb[i]);
309	}
310	}
311	mutex_unlock(&al->card_mutex);
312
313	out:
314	usb_free_urb(sg.urb[0]);
315	usb_free_urb(sg.urb[1]);
316	usb_free_urb(sg.urb[2]);
317	return err;
318	}
319
320	static int alauda_erase_block(struct mtd_info *mtd, loff_t ofs)
321	{
322	struct alauda_sg_request sg;
323	struct alauda *al = mtd->priv;
324	u32 pba = ofs >> al->card->blockshift;
325	u8 command[] = {
326	ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba),
327	PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, al->port
328	};
329	u8 buf[2];
330	int i, err;
331
332	for (i=0; i<2; i++)
333	sg.urb[i] = NULL;
334
335	err = -ENOMEM;
336	for (i=0; i<2; i++) {
337	sg.urb[i] = usb_alloc_urb(0, GFP_NOIO);
338	if (!sg.urb[i])
339	goto out;
340	}
341	init_completion(&sg.comp);
342	usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9,
343	alauda_complete, NULL);
344	usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, 2,
345	alauda_complete, &sg.comp);
346
347	mutex_lock(&al->card_mutex);
348	for (i=0; i<2; i++) {
349	err = usb_submit_urb(sg.urb[i], GFP_NOIO);
350	if (err)
351	goto cancel;
352	}
353	if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) {
354	err = -ETIMEDOUT;
355	cancel:
356	for (i=0; i<2; i++) {
357	usb_kill_urb(sg.urb[i]);
358	}
359	}
360	mutex_unlock(&al->card_mutex);
361
362	out:
363	usb_free_urb(sg.urb[0]);
364	usb_free_urb(sg.urb[1]);
365	return err;
366	}
367
368	static int alauda_read_oob(struct mtd_info mtd, loff_t from, void oob)
369	{
370	static u8 ignore_buf[512]; /* write only */
371
372	return __alauda_read_page(mtd, from, ignore_buf, oob);
373	}
374
e208520e JE	375	static int alauda_isbad(struct mtd_info *mtd, loff_t ofs)
	376	{
	377	u8 oob[16];
	378	int err;
	379
	380	err = alauda_read_oob(mtd, ofs, oob);
	381	if (err)
	382	return err;
	383
	384	/* A block is marked bad if two or more bits are zero */
54c69cc2	385	return hweight8(oob[5]) >= 7 ? 0 : 1;
e208520e JE	386	}
	387
	388	static int alauda_bounce_read(struct mtd_info *mtd, loff_t from, size_t len,
	389	size_t retlen, u_char buf)
	390	{
	391	struct alauda *al = mtd->priv;
	392	void *bounce_buf;
	393	int err, corrected=0, uncorrected=0;
	394
	395	bounce_buf = kmalloc(mtd->writesize, GFP_KERNEL);
	396	if (!bounce_buf)
	397	return -ENOMEM;
	398
	399	*retlen = len;
	400	while (len) {
	401	u8 oob[16];
f96880d1	402	size_t byte = from & al->bytemask;
e208520e JE	403	size_t cplen = min(len, mtd->writesize - byte);
	404
	405	err = alauda_read_page(mtd, from, bounce_buf, oob,
	406	&corrected, &uncorrected);
	407	if (err)
	408	goto out;
	409
	410	memcpy(buf, bounce_buf + byte, cplen);
	411	buf += cplen;
	412	from += cplen;
	413	len -= cplen;
	414	}
	415	err = 0;
	416	if (corrected)
edbc4540	417	err = 1; /* return max_bitflips per ecc step */
e208520e JE	418	if (uncorrected)
	419	err = -EBADMSG;
	420	out:
	421	kfree(bounce_buf);
	422	return err;
	423	}
	424
	425	static int alauda_read(struct mtd_info *mtd, loff_t from, size_t len,
	426	size_t retlen, u_char buf)
	427	{
	428	struct alauda *al = mtd->priv;
	429	int err, corrected=0, uncorrected=0;
	430
	431	if ((from & al->bytemask) \|\| (len & al->bytemask))
	432	return alauda_bounce_read(mtd, from, len, retlen, buf);
	433
	434	*retlen = len;
	435	while (len) {
	436	u8 oob[16];
	437
	438	err = alauda_read_page(mtd, from, buf, oob,
	439	&corrected, &uncorrected);
	440	if (err)
	441	return err;
	442
	443	buf += mtd->writesize;
	444	from += mtd->writesize;
	445	len -= mtd->writesize;
	446	}
	447	err = 0;
	448	if (corrected)
edbc4540	449	err = 1; /* return max_bitflips per ecc step */
e208520e JE	450	if (uncorrected)
	451	err = -EBADMSG;
	452	return err;
	453	}
	454
	455	static int alauda_write(struct mtd_info *mtd, loff_t to, size_t len,
	456	size_t retlen, const u_char buf)
	457	{
	458	struct alauda *al = mtd->priv;
	459	int err;
	460
	461	if ((to & al->bytemask) \|\| (len & al->bytemask))
	462	return -EINVAL;
	463
	464	*retlen = len;
	465	while (len) {
	466	u32 page = (to >> al->card->pageshift) & al->pagemask;
	467	u8 oob[16] = { 'h', 'e', 'l', 'l', 'o', 0xff, 0xff, 0xff,
	468	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
	469
	470	/* don't write to bad blocks */
	471	if (page == 0) {
	472	err = alauda_isbad(mtd, to);
	473	if (err) {
	474	return -EIO;
	475	}
	476	}
	477	nand_calculate_ecc(mtd, buf, &oob[13]);
	478	nand_calculate_ecc(mtd, buf+256, &oob[8]);
	479
	480	err = alauda_write_page(mtd, to, (void*)buf, oob);
	481	if (err)
	482	return err;
	483
	484	buf += mtd->writesize;
	485	to += mtd->writesize;
	486	len -= mtd->writesize;
	487	}
	488	return 0;
	489	}
	490
	491	static int __alauda_erase(struct mtd_info mtd, struct erase_info instr)
	492	{
	493	struct alauda *al = mtd->priv;
	494	u32 ofs = instr->addr;
	495	u32 len = instr->len;
	496	int err;
	497
	498	if ((ofs & al->blockmask) \|\| (len & al->blockmask))
	499	return -EINVAL;
	500
	501	while (len) {
	502	/* don't erase bad blocks */
	503	err = alauda_isbad(mtd, ofs);
	504	if (err > 0)
	505	err = -EIO;
	506	if (err < 0)
	507	return err;
	508
	509	err = alauda_erase_block(mtd, ofs);
	510	if (err < 0)
	511	return err;
	512
	513	ofs += mtd->erasesize;
514	len -= mtd->erasesize;
515	}
516	return 0;
517	}
518
519	static int alauda_erase(struct mtd_info mtd, struct erase_info instr)
520	{
521	int err;
522
523	err = __alauda_erase(mtd, instr);
524	instr->state = err ? MTD_ERASE_FAILED : MTD_ERASE_DONE;
525	mtd_erase_callback(instr);
526	return err;
527	}
528
529	static int alauda_init_media(struct alauda *al)
530	{
531	u8 buf[4], b0=buf, b1=buf+1;
532	struct alauda_card *card;
533	struct mtd_info *mtd;
534	int err;
535
536	mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
537	if (!mtd)
538	return -ENOMEM;
539
540	for (;;) {
541	err = alauda_get_media_status(al, buf);
542	if (err < 0)
543	goto error;
544	if (*b0 & 0x10)
545	break;
546	msleep(20);
547	}
548
549	err = alauda_ack_media(al);
550	if (err)
551	goto error;
552
553	msleep(10);
554
555	err = alauda_get_media_status(al, buf);
556	if (err < 0)
557	goto error;
558
559	if (*b0 != 0x14) {
560	/* media not ready */
561	err = -EIO;
562	goto error;
563	}
564	err = alauda_get_media_signatures(al, buf);
565	if (err < 0)
566	goto error;
567
568	card = get_card(*b1);
569	if (!card) {
570	printk(KERN_ERR"Alauda: unknown card id %02x\n", *b1);
571	err = -EIO;
572	goto error;
573	}
574	printk(KERN_INFO"pagesize=%x\nerasesize=%x\nsize=%xMiB\n",
575	1<<card->pageshift, 1<<card->blockshift,
576	1<<(card->chipshift-20));
577	al->card = card;
578	al->pagemask = (1 << (card->blockshift - card->pageshift)) - 1;
579	al->bytemask = (1 << card->pageshift) - 1;
580	al->blockmask = (1 << card->blockshift) - 1;
581
582	mtd->name = "alauda";
583	mtd->size = 1<<card->chipshift;
584	mtd->erasesize = 1<<card->blockshift;
585	mtd->writesize = 1<<card->pageshift;
586	mtd->type = MTD_NANDFLASH;
587	mtd->flags = MTD_CAP_NANDFLASH;
3c3c10bb AB	588	mtd->_read = alauda_read;
	589	mtd->_write = alauda_write;
	590	mtd->_erase = alauda_erase;
	591	mtd->_block_isbad = alauda_isbad;
e208520e JE	592	mtd->priv = al;
e208520e JE	593	mtd->owner = THIS_MODULE;
6a918bad	594	mtd->ecc_strength = 1;
e208520e	595
ee0e87b1	596	err = mtd_device_register(mtd, NULL, 0);
e208520e JE	597	if (err) {
	598	err = -ENFILE;
	599	goto error;
	600	}
	601
	602	al->mtd = mtd;
	603	alauda_reset(al); /* no clue whether this is necessary */
	604	return 0;
	605	error:
	606	kfree(mtd);
	607	return err;
	608	}
	609
	610	static int alauda_check_media(struct alauda *al)
	611	{
	612	u8 buf[2], b0 = buf, b1 = buf+1;
	613	int err;
	614
	615	err = alauda_get_media_status(al, buf);
	616	if (err < 0)
	617	return err;
	618
	619	if ((*b1 & 0x01) == 0) {
	620	/* door open */
	621	return -EIO;
	622	}
	623	if ((b0 & 0x80) \|\| ((b0 & 0x1F) == 0x10)) {
	624	/* no media ? */
	625	return -EIO;
	626	}
	627	if (*b0 & 0x08) {
	628	/* media change ? */
	629	return alauda_init_media(al);
	630	}
	631	return 0;
	632	}
	633
	634	static int alauda_probe(struct usb_interface *interface,
	635	const struct usb_device_id *id)
	636	{
	637	struct alauda *al;
	638	struct usb_host_interface *iface;
	639	struct usb_endpoint_descriptor *ep,
	640	ep_in=NULL, ep_out=NULL, *ep_wr=NULL;
	641	int i, err = -ENOMEM;
	642
	643	al = kzalloc(2sizeof(al), GFP_KERNEL);
	644	if (!al)
	645	goto error;
	646
	647	kref_init(&al->kref);
	648	usb_set_intfdata(interface, al);
	649
	650	al->dev = usb_get_dev(interface_to_usbdev(interface));
	651	al->interface = interface;
	652
	653	iface = interface->cur_altsetting;
	654	for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
	655	ep = &iface->endpoint[i].desc;
	656
	657	if (usb_endpoint_is_bulk_in(ep)) {
	658	ep_in = ep;
	659	} else if (usb_endpoint_is_bulk_out(ep)) {
	660	if (i==0)
661	ep_wr = ep;
662	else
663	ep_out = ep;
664	}
665	}
666	err = -EIO;
667	if (!ep_wr \|\| !ep_in \|\| !ep_out)
668	goto error;
669
670	al->write_out = usb_sndbulkpipe(al->dev,
232ed5e6	671	usb_endpoint_num(ep_wr));
e208520e	672	al->bulk_in = usb_rcvbulkpipe(al->dev,
232ed5e6	673	usb_endpoint_num(ep_in));
e208520e	674	al->bulk_out = usb_sndbulkpipe(al->dev,
232ed5e6	675	usb_endpoint_num(ep_out));
e208520e JE	676
	677	/* second device is identical up to now */
	678	memcpy(al+1, al, sizeof(*al));
	679
	680	mutex_init(&al[0].card_mutex);
	681	mutex_init(&al[1].card_mutex);
	682
	683	al[0].port = ALAUDA_PORT_XD;
	684	al[1].port = ALAUDA_PORT_SM;
	685
b887265c	686	dev_info(&interface->dev, "alauda probed\n");
e208520e JE	687	alauda_check_media(al);
	688	alauda_check_media(al+1);
	689
	690	return 0;
	691
	692	error:
	693	if (al)
	694	kref_put(&al->kref, alauda_delete);
	695	return err;
	696	}
	697
	698	static void alauda_disconnect(struct usb_interface *interface)
	699	{
	700	struct alauda *al;
	701
	702	al = usb_get_intfdata(interface);
	703	usb_set_intfdata(interface, NULL);
	704
	705	/* FIXME: prevent more I/O from starting */
	706
	707	/* decrement our usage count */
	708	if (al)
	709	kref_put(&al->kref, alauda_delete);
	710
b887265c	711	dev_info(&interface->dev, "alauda gone");
e208520e JE	712	}
	713
	714	static struct usb_driver alauda_driver = {
	715	.name = "alauda",
	716	.probe = alauda_probe,
	717	.disconnect = alauda_disconnect,
	718	.id_table = alauda_table,
	719	};
	720
fe748483	721	module_usb_driver(alauda_driver);
e208520e JE	722
e208520e JE	723	MODULE_LICENSE("GPL");