drivers/mtd/maps/vmu-flash.c - kernel/msm.git - Git at Google

 /* vmu-flash.c
  * Driver for SEGA Dreamcast Visual Memory Unit
  *
  * Copyright (c) Adrian McMenamin 2002 - 2009
  * Copyright (c) Paul Mundt 2001
  *
  * Licensed under version 2 of the
  * GNU General Public Licence
  */
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/maple.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>

 struct vmu_cache {
 	unsigned char *buffer;		/* Cache */
 	unsigned int block;		/* Which block was cached */
 	unsigned long jiffies_atc;	/* When was it cached? */
 	int valid;
 };

 struct mdev_part {
 	struct maple_device *mdev;
 	int partition;
 };

 struct vmupart {
 	u16 user_blocks;
 	u16 root_block;
 	u16 numblocks;
 	char *name;
 	struct vmu_cache *pcache;
 };

 struct memcard {
 	u16 tempA;
 	u16 tempB;
 	u32 partitions;
 	u32 blocklen;
 	u32 writecnt;
 	u32 readcnt;
 	u32 removeable;
 	int partition;
 	int read;
 	unsigned char *blockread;
 	struct vmupart *parts;
 	struct mtd_info *mtd;
 };

 struct vmu_block {
 	unsigned int num; /* block number */
 	unsigned int ofs; /* block offset */
 };

 static struct vmu_block *ofs_to_block(unsigned long src_ofs,
 	struct mtd_info *mtd, int partition)
 {
 	struct vmu_block *vblock;
 	struct maple_device *mdev;
 	struct memcard *card;
 	struct mdev_part *mpart;
 	int num;

 	mpart = mtd->priv;
 	mdev = mpart->mdev;
 	card = maple_get_drvdata(mdev);

 	if (src_ofs >= card->parts[partition].numblocks * card->blocklen)
 		goto failed;

 	num = src_ofs / card->blocklen;
 	if (num > card->parts[partition].numblocks)
 		goto failed;

 	vblock = kmalloc(sizeof(struct vmu_block), GFP_KERNEL);
 	if (!vblock)
 		goto failed;

 	vblock->num = num;
 	vblock->ofs = src_ofs % card->blocklen;
 	return vblock;

 failed:
 	return NULL;
 }

 /* Maple bus callback function for reads */
 static void vmu_blockread(struct mapleq *mq)
 {
 	struct maple_device *mdev;
 	struct memcard *card;

 	mdev = mq->dev;
 	card = maple_get_drvdata(mdev);
 	/* copy the read in data */

 	if (unlikely(!card->blockread))
 		return;

 	memcpy(card->blockread, mq->recvbuf->buf + 12,
 		card->blocklen/card->readcnt);

 }

 /* Interface with maple bus to read blocks
  * caching the results so that other parts
  * of the driver can access block reads */
 static int maple_vmu_read_block(unsigned int num, unsigned char *buf,
 	struct mtd_info *mtd)
 {
 	struct memcard *card;
 	struct mdev_part *mpart;
 	struct maple_device *mdev;
 	int partition, error = 0, x, wait;
 	unsigned char *blockread = NULL;
 	struct vmu_cache *pcache;
 	__be32 sendbuf;

 	mpart = mtd->priv;
 	mdev = mpart->mdev;
 	partition = mpart->partition;
 	card = maple_get_drvdata(mdev);
 	pcache = card->parts[partition].pcache;
 	pcache->valid = 0;

 	/* prepare the cache for this block */
 	if (!pcache->buffer) {
 		pcache->buffer = kmalloc(card->blocklen, GFP_KERNEL);
 		if (!pcache->buffer) {
 			dev_err(&mdev->dev, "VMU at (%d, %d) - read fails due"
 				" to lack of memory\n", mdev->port,
 				mdev->unit);
 			error = -ENOMEM;
 			goto outB;
 		}
 	}

 	/*
 	* Reads may be phased - again the hardware spec
 	* supports this - though may not be any devices in
 	* the wild that implement it, but we will here
 	*/
 	for (x = 0; x < card->readcnt; x++) {
 		sendbuf = cpu_to_be32(partition << 24 | x << 16 | num);

 		if (atomic_read(&mdev->busy) == 1) {
 			wait_event_interruptible_timeout(mdev->maple_wait,
 				atomic_read(&mdev->busy) == 0, HZ);
 			if (atomic_read(&mdev->busy) == 1) {
 				dev_notice(&mdev->dev, "VMU at (%d, %d)"
 					" is busy\n", mdev->port, mdev->unit);
 				error = -EAGAIN;
 				goto outB;
 			}
 		}

 		atomic_set(&mdev->busy, 1);
 		blockread = kmalloc(card->blocklen/card->readcnt, GFP_KERNEL);
 		if (!blockread) {
 			error = -ENOMEM;
 			atomic_set(&mdev->busy, 0);
 			goto outB;
 		}
 		card->blockread = blockread;

 		maple_getcond_callback(mdev, vmu_blockread, 0,
 			MAPLE_FUNC_MEMCARD);
 		error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 				MAPLE_COMMAND_BREAD, 2, &sendbuf);
 		/* Very long timeouts seem to be needed when box is stressed */
 		wait = wait_event_interruptible_timeout(mdev->maple_wait,
 			(atomic_read(&mdev->busy) == 0 ||
 			atomic_read(&mdev->busy) == 2), HZ * 3);
 		/*
 		* MTD layer does not handle hotplugging well
 		* so have to return errors when VMU is unplugged
 		* in the middle of a read (busy == 2)
 		*/
 		if (error || atomic_read(&mdev->busy) == 2) {
 			if (atomic_read(&mdev->busy) == 2)
 				error = -ENXIO;
 			atomic_set(&mdev->busy, 0);
 			card->blockread = NULL;
 			goto outA;
 		}
 		if (wait == 0 || wait == -ERESTARTSYS) {
 			card->blockread = NULL;
 			atomic_set(&mdev->busy, 0);
 			error = -EIO;
 			list_del_init(&(mdev->mq->list));
 			kfree(mdev->mq->sendbuf);
 			mdev->mq->sendbuf = NULL;
 			if (wait == -ERESTARTSYS) {
 				dev_warn(&mdev->dev, "VMU read on (%d, %d)"
 					" interrupted on block 0x%X\n",
 					mdev->port, mdev->unit, num);
 			} else
 				dev_notice(&mdev->dev, "VMU read on (%d, %d)"
 					" timed out on block 0x%X\n",
 					mdev->port, mdev->unit, num);
 			goto outA;
 		}

 		memcpy(buf + (card->blocklen/card->readcnt) * x, blockread,
 			card->blocklen/card->readcnt);

 		memcpy(pcache->buffer + (card->blocklen/card->readcnt) * x,
 			card->blockread, card->blocklen/card->readcnt);
 		card->blockread = NULL;
 		pcache->block = num;
 		pcache->jiffies_atc = jiffies;
 		pcache->valid = 1;
 		kfree(blockread);
 	}

 	return error;

 outA:
 	kfree(blockread);
 outB:
 	return error;
 }

 /* communicate with maple bus for phased writing */
 static int maple_vmu_write_block(unsigned int num, const unsigned char *buf,
 	struct mtd_info *mtd)
 {
 	struct memcard *card;
 	struct mdev_part *mpart;
 	struct maple_device *mdev;
 	int partition, error, locking, x, phaselen, wait;
 	__be32 *sendbuf;

 	mpart = mtd->priv;
 	mdev = mpart->mdev;
 	partition = mpart->partition;
 	card = maple_get_drvdata(mdev);

 	phaselen = card->blocklen/card->writecnt;

 	sendbuf = kmalloc(phaselen + 4, GFP_KERNEL);
 	if (!sendbuf) {
 		error = -ENOMEM;
 		goto fail_nosendbuf;
 	}
 	for (x = 0; x < card->writecnt; x++) {
 		sendbuf[0] = cpu_to_be32(partition << 24 | x << 16 | num);
 		memcpy(&sendbuf[1], buf + phaselen * x, phaselen);
 		/* wait until the device is not busy doing something else
 		* or 1 second - which ever is longer */
 		if (atomic_read(&mdev->busy) == 1) {
 			wait_event_interruptible_timeout(mdev->maple_wait,
 				atomic_read(&mdev->busy) == 0, HZ);
 			if (atomic_read(&mdev->busy) == 1) {
 				error = -EBUSY;
 				dev_notice(&mdev->dev, "VMU write at (%d, %d)"
 					"failed - device is busy\n",
 					mdev->port, mdev->unit);
 				goto fail_nolock;
 			}
 		}
 		atomic_set(&mdev->busy, 1);

 		locking = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 			MAPLE_COMMAND_BWRITE, phaselen / 4 + 2, sendbuf);
 		wait = wait_event_interruptible_timeout(mdev->maple_wait,
 			atomic_read(&mdev->busy) == 0, HZ/10);
 		if (locking) {
 			error = -EIO;
 			atomic_set(&mdev->busy, 0);
 			goto fail_nolock;
 		}
 		if (atomic_read(&mdev->busy) == 2) {
 			atomic_set(&mdev->busy, 0);
 		} else if (wait == 0 || wait == -ERESTARTSYS) {
 			error = -EIO;
 			dev_warn(&mdev->dev, "Write at (%d, %d) of block"
 				" 0x%X at phase %d failed: could not"
 				" communicate with VMU", mdev->port,
 				mdev->unit, num, x);
 			atomic_set(&mdev->busy, 0);
 			kfree(mdev->mq->sendbuf);
 			mdev->mq->sendbuf = NULL;
 			list_del_init(&(mdev->mq->list));
 			goto fail_nolock;
 		}
 	}
 	kfree(sendbuf);

 	return card->blocklen;

 fail_nolock:
 	kfree(sendbuf);
 fail_nosendbuf:
 	dev_err(&mdev->dev, "VMU (%d, %d): write failed\n", mdev->port,
 		mdev->unit);
 	return error;
 }

 /* mtd function to simulate reading byte by byte */
 static unsigned char vmu_flash_read_char(unsigned long ofs, int *retval,
 	struct mtd_info *mtd)
 {
 	struct vmu_block *vblock;
 	struct memcard *card;
 	struct mdev_part *mpart;
 	struct maple_device *mdev;
 	unsigned char *buf, ret;
 	int partition, error;

 	mpart = mtd->priv;
 	mdev = mpart->mdev;
 	partition = mpart->partition;
 	card = maple_get_drvdata(mdev);
 	*retval =  0;

 	buf = kmalloc(card->blocklen, GFP_KERNEL);
 	if (!buf) {
 		*retval = 1;
 		ret = -ENOMEM;
 		goto finish;
 	}

 	vblock = ofs_to_block(ofs, mtd, partition);
 	if (!vblock) {
 		*retval = 3;
 		ret = -ENOMEM;
 		goto out_buf;
 	}

 	error = maple_vmu_read_block(vblock->num, buf, mtd);
 	if (error) {
 		ret = error;
 		*retval = 2;
 		goto out_vblock;
 	}

 	ret = buf[vblock->ofs];

 out_vblock:
 	kfree(vblock);
 out_buf:
 	kfree(buf);
 finish:
 	return ret;
 }

 /* mtd higher order function to read flash */
 static int vmu_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
 	size_t *retlen,  u_char *buf)
 {
 	struct maple_device *mdev;
 	struct memcard *card;
 	struct mdev_part *mpart;
 	struct vmu_cache *pcache;
 	struct vmu_block *vblock;
 	int index = 0, retval, partition, leftover, numblocks;
 	unsigned char cx;

 	mpart = mtd->priv;
 	mdev = mpart->mdev;
 	partition = mpart->partition;
 	card = maple_get_drvdata(mdev);

 	numblocks = card->parts[partition].numblocks;
 	if (from + len > numblocks * card->blocklen)
 		len = numblocks * card->blocklen - from;
 	if (len == 0)
 		return -EIO;
 	/* Have we cached this bit already? */
 	pcache = card->parts[partition].pcache;
 	do {
 		vblock =  ofs_to_block(from + index, mtd, partition);
 		if (!vblock)
 			return -ENOMEM;
 		/* Have we cached this and is the cache valid and timely? */
 		if (pcache->valid &&
 			time_before(jiffies, pcache->jiffies_atc + HZ) &&
 			(pcache->block == vblock->num)) {
 			/* we have cached it, so do necessary copying */
 			leftover = card->blocklen - vblock->ofs;
 			if (vblock->ofs + len - index < card->blocklen) {
 				/* only a bit of this block to copy */
 				memcpy(buf + index,
 					pcache->buffer + vblock->ofs,
 					len - index);
 				index = len;
 			} else {
 				/* otherwise copy remainder of whole block */
 				memcpy(buf + index, pcache->buffer +
 					vblock->ofs, leftover);
 				index += leftover;
 			}
 		} else {
 			/*
 			* Not cached so read one byte -
 			* but cache the rest of the block
 			*/
 			cx = vmu_flash_read_char(from + index, &retval, mtd);
 			if (retval) {
 				*retlen = index;
 				kfree(vblock);
 				return cx;
 			}
 			memset(buf + index, cx, 1);
 			index++;
 		}
 		kfree(vblock);
 	} while (len > index);
 	*retlen = index;

 	return 0;
 }

 static int vmu_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
 	size_t *retlen, const u_char *buf)
 {
 	struct maple_device *mdev;
 	struct memcard *card;
 	struct mdev_part *mpart;
 	int index = 0, partition, error = 0, numblocks;
 	struct vmu_cache *pcache;
 	struct vmu_block *vblock;
 	unsigned char *buffer;

 	mpart = mtd->priv;
 	mdev = mpart->mdev;
 	partition = mpart->partition;
 	card = maple_get_drvdata(mdev);

 	numblocks = card->parts[partition].numblocks;
 	if (to + len > numblocks * card->blocklen)
 		len = numblocks * card->blocklen - to;
 	if (len == 0) {
 		error = -EIO;
 		goto failed;
 	}

 	vblock = ofs_to_block(to, mtd, partition);
 	if (!vblock) {
 		error = -ENOMEM;
 		goto failed;
 	}

 	buffer = kmalloc(card->blocklen, GFP_KERNEL);
 	if (!buffer) {
 		error = -ENOMEM;
 		goto fail_buffer;
 	}

 	do {
 		/* Read in the block we are to write to */
 		error = maple_vmu_read_block(vblock->num, buffer, mtd);
 		if (error)
 			goto fail_io;

 		do {
 			buffer[vblock->ofs] = buf[index];
 			vblock->ofs++;
 			index++;
 			if (index >= len)
 				break;
 		} while (vblock->ofs < card->blocklen);

 		/* write out new buffer */
 		error = maple_vmu_write_block(vblock->num, buffer, mtd);
 		/* invalidate the cache */
 		pcache = card->parts[partition].pcache;
 		pcache->valid = 0;

 		if (error != card->blocklen)
 			goto fail_io;

 		vblock->num++;
 		vblock->ofs = 0;
 	} while (len > index);

 	kfree(buffer);
 	*retlen = index;
 	kfree(vblock);
 	return 0;

 fail_io:
 	kfree(buffer);
 fail_buffer:
 	kfree(vblock);
 failed:
 	dev_err(&mdev->dev, "VMU write failing with error %d\n", error);
 	return error;
 }

 static void vmu_flash_sync(struct mtd_info *mtd)
 {
 	/* Do nothing here */
 }

 /* Maple bus callback function to recursively query hardware details */
 static void vmu_queryblocks(struct mapleq *mq)
 {
 	struct maple_device *mdev;
 	unsigned short *res;
 	struct memcard *card;
 	__be32 partnum;
 	struct vmu_cache *pcache;
 	struct mdev_part *mpart;
 	struct mtd_info *mtd_cur;
 	struct vmupart *part_cur;
 	int error;

 	mdev = mq->dev;
 	card = maple_get_drvdata(mdev);
 	res = (unsigned short *) (mq->recvbuf->buf);
 	card->tempA = res[12];
 	card->tempB = res[6];

 	dev_info(&mdev->dev, "VMU device at partition %d has %d user "
 		"blocks with a root block at %d\n", card->partition,
 		card->tempA, card->tempB);

 	part_cur = &card->parts[card->partition];
 	part_cur->user_blocks = card->tempA;
 	part_cur->root_block = card->tempB;
 	part_cur->numblocks = card->tempB + 1;
 	part_cur->name = kmalloc(12, GFP_KERNEL);
 	if (!part_cur->name)
 		goto fail_name;

 	sprintf(part_cur->name, "vmu%d.%d.%d",
 		mdev->port, mdev->unit, card->partition);
 	mtd_cur = &card->mtd[card->partition];
 	mtd_cur->name = part_cur->name;
 	mtd_cur->type = 8;
 	mtd_cur->flags = MTD_WRITEABLE|MTD_NO_ERASE;
 	mtd_cur->size = part_cur->numblocks * card->blocklen;
 	mtd_cur->erasesize = card->blocklen;
 	mtd_cur->_write = vmu_flash_write;
 	mtd_cur->_read = vmu_flash_read;
 	mtd_cur->_sync = vmu_flash_sync;
 	mtd_cur->writesize = card->blocklen;

 	mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL);
 	if (!mpart)
 		goto fail_mpart;

 	mpart->mdev = mdev;
 	mpart->partition = card->partition;
 	mtd_cur->priv = mpart;
 	mtd_cur->owner = THIS_MODULE;

 	pcache = kzalloc(sizeof(struct vmu_cache), GFP_KERNEL);
 	if (!pcache)
 		goto fail_cache_create;
 	part_cur->pcache = pcache;

 	error = mtd_device_register(mtd_cur, NULL, 0);
 	if (error)
 		goto fail_mtd_register;

 	maple_getcond_callback(mdev, NULL, 0,
 		MAPLE_FUNC_MEMCARD);

 	/*
 	* Set up a recursive call to the (probably theoretical)
 	* second or more partition
 	*/
 	if (++card->partition < card->partitions) {
 		partnum = cpu_to_be32(card->partition << 24);
 		maple_getcond_callback(mdev, vmu_queryblocks, 0,
 			MAPLE_FUNC_MEMCARD);
 		maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 			MAPLE_COMMAND_GETMINFO, 2, &partnum);
 	}
 	return;

 fail_mtd_register:
 	dev_err(&mdev->dev, "Could not register maple device at (%d, %d)"
 		"error is 0x%X\n", mdev->port, mdev->unit, error);
 	for (error = 0; error <= card->partition; error++) {
 		kfree(((card->parts)[error]).pcache);
 		((card->parts)[error]).pcache = NULL;
 	}
 fail_cache_create:
 fail_mpart:
 	for (error = 0; error <= card->partition; error++) {
 		kfree(((card->mtd)[error]).priv);
 		((card->mtd)[error]).priv = NULL;
 	}
 	maple_getcond_callback(mdev, NULL, 0,
 		MAPLE_FUNC_MEMCARD);
 	kfree(part_cur->name);
 fail_name:
 	return;
 }

 /* Handles very basic info about the flash, queries for details */
 static int vmu_connect(struct maple_device *mdev)
 {
 	unsigned long test_flash_data, basic_flash_data;
 	int c, error;
 	struct memcard *card;
 	u32 partnum = 0;

 	test_flash_data = be32_to_cpu(mdev->devinfo.function);
 	/* Need to count how many bits are set - to find out which
 	 * function_data element has details of the memory card
 	 */
 	c = hweight_long(test_flash_data);

 	basic_flash_data = be32_to_cpu(mdev->devinfo.function_data[c - 1]);

 	card = kmalloc(sizeof(struct memcard), GFP_KERNEL);
 	if (!card) {
 		error = -ENOMEM;
 		goto fail_nomem;
 	}

 	card->partitions = (basic_flash_data >> 24 & 0xFF) + 1;
 	card->blocklen = ((basic_flash_data >> 16 & 0xFF) + 1) << 5;
 	card->writecnt = basic_flash_data >> 12 & 0xF;
 	card->readcnt = basic_flash_data >> 8 & 0xF;
 	card->removeable = basic_flash_data >> 7 & 1;

 	card->partition = 0;

 	/*
 	* Not sure there are actually any multi-partition devices in the
 	* real world, but the hardware supports them, so, so will we
 	*/
 	card->parts = kmalloc(sizeof(struct vmupart) * card->partitions,
 		GFP_KERNEL);
 	if (!card->parts) {
 		error = -ENOMEM;
 		goto fail_partitions;
 	}

 	card->mtd = kmalloc(sizeof(struct mtd_info) * card->partitions,
 		GFP_KERNEL);
 	if (!card->mtd) {
 		error = -ENOMEM;
 		goto fail_mtd_info;
 	}

 	maple_set_drvdata(mdev, card);

 	/*
 	* We want to trap meminfo not get cond
 	* so set interval to zero, but rely on maple bus
 	* driver to pass back the results of the meminfo
 	*/
 	maple_getcond_callback(mdev, vmu_queryblocks, 0,
 		MAPLE_FUNC_MEMCARD);

 	/* Make sure we are clear to go */
 	if (atomic_read(&mdev->busy) == 1) {
 		wait_event_interruptible_timeout(mdev->maple_wait,
 			atomic_read(&mdev->busy) == 0, HZ);
 		if (atomic_read(&mdev->busy) == 1) {
 			dev_notice(&mdev->dev, "VMU at (%d, %d) is busy\n",
 				mdev->port, mdev->unit);
 			error = -EAGAIN;
 			goto fail_device_busy;
 		}
 	}

 	atomic_set(&mdev->busy, 1);

 	/*
 	* Set up the minfo call: vmu_queryblocks will handle
 	* the information passed back
 	*/
 	error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 		MAPLE_COMMAND_GETMINFO, 2, &partnum);
 	if (error) {
 		dev_err(&mdev->dev, "Could not lock VMU at (%d, %d)"
 			" error is 0x%X\n", mdev->port, mdev->unit, error);
 		goto fail_mtd_info;
 	}
 	return 0;

 fail_device_busy:
 	kfree(card->mtd);
 fail_mtd_info:
 	kfree(card->parts);
 fail_partitions:
 	kfree(card);
 fail_nomem:
 	return error;
 }

 static void vmu_disconnect(struct maple_device *mdev)
 {
 	struct memcard *card;
 	struct mdev_part *mpart;
 	int x;

 	mdev->callback = NULL;
 	card = maple_get_drvdata(mdev);
 	for (x = 0; x < card->partitions; x++) {
 		mpart = ((card->mtd)[x]).priv;
 		mpart->mdev = NULL;
 		mtd_device_unregister(&((card->mtd)[x]));
 		kfree(((card->parts)[x]).name);
 	}
 	kfree(card->parts);
 	kfree(card->mtd);
 	kfree(card);
 }

 /* Callback to handle eccentricities of both mtd subsystem
  * and general flakyness of Dreamcast VMUs
  */
 static int vmu_can_unload(struct maple_device *mdev)
 {
 	struct memcard *card;
 	int x;
 	struct mtd_info *mtd;

 	card = maple_get_drvdata(mdev);
 	for (x = 0; x < card->partitions; x++) {
 		mtd = &((card->mtd)[x]);
 		if (mtd->usecount > 0)
 			return 0;
 	}
 	return 1;
 }

 #define ERRSTR "VMU at (%d, %d) file error -"

 static void vmu_file_error(struct maple_device *mdev, void *recvbuf)
 {
 	enum maple_file_errors error = ((int *)recvbuf)[1];

 	switch (error) {

 	case MAPLE_FILEERR_INVALID_PARTITION:
 		dev_notice(&mdev->dev, ERRSTR " invalid partition number\n",
 			mdev->port, mdev->unit);
 		break;

 	case MAPLE_FILEERR_PHASE_ERROR:
 		dev_notice(&mdev->dev, ERRSTR " phase error\n",
 			mdev->port, mdev->unit);
 		break;

 	case MAPLE_FILEERR_INVALID_BLOCK:
 		dev_notice(&mdev->dev, ERRSTR " invalid block number\n",
 			mdev->port, mdev->unit);
 		break;

 	case MAPLE_FILEERR_WRITE_ERROR:
 		dev_notice(&mdev->dev, ERRSTR " write error\n",
 			mdev->port, mdev->unit);
 		break;

 	case MAPLE_FILEERR_INVALID_WRITE_LENGTH:
 		dev_notice(&mdev->dev, ERRSTR " invalid write length\n",
 			mdev->port, mdev->unit);
 		break;

 	case MAPLE_FILEERR_BAD_CRC:
 		dev_notice(&mdev->dev, ERRSTR " bad CRC\n",
 			mdev->port, mdev->unit);
 		break;

 	default:
 		dev_notice(&mdev->dev, ERRSTR " 0x%X\n",
 			mdev->port, mdev->unit, error);
 	}
 }


 static int probe_maple_vmu(struct device *dev)
 {
 	int error;
 	struct maple_device *mdev = to_maple_dev(dev);
 	struct maple_driver *mdrv = to_maple_driver(dev->driver);

 	mdev->can_unload = vmu_can_unload;
 	mdev->fileerr_handler = vmu_file_error;
 	mdev->driver = mdrv;

 	error = vmu_connect(mdev);
 	if (error)
 		return error;

 	return 0;
 }

 static int remove_maple_vmu(struct device *dev)
 {
 	struct maple_device *mdev = to_maple_dev(dev);

 	vmu_disconnect(mdev);
 	return 0;
 }

 static struct maple_driver vmu_flash_driver = {
 	.function =	MAPLE_FUNC_MEMCARD,
 	.drv = {
 		.name =		"Dreamcast_visual_memory",
 		.probe =	probe_maple_vmu,
 		.remove =	remove_maple_vmu,
 	},
 };

 static int __init vmu_flash_map_init(void)
 {
 	return maple_driver_register(&vmu_flash_driver);
 }

 static void __exit vmu_flash_map_exit(void)
 {
 	maple_driver_unregister(&vmu_flash_driver);
 }

 module_init(vmu_flash_map_init);
 module_exit(vmu_flash_map_exit);

 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Adrian McMenamin");
 MODULE_DESCRIPTION("Flash mapping for Sega Dreamcast visual memory");
	/* vmu-flash.c
	* Driver for SEGA Dreamcast Visual Memory Unit
	*
	* Copyright (c) Adrian McMenamin 2002 - 2009
	* Copyright (c) Paul Mundt 2001
	*
	* Licensed under version 2 of the
	* GNU General Public Licence
	*/
	#include <linux/init.h>
	#include <linux/slab.h>
	#include <linux/sched.h>
	#include <linux/delay.h>
	#include <linux/maple.h>
	#include <linux/mtd/mtd.h>
	#include <linux/mtd/map.h>

	struct vmu_cache {
	unsigned char buffer; / Cache */
	unsigned int block; /* Which block was cached */
	unsigned long jiffies_atc; /* When was it cached? */
	int valid;
	};

	struct mdev_part {
	struct maple_device *mdev;
	int partition;
	};

	struct vmupart {
	u16 user_blocks;
	u16 root_block;
	u16 numblocks;
	char *name;
	struct vmu_cache *pcache;
	};

	struct memcard {
	u16 tempA;
	u16 tempB;
	u32 partitions;
	u32 blocklen;
	u32 writecnt;
	u32 readcnt;
	u32 removeable;
	int partition;
	int read;
	unsigned char *blockread;
	struct vmupart *parts;
	struct mtd_info *mtd;
	};

	struct vmu_block {
	unsigned int num; /* block number */
	unsigned int ofs; /* block offset */
	};

	static struct vmu_block *ofs_to_block(unsigned long src_ofs,
	struct mtd_info *mtd, int partition)
	{
	struct vmu_block *vblock;
	struct maple_device *mdev;
	struct memcard *card;
	struct mdev_part *mpart;
	int num;

	mpart = mtd->priv;
	mdev = mpart->mdev;
	card = maple_get_drvdata(mdev);

	if (src_ofs >= card->parts[partition].numblocks * card->blocklen)
	goto failed;

	num = src_ofs / card->blocklen;
	if (num > card->parts[partition].numblocks)
	goto failed;

	vblock = kmalloc(sizeof(struct vmu_block), GFP_KERNEL);
	if (!vblock)
	goto failed;

	vblock->num = num;
	vblock->ofs = src_ofs % card->blocklen;
	return vblock;

	failed:
	return NULL;
	}

	/* Maple bus callback function for reads */
	static void vmu_blockread(struct mapleq *mq)
	{
	struct maple_device *mdev;
	struct memcard *card;

	mdev = mq->dev;
	card = maple_get_drvdata(mdev);
	/* copy the read in data */

	if (unlikely(!card->blockread))
	return;

	memcpy(card->blockread, mq->recvbuf->buf + 12,
	card->blocklen/card->readcnt);

	}

	/* Interface with maple bus to read blocks
	* caching the results so that other parts
	* of the driver can access block reads */
	static int maple_vmu_read_block(unsigned int num, unsigned char *buf,
	struct mtd_info *mtd)
	{
	struct memcard *card;
	struct mdev_part *mpart;
	struct maple_device *mdev;
	int partition, error = 0, x, wait;
	unsigned char *blockread = NULL;
	struct vmu_cache *pcache;
	__be32 sendbuf;

	mpart = mtd->priv;
	mdev = mpart->mdev;
	partition = mpart->partition;
	card = maple_get_drvdata(mdev);
	pcache = card->parts[partition].pcache;
	pcache->valid = 0;

	/* prepare the cache for this block */
	if (!pcache->buffer) {
	pcache->buffer = kmalloc(card->blocklen, GFP_KERNEL);
	if (!pcache->buffer) {
	dev_err(&mdev->dev, "VMU at (%d, %d) - read fails due"
	" to lack of memory\n", mdev->port,
	mdev->unit);
	error = -ENOMEM;
	goto outB;
	}
	}

	/*
	* Reads may be phased - again the hardware spec
	* supports this - though may not be any devices in
	* the wild that implement it, but we will here
	*/
	for (x = 0; x < card->readcnt; x++) {
	sendbuf = cpu_to_be32(partition << 24 \| x << 16 \| num);

	if (atomic_read(&mdev->busy) == 1) {
	wait_event_interruptible_timeout(mdev->maple_wait,
	atomic_read(&mdev->busy) == 0, HZ);
	if (atomic_read(&mdev->busy) == 1) {
	dev_notice(&mdev->dev, "VMU at (%d, %d)"
	" is busy\n", mdev->port, mdev->unit);
	error = -EAGAIN;
	goto outB;
	}
	}

	atomic_set(&mdev->busy, 1);
	blockread = kmalloc(card->blocklen/card->readcnt, GFP_KERNEL);
	if (!blockread) {
	error = -ENOMEM;
	atomic_set(&mdev->busy, 0);
	goto outB;
	}
	card->blockread = blockread;

	maple_getcond_callback(mdev, vmu_blockread, 0,
	MAPLE_FUNC_MEMCARD);
	error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
	MAPLE_COMMAND_BREAD, 2, &sendbuf);
	/* Very long timeouts seem to be needed when box is stressed */
	wait = wait_event_interruptible_timeout(mdev->maple_wait,
	(atomic_read(&mdev->busy) == 0 \|\|
	atomic_read(&mdev->busy) == 2), HZ * 3);
	/*
	* MTD layer does not handle hotplugging well
	* so have to return errors when VMU is unplugged
	* in the middle of a read (busy == 2)
	*/
	if (error \|\| atomic_read(&mdev->busy) == 2) {
	if (atomic_read(&mdev->busy) == 2)
	error = -ENXIO;
	atomic_set(&mdev->busy, 0);
	card->blockread = NULL;
	goto outA;
	}
	if (wait == 0 \|\| wait == -ERESTARTSYS) {
	card->blockread = NULL;
	atomic_set(&mdev->busy, 0);
	error = -EIO;
	list_del_init(&(mdev->mq->list));
	kfree(mdev->mq->sendbuf);
	mdev->mq->sendbuf = NULL;
	if (wait == -ERESTARTSYS) {
	dev_warn(&mdev->dev, "VMU read on (%d, %d)"
	" interrupted on block 0x%X\n",
	mdev->port, mdev->unit, num);
	} else
	dev_notice(&mdev->dev, "VMU read on (%d, %d)"
	" timed out on block 0x%X\n",
	mdev->port, mdev->unit, num);
	goto outA;
	}

	memcpy(buf + (card->blocklen/card->readcnt) * x, blockread,
	card->blocklen/card->readcnt);

	memcpy(pcache->buffer + (card->blocklen/card->readcnt) * x,
	card->blockread, card->blocklen/card->readcnt);
	card->blockread = NULL;
	pcache->block = num;
	pcache->jiffies_atc = jiffies;
	pcache->valid = 1;
	kfree(blockread);
	}

	return error;

	outA:
	kfree(blockread);
	outB:
	return error;
	}

	/* communicate with maple bus for phased writing */
	static int maple_vmu_write_block(unsigned int num, const unsigned char *buf,
	struct mtd_info *mtd)
	{
	struct memcard *card;
	struct mdev_part *mpart;
	struct maple_device *mdev;
	int partition, error, locking, x, phaselen, wait;
	__be32 *sendbuf;

	mpart = mtd->priv;
	mdev = mpart->mdev;
	partition = mpart->partition;
	card = maple_get_drvdata(mdev);

	phaselen = card->blocklen/card->writecnt;

	sendbuf = kmalloc(phaselen + 4, GFP_KERNEL);
	if (!sendbuf) {
	error = -ENOMEM;
	goto fail_nosendbuf;
	}
	for (x = 0; x < card->writecnt; x++) {
	sendbuf[0] = cpu_to_be32(partition << 24 \| x << 16 \| num);
	memcpy(&sendbuf[1], buf + phaselen * x, phaselen);
	/* wait until the device is not busy doing something else
	* or 1 second - which ever is longer */
	if (atomic_read(&mdev->busy) == 1) {
	wait_event_interruptible_timeout(mdev->maple_wait,
	atomic_read(&mdev->busy) == 0, HZ);
	if (atomic_read(&mdev->busy) == 1) {
	error = -EBUSY;
	dev_notice(&mdev->dev, "VMU write at (%d, %d)"
	"failed - device is busy\n",
	mdev->port, mdev->unit);
	goto fail_nolock;
	}
	}
	atomic_set(&mdev->busy, 1);

	locking = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
	MAPLE_COMMAND_BWRITE, phaselen / 4 + 2, sendbuf);
	wait = wait_event_interruptible_timeout(mdev->maple_wait,
	atomic_read(&mdev->busy) == 0, HZ/10);
	if (locking) {
	error = -EIO;
	atomic_set(&mdev->busy, 0);
	goto fail_nolock;
	}
	if (atomic_read(&mdev->busy) == 2) {
	atomic_set(&mdev->busy, 0);
	} else if (wait == 0 \|\| wait == -ERESTARTSYS) {
	error = -EIO;
	dev_warn(&mdev->dev, "Write at (%d, %d) of block"
	" 0x%X at phase %d failed: could not"
	" communicate with VMU", mdev->port,
	mdev->unit, num, x);
	atomic_set(&mdev->busy, 0);
	kfree(mdev->mq->sendbuf);
	mdev->mq->sendbuf = NULL;
	list_del_init(&(mdev->mq->list));
	goto fail_nolock;
	}
	}
	kfree(sendbuf);

	return card->blocklen;

	fail_nolock:
	kfree(sendbuf);
	fail_nosendbuf:
	dev_err(&mdev->dev, "VMU (%d, %d): write failed\n", mdev->port,
	mdev->unit);
	return error;
	}

	/* mtd function to simulate reading byte by byte */
	static unsigned char vmu_flash_read_char(unsigned long ofs, int *retval,
	struct mtd_info *mtd)
	{
	struct vmu_block *vblock;
	struct memcard *card;
	struct mdev_part *mpart;
	struct maple_device *mdev;
	unsigned char *buf, ret;
	int partition, error;

	mpart = mtd->priv;
	mdev = mpart->mdev;
	partition = mpart->partition;
	card = maple_get_drvdata(mdev);
	*retval = 0;

	buf = kmalloc(card->blocklen, GFP_KERNEL);
	if (!buf) {
	*retval = 1;
	ret = -ENOMEM;
	goto finish;
	}

	vblock = ofs_to_block(ofs, mtd, partition);
	if (!vblock) {
	*retval = 3;
	ret = -ENOMEM;
	goto out_buf;
	}

	error = maple_vmu_read_block(vblock->num, buf, mtd);
	if (error) {
	ret = error;
	*retval = 2;
	goto out_vblock;
	}

	ret = buf[vblock->ofs];

	out_vblock:
	kfree(vblock);
	out_buf:
	kfree(buf);
	finish:
	return ret;
	}

	/* mtd higher order function to read flash */
	static int vmu_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
	size_t retlen, u_char buf)
	{
	struct maple_device *mdev;
	struct memcard *card;
	struct mdev_part *mpart;
	struct vmu_cache *pcache;
	struct vmu_block *vblock;
	int index = 0, retval, partition, leftover, numblocks;
	unsigned char cx;

	mpart = mtd->priv;
	mdev = mpart->mdev;
	partition = mpart->partition;
	card = maple_get_drvdata(mdev);

	numblocks = card->parts[partition].numblocks;
	if (from + len > numblocks * card->blocklen)
	len = numblocks * card->blocklen - from;
	if (len == 0)
	return -EIO;
	/* Have we cached this bit already? */
	pcache = card->parts[partition].pcache;
	do {
	vblock = ofs_to_block(from + index, mtd, partition);
	if (!vblock)
	return -ENOMEM;
	/* Have we cached this and is the cache valid and timely? */
	if (pcache->valid &&
	time_before(jiffies, pcache->jiffies_atc + HZ) &&
	(pcache->block == vblock->num)) {
	/* we have cached it, so do necessary copying */
	leftover = card->blocklen - vblock->ofs;
	if (vblock->ofs + len - index < card->blocklen) {
	/* only a bit of this block to copy */
	memcpy(buf + index,
	pcache->buffer + vblock->ofs,
	len - index);
	index = len;
	} else {
	/* otherwise copy remainder of whole block */
	memcpy(buf + index, pcache->buffer +
	vblock->ofs, leftover);
	index += leftover;
	}
	} else {
	/*
	* Not cached so read one byte -
	* but cache the rest of the block
	*/
	cx = vmu_flash_read_char(from + index, &retval, mtd);
	if (retval) {
	*retlen = index;
	kfree(vblock);
	return cx;
	}
	memset(buf + index, cx, 1);
	index++;
	}
	kfree(vblock);
	} while (len > index);
	*retlen = index;

	return 0;
	}

	static int vmu_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
	size_t retlen, const u_char buf)
	{
	struct maple_device *mdev;
	struct memcard *card;
	struct mdev_part *mpart;
	int index = 0, partition, error = 0, numblocks;
	struct vmu_cache *pcache;
	struct vmu_block *vblock;
	unsigned char *buffer;

	mpart = mtd->priv;
	mdev = mpart->mdev;
	partition = mpart->partition;
	card = maple_get_drvdata(mdev);

	numblocks = card->parts[partition].numblocks;
	if (to + len > numblocks * card->blocklen)
	len = numblocks * card->blocklen - to;
	if (len == 0) {
	error = -EIO;
	goto failed;
	}

	vblock = ofs_to_block(to, mtd, partition);
	if (!vblock) {
	error = -ENOMEM;
	goto failed;
	}

	buffer = kmalloc(card->blocklen, GFP_KERNEL);
	if (!buffer) {
	error = -ENOMEM;
	goto fail_buffer;
	}

	do {
	/* Read in the block we are to write to */
	error = maple_vmu_read_block(vblock->num, buffer, mtd);
	if (error)
	goto fail_io;

	do {
	buffer[vblock->ofs] = buf[index];
	vblock->ofs++;
	index++;
	if (index >= len)
	break;
	} while (vblock->ofs < card->blocklen);

	/* write out new buffer */
	error = maple_vmu_write_block(vblock->num, buffer, mtd);
	/* invalidate the cache */
	pcache = card->parts[partition].pcache;
	pcache->valid = 0;

	if (error != card->blocklen)
	goto fail_io;

	vblock->num++;
	vblock->ofs = 0;
	} while (len > index);

	kfree(buffer);
	*retlen = index;
	kfree(vblock);
	return 0;

	fail_io:
	kfree(buffer);
	fail_buffer:
	kfree(vblock);
	failed:
	dev_err(&mdev->dev, "VMU write failing with error %d\n", error);
	return error;
	}

	static void vmu_flash_sync(struct mtd_info *mtd)
	{
	/* Do nothing here */
	}

	/* Maple bus callback function to recursively query hardware details */
	static void vmu_queryblocks(struct mapleq *mq)
	{
	struct maple_device *mdev;
	unsigned short *res;
	struct memcard *card;
	__be32 partnum;
	struct vmu_cache *pcache;
	struct mdev_part *mpart;
	struct mtd_info *mtd_cur;
	struct vmupart *part_cur;
	int error;

	mdev = mq->dev;
	card = maple_get_drvdata(mdev);
	res = (unsigned short *) (mq->recvbuf->buf);
	card->tempA = res[12];
	card->tempB = res[6];

	dev_info(&mdev->dev, "VMU device at partition %d has %d user "
	"blocks with a root block at %d\n", card->partition,
	card->tempA, card->tempB);

	part_cur = &card->parts[card->partition];
	part_cur->user_blocks = card->tempA;
	part_cur->root_block = card->tempB;
	part_cur->numblocks = card->tempB + 1;
	part_cur->name = kmalloc(12, GFP_KERNEL);
	if (!part_cur->name)
	goto fail_name;

	sprintf(part_cur->name, "vmu%d.%d.%d",
	mdev->port, mdev->unit, card->partition);
	mtd_cur = &card->mtd[card->partition];
	mtd_cur->name = part_cur->name;
	mtd_cur->type = 8;
	mtd_cur->flags = MTD_WRITEABLE\|MTD_NO_ERASE;
	mtd_cur->size = part_cur->numblocks * card->blocklen;
	mtd_cur->erasesize = card->blocklen;
	mtd_cur->_write = vmu_flash_write;
	mtd_cur->_read = vmu_flash_read;
	mtd_cur->_sync = vmu_flash_sync;
	mtd_cur->writesize = card->blocklen;

	mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL);
	if (!mpart)
	goto fail_mpart;

	mpart->mdev = mdev;
	mpart->partition = card->partition;
	mtd_cur->priv = mpart;
	mtd_cur->owner = THIS_MODULE;

	pcache = kzalloc(sizeof(struct vmu_cache), GFP_KERNEL);
	if (!pcache)
	goto fail_cache_create;
	part_cur->pcache = pcache;

	error = mtd_device_register(mtd_cur, NULL, 0);
	if (error)
	goto fail_mtd_register;

	maple_getcond_callback(mdev, NULL, 0,
	MAPLE_FUNC_MEMCARD);

	/*
	* Set up a recursive call to the (probably theoretical)
	* second or more partition
	*/
	if (++card->partition < card->partitions) {
	partnum = cpu_to_be32(card->partition << 24);
	maple_getcond_callback(mdev, vmu_queryblocks, 0,
	MAPLE_FUNC_MEMCARD);
	maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
	MAPLE_COMMAND_GETMINFO, 2, &partnum);
	}
	return;

	fail_mtd_register:
	dev_err(&mdev->dev, "Could not register maple device at (%d, %d)"
	"error is 0x%X\n", mdev->port, mdev->unit, error);
	for (error = 0; error <= card->partition; error++) {
	kfree(((card->parts)[error]).pcache);
	((card->parts)[error]).pcache = NULL;
	}
	fail_cache_create:
	fail_mpart:
	for (error = 0; error <= card->partition; error++) {
	kfree(((card->mtd)[error]).priv);
	((card->mtd)[error]).priv = NULL;
	}
	maple_getcond_callback(mdev, NULL, 0,
	MAPLE_FUNC_MEMCARD);
	kfree(part_cur->name);
	fail_name:
	return;
	}

	/* Handles very basic info about the flash, queries for details */
	static int vmu_connect(struct maple_device *mdev)
	{
	unsigned long test_flash_data, basic_flash_data;
	int c, error;
	struct memcard *card;
	u32 partnum = 0;

	test_flash_data = be32_to_cpu(mdev->devinfo.function);
	/* Need to count how many bits are set - to find out which
	* function_data element has details of the memory card
	*/
	c = hweight_long(test_flash_data);

	basic_flash_data = be32_to_cpu(mdev->devinfo.function_data[c - 1]);

	card = kmalloc(sizeof(struct memcard), GFP_KERNEL);
	if (!card) {
	error = -ENOMEM;
	goto fail_nomem;
	}

	card->partitions = (basic_flash_data >> 24 & 0xFF) + 1;
	card->blocklen = ((basic_flash_data >> 16 & 0xFF) + 1) << 5;
	card->writecnt = basic_flash_data >> 12 & 0xF;
	card->readcnt = basic_flash_data >> 8 & 0xF;
	card->removeable = basic_flash_data >> 7 & 1;

	card->partition = 0;

	/*
	* Not sure there are actually any multi-partition devices in the
	* real world, but the hardware supports them, so, so will we
	*/
	card->parts = kmalloc(sizeof(struct vmupart) * card->partitions,
	GFP_KERNEL);
	if (!card->parts) {
	error = -ENOMEM;
	goto fail_partitions;
	}

	card->mtd = kmalloc(sizeof(struct mtd_info) * card->partitions,
	GFP_KERNEL);
	if (!card->mtd) {
	error = -ENOMEM;
	goto fail_mtd_info;
	}

	maple_set_drvdata(mdev, card);

	/*
	* We want to trap meminfo not get cond
	* so set interval to zero, but rely on maple bus
	* driver to pass back the results of the meminfo
	*/
	maple_getcond_callback(mdev, vmu_queryblocks, 0,
	MAPLE_FUNC_MEMCARD);

	/* Make sure we are clear to go */
	if (atomic_read(&mdev->busy) == 1) {
	wait_event_interruptible_timeout(mdev->maple_wait,
	atomic_read(&mdev->busy) == 0, HZ);
	if (atomic_read(&mdev->busy) == 1) {
	dev_notice(&mdev->dev, "VMU at (%d, %d) is busy\n",
	mdev->port, mdev->unit);
	error = -EAGAIN;
	goto fail_device_busy;
	}
	}

	atomic_set(&mdev->busy, 1);

	/*
	* Set up the minfo call: vmu_queryblocks will handle
	* the information passed back
	*/
	error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
	MAPLE_COMMAND_GETMINFO, 2, &partnum);
	if (error) {
	dev_err(&mdev->dev, "Could not lock VMU at (%d, %d)"
	" error is 0x%X\n", mdev->port, mdev->unit, error);
	goto fail_mtd_info;
	}
	return 0;

	fail_device_busy:
	kfree(card->mtd);
	fail_mtd_info:
	kfree(card->parts);
	fail_partitions:
	kfree(card);
	fail_nomem:
	return error;
	}

	static void vmu_disconnect(struct maple_device *mdev)
	{
	struct memcard *card;
	struct mdev_part *mpart;
	int x;

	mdev->callback = NULL;
	card = maple_get_drvdata(mdev);
	for (x = 0; x < card->partitions; x++) {
	mpart = ((card->mtd)[x]).priv;
	mpart->mdev = NULL;
	mtd_device_unregister(&((card->mtd)[x]));
	kfree(((card->parts)[x]).name);
	}
	kfree(card->parts);
	kfree(card->mtd);
	kfree(card);
	}

	/* Callback to handle eccentricities of both mtd subsystem
	* and general flakyness of Dreamcast VMUs
	*/
	static int vmu_can_unload(struct maple_device *mdev)
	{
	struct memcard *card;
	int x;
	struct mtd_info *mtd;

	card = maple_get_drvdata(mdev);
	for (x = 0; x < card->partitions; x++) {
	mtd = &((card->mtd)[x]);
	if (mtd->usecount > 0)
	return 0;
	}
	return 1;
	}

	#define ERRSTR "VMU at (%d, %d) file error -"

	static void vmu_file_error(struct maple_device mdev, void recvbuf)
	{
	enum maple_file_errors error = ((int *)recvbuf)[1];

	switch (error) {

	case MAPLE_FILEERR_INVALID_PARTITION:
	dev_notice(&mdev->dev, ERRSTR " invalid partition number\n",
	mdev->port, mdev->unit);
	break;

	case MAPLE_FILEERR_PHASE_ERROR:
	dev_notice(&mdev->dev, ERRSTR " phase error\n",
	mdev->port, mdev->unit);
	break;

	case MAPLE_FILEERR_INVALID_BLOCK:
	dev_notice(&mdev->dev, ERRSTR " invalid block number\n",
	mdev->port, mdev->unit);
	break;

	case MAPLE_FILEERR_WRITE_ERROR:
	dev_notice(&mdev->dev, ERRSTR " write error\n",
	mdev->port, mdev->unit);
	break;

	case MAPLE_FILEERR_INVALID_WRITE_LENGTH:
	dev_notice(&mdev->dev, ERRSTR " invalid write length\n",
	mdev->port, mdev->unit);
	break;

	case MAPLE_FILEERR_BAD_CRC:
	dev_notice(&mdev->dev, ERRSTR " bad CRC\n",
	mdev->port, mdev->unit);
	break;

	default:
	dev_notice(&mdev->dev, ERRSTR " 0x%X\n",
	mdev->port, mdev->unit, error);
	}
	}


	static int probe_maple_vmu(struct device *dev)
	{
	int error;
	struct maple_device *mdev = to_maple_dev(dev);
	struct maple_driver *mdrv = to_maple_driver(dev->driver);

	mdev->can_unload = vmu_can_unload;
	mdev->fileerr_handler = vmu_file_error;
	mdev->driver = mdrv;

	error = vmu_connect(mdev);
	if (error)
	return error;

	return 0;
	}

	static int remove_maple_vmu(struct device *dev)
	{
	struct maple_device *mdev = to_maple_dev(dev);

	vmu_disconnect(mdev);
	return 0;
	}

	static struct maple_driver vmu_flash_driver = {
	.function = MAPLE_FUNC_MEMCARD,
	.drv = {
	.name = "Dreamcast_visual_memory",
	.probe = probe_maple_vmu,
	.remove = remove_maple_vmu,
	},
	};

	static int __init vmu_flash_map_init(void)
	{
	return maple_driver_register(&vmu_flash_driver);
	}

	static void __exit vmu_flash_map_exit(void)
	{
	maple_driver_unregister(&vmu_flash_driver);
	}

	module_init(vmu_flash_map_init);
	module_exit(vmu_flash_map_exit);

	MODULE_LICENSE("GPL");
	MODULE_AUTHOR("Adrian McMenamin");
	MODULE_DESCRIPTION("Flash mapping for Sega Dreamcast visual memory");