[mirror_ubuntu-hirsute-kernel.git] / drivers / mtd / mtdpart.c

/*
 * Simple MTD partitioning layer
 *
 * (C) 2000 Nicolas Pitre <nico@cam.org>
 *
 * This code is GPL
 *
 * 	02-21-2002	Thomas Gleixner <gleixner@autronix.de>
 *			added support for read_oob, write_oob
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/kmod.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/compatmac.h>

/* Our partition linked list */
static LIST_HEAD(mtd_partitions);

/* Our partition node structure */
struct mtd_part {
	struct mtd_info mtd;
	struct mtd_info *master;
	u_int32_t offset;
	int index;
	struct list_head list;
	int registered;
};

/*
 * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
 * the pointer to that structure with this macro.
 */
#define PART(x)  ((struct mtd_part *)(x))


/*
 * MTD methods which simply translate the effective address and pass through
 * to the _real_ device.
 */

static int part_read (struct mtd_info *mtd, loff_t from, size_t len,
			size_t *retlen, u_char *buf)
{
	struct mtd_part *part = PART(mtd);
	int res;

	if (from >= mtd->size)
		len = 0;
	else if (from + len > mtd->size)
		len = mtd->size - from;
	res = part->master->read (part->master, from + part->offset,
				   len, retlen, buf);
	if (unlikely(res)) {
		if (res == -EUCLEAN)
			mtd->ecc_stats.corrected++;
		if (res == -EBADMSG)
			mtd->ecc_stats.failed++;
	}
	return res;
}

static int part_point (struct mtd_info *mtd, loff_t from, size_t len,
			size_t *retlen, void **virt, resource_size_t *phys)
{
	struct mtd_part *part = PART(mtd);
	if (from >= mtd->size)
		len = 0;
	else if (from + len > mtd->size)
		len = mtd->size - from;
	return part->master->point (part->master, from + part->offset,
				    len, retlen, virt, phys);
}

static void part_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
{
	struct mtd_part *part = PART(mtd);

	part->master->unpoint(part->master, from + part->offset, len);
}

static int part_read_oob(struct mtd_info *mtd, loff_t from,
			 struct mtd_oob_ops *ops)
{
	struct mtd_part *part = PART(mtd);
	int res;

	if (from >= mtd->size)
		return -EINVAL;
	if (ops->datbuf && from + ops->len > mtd->size)
		return -EINVAL;
	res = part->master->read_oob(part->master, from + part->offset, ops);

	if (unlikely(res)) {
		if (res == -EUCLEAN)
			mtd->ecc_stats.corrected++;
		if (res == -EBADMSG)
			mtd->ecc_stats.failed++;
	}
	return res;
}

static int part_read_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
			size_t *retlen, u_char *buf)
{
	struct mtd_part *part = PART(mtd);
	return part->master->read_user_prot_reg (part->master, from,
					len, retlen, buf);
}

static int part_get_user_prot_info (struct mtd_info *mtd,
				    struct otp_info *buf, size_t len)
{
	struct mtd_part *part = PART(mtd);
	return part->master->get_user_prot_info (part->master, buf, len);
}

static int part_read_fact_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
			size_t *retlen, u_char *buf)
{
	struct mtd_part *part = PART(mtd);
	return part->master->read_fact_prot_reg (part->master, from,
					len, retlen, buf);
}

static int part_get_fact_prot_info (struct mtd_info *mtd,
				    struct otp_info *buf, size_t len)
{
	struct mtd_part *part = PART(mtd);
	return part->master->get_fact_prot_info (part->master, buf, len);
}

static int part_write (struct mtd_info *mtd, loff_t to, size_t len,
			size_t *retlen, const u_char *buf)
{
	struct mtd_part *part = PART(mtd);
	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;
	if (to >= mtd->size)
		len = 0;
	else if (to + len > mtd->size)
		len = mtd->size - to;
	return part->master->write (part->master, to + part->offset,
				    len, retlen, buf);
}

static int part_panic_write (struct mtd_info *mtd, loff_t to, size_t len,
			size_t *retlen, const u_char *buf)
{
	struct mtd_part *part = PART(mtd);
	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;
	if (to >= mtd->size)
		len = 0;
	else if (to + len > mtd->size)
		len = mtd->size - to;
	return part->master->panic_write (part->master, to + part->offset,
				    len, retlen, buf);
}

static int part_write_oob(struct mtd_info *mtd, loff_t to,
			 struct mtd_oob_ops *ops)
{
	struct mtd_part *part = PART(mtd);

	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;

	if (to >= mtd->size)
		return -EINVAL;
	if (ops->datbuf && to + ops->len > mtd->size)
		return -EINVAL;
	return part->master->write_oob(part->master, to + part->offset, ops);
}

static int part_write_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
			size_t *retlen, u_char *buf)
{
	struct mtd_part *part = PART(mtd);
	return part->master->write_user_prot_reg (part->master, from,
					len, retlen, buf);
}

static int part_lock_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len)
{
	struct mtd_part *part = PART(mtd);
	return part->master->lock_user_prot_reg (part->master, from, len);
}

static int part_writev (struct mtd_info *mtd,  const struct kvec *vecs,
			 unsigned long count, loff_t to, size_t *retlen)
{
	struct mtd_part *part = PART(mtd);
	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;
	return part->master->writev (part->master, vecs, count,
					to + part->offset, retlen);
}

static int part_erase (struct mtd_info *mtd, struct erase_info *instr)
{
	struct mtd_part *part = PART(mtd);
	int ret;
	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;
	if (instr->addr >= mtd->size)
		return -EINVAL;
	instr->addr += part->offset;
	ret = part->master->erase(part->master, instr);
	if (ret) {
		if (instr->fail_addr != 0xffffffff)
			instr->fail_addr -= part->offset;
		instr->addr -= part->offset;
	}
	return ret;
}

void mtd_erase_callback(struct erase_info *instr)
{
	if (instr->mtd->erase == part_erase) {
		struct mtd_part *part = PART(instr->mtd);

		if (instr->fail_addr != 0xffffffff)
			instr->fail_addr -= part->offset;
		instr->addr -= part->offset;
	}
	if (instr->callback)
		instr->callback(instr);
}
EXPORT_SYMBOL_GPL(mtd_erase_callback);

static int part_lock (struct mtd_info *mtd, loff_t ofs, size_t len)
{
	struct mtd_part *part = PART(mtd);
	if ((len + ofs) > mtd->size)
		return -EINVAL;
	return part->master->lock(part->master, ofs + part->offset, len);
}

static int part_unlock (struct mtd_info *mtd, loff_t ofs, size_t len)
{
	struct mtd_part *part = PART(mtd);
	if ((len + ofs) > mtd->size)
		return -EINVAL;
	return part->master->unlock(part->master, ofs + part->offset, len);
}

static void part_sync(struct mtd_info *mtd)
{
	struct mtd_part *part = PART(mtd);
	part->master->sync(part->master);
}

static int part_suspend(struct mtd_info *mtd)
{
	struct mtd_part *part = PART(mtd);
	return part->master->suspend(part->master);
}

static void part_resume(struct mtd_info *mtd)
{
	struct mtd_part *part = PART(mtd);
	part->master->resume(part->master);
}

static int part_block_isbad (struct mtd_info *mtd, loff_t ofs)
{
	struct mtd_part *part = PART(mtd);
	if (ofs >= mtd->size)
		return -EINVAL;
	ofs += part->offset;
	return part->master->block_isbad(part->master, ofs);
}

static int part_block_markbad (struct mtd_info *mtd, loff_t ofs)
{
	struct mtd_part *part = PART(mtd);
	int res;

	if (!(mtd->flags & MTD_WRITEABLE))
		return -EROFS;
	if (ofs >= mtd->size)
		return -EINVAL;
	ofs += part->offset;
	res = part->master->block_markbad(part->master, ofs);
	if (!res)
		mtd->ecc_stats.badblocks++;
	return res;
}

/*
 * This function unregisters and destroy all slave MTD objects which are
 * attached to the given master MTD object.
 */

int del_mtd_partitions(struct mtd_info *master)
{
	struct mtd_part *slave, *next;

	list_for_each_entry_safe(slave, next, &mtd_partitions, list)
		if (slave->master == master) {
			list_del(&slave->list);
			if(slave->registered)
				del_mtd_device(&slave->mtd);
			kfree(slave);
		}

	return 0;
}

static struct mtd_part *add_one_partition(struct mtd_info *master,
		const struct mtd_partition *part, int partno,
		u_int32_t cur_offset)
{
	struct mtd_part *slave;

	/* allocate the partition structure */
	slave = kzalloc (sizeof(*slave), GFP_KERNEL);
	if (!slave) {
		printk("memory allocation error while creating partitions for \"%s\"\n",
			master->name);
		del_mtd_partitions(master);
		return NULL;
	}
	list_add(&slave->list, &mtd_partitions);

	/* set up the MTD object for this partition */
	slave->mtd.type = master->type;
	slave->mtd.flags = master->flags & ~part->mask_flags;
	slave->mtd.size = part->size;
	slave->mtd.writesize = master->writesize;
	slave->mtd.oobsize = master->oobsize;
	slave->mtd.oobavail = master->oobavail;
	slave->mtd.subpage_sft = master->subpage_sft;

	slave->mtd.name = part->name;
	slave->mtd.owner = master->owner;

	slave->mtd.read = part_read;
	slave->mtd.write = part_write;

	if (master->panic_write)
		slave->mtd.panic_write = part_panic_write;

	if(master->point && master->unpoint){
		slave->mtd.point = part_point;
		slave->mtd.unpoint = part_unpoint;
	}

	if (master->read_oob)
		slave->mtd.read_oob = part_read_oob;
	if (master->write_oob)
		slave->mtd.write_oob = part_write_oob;
	if(master->read_user_prot_reg)
		slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
	if(master->read_fact_prot_reg)
		slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
	if(master->write_user_prot_reg)
		slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
	if(master->lock_user_prot_reg)
		slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
	if(master->get_user_prot_info)
		slave->mtd.get_user_prot_info = part_get_user_prot_info;
	if(master->get_fact_prot_info)
		slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
	if (master->sync)
		slave->mtd.sync = part_sync;
	if (!partno && master->suspend && master->resume) {
			slave->mtd.suspend = part_suspend;
			slave->mtd.resume = part_resume;
	}
	if (master->writev)
		slave->mtd.writev = part_writev;
	if (master->lock)
		slave->mtd.lock = part_lock;
	if (master->unlock)
		slave->mtd.unlock = part_unlock;
	if (master->block_isbad)
		slave->mtd.block_isbad = part_block_isbad;
	if (master->block_markbad)
		slave->mtd.block_markbad = part_block_markbad;
	slave->mtd.erase = part_erase;
	slave->master = master;
	slave->offset = part->offset;
	slave->index = partno;

	if (slave->offset == MTDPART_OFS_APPEND)
		slave->offset = cur_offset;
	if (slave->offset == MTDPART_OFS_NXTBLK) {
		slave->offset = cur_offset;
		if ((cur_offset % master->erasesize) != 0) {
			/* Round up to next erasesize */
			slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
			printk(KERN_NOTICE "Moving partition %d: "
			       "0x%08x -> 0x%08x\n", partno,
			       cur_offset, slave->offset);
		}
	}
	if (slave->mtd.size == MTDPART_SIZ_FULL)
		slave->mtd.size = master->size - slave->offset;

	printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
		slave->offset + slave->mtd.size, slave->mtd.name);

	/* let's do some sanity checks */
	if (slave->offset >= master->size) {
			/* let's register it anyway to preserve ordering */
		slave->offset = 0;
		slave->mtd.size = 0;
		printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
			part->name);
	}
	if (slave->offset + slave->mtd.size > master->size) {
		slave->mtd.size = master->size - slave->offset;
		printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
			part->name, master->name, slave->mtd.size);
	}
	if (master->numeraseregions>1) {
		/* Deal with variable erase size stuff */
		int i;
		struct mtd_erase_region_info *regions = master->eraseregions;

		/* Find the first erase regions which is part of this partition. */
		for (i=0; i < master->numeraseregions && regions[i].offset <= slave->offset; i++)
			;

		for (i--; i < master->numeraseregions && regions[i].offset < slave->offset + slave->mtd.size; i++) {
			if (slave->mtd.erasesize < regions[i].erasesize) {
				slave->mtd.erasesize = regions[i].erasesize;
			}
		}
	} else {
		/* Single erase size */
		slave->mtd.erasesize = master->erasesize;
	}

	if ((slave->mtd.flags & MTD_WRITEABLE) &&
	    (slave->offset % slave->mtd.erasesize)) {
		/* Doesn't start on a boundary of major erase size */
		/* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
		slave->mtd.flags &= ~MTD_WRITEABLE;
		printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
			part->name);
	}
	if ((slave->mtd.flags & MTD_WRITEABLE) &&
	    (slave->mtd.size % slave->mtd.erasesize)) {
		slave->mtd.flags &= ~MTD_WRITEABLE;
		printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
			part->name);
	}

	slave->mtd.ecclayout = master->ecclayout;
	if (master->block_isbad) {
		uint32_t offs = 0;

		while(offs < slave->mtd.size) {
			if (master->block_isbad(master,
						offs + slave->offset))
				slave->mtd.ecc_stats.badblocks++;
			offs += slave->mtd.erasesize;
		}
	}

	if(part->mtdp) {	/* store the object pointer (caller may or may not register it */
		*part->mtdp = &slave->mtd;
		slave->registered = 0;
	} else {
		/* register our partition */
		add_mtd_device(&slave->mtd);
		slave->registered = 1;
	}
	return slave;
}

/*
 * This function, given a master MTD object and a partition table, creates
 * and registers slave MTD objects which are bound to the master according to
 * the partition definitions.
 * (Q: should we register the master MTD object as well?)
 */

int add_mtd_partitions(struct mtd_info *master,
		       const struct mtd_partition *parts,
		       int nbparts)
{
	struct mtd_part *slave;
	u_int32_t cur_offset = 0;
	int i;

	printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);

	for (i = 0; i < nbparts; i++) {
		slave = add_one_partition(master, parts + i, i, cur_offset);
		if (!slave)
			return -ENOMEM;
		cur_offset = slave->offset + slave->mtd.size;
	}

	return 0;
}

EXPORT_SYMBOL(add_mtd_partitions);
EXPORT_SYMBOL(del_mtd_partitions);

static DEFINE_SPINLOCK(part_parser_lock);
static LIST_HEAD(part_parsers);

static struct mtd_part_parser *get_partition_parser(const char *name)
{
	struct mtd_part_parser *p, *ret = NULL;

	spin_lock(&part_parser_lock);

	list_for_each_entry(p, &part_parsers, list)
		if (!strcmp(p->name, name) && try_module_get(p->owner)) {
			ret = p;
			break;
		}

	spin_unlock(&part_parser_lock);

	return ret;
}

int register_mtd_parser(struct mtd_part_parser *p)
{
	spin_lock(&part_parser_lock);
	list_add(&p->list, &part_parsers);
	spin_unlock(&part_parser_lock);

	return 0;
}

int deregister_mtd_parser(struct mtd_part_parser *p)
{
	spin_lock(&part_parser_lock);
	list_del(&p->list);
	spin_unlock(&part_parser_lock);
	return 0;
}

int parse_mtd_partitions(struct mtd_info *master, const char **types,
			 struct mtd_partition **pparts, unsigned long origin)
{
	struct mtd_part_parser *parser;
	int ret = 0;

	for ( ; ret <= 0 && *types; types++) {
		parser = get_partition_parser(*types);
#ifdef CONFIG_KMOD
		if (!parser && !request_module("%s", *types))
				parser = get_partition_parser(*types);
#endif
		if (!parser) {
			printk(KERN_NOTICE "%s partition parsing not available\n",
			       *types);
			continue;
		}
		ret = (*parser->parse_fn)(master, pparts, origin);
		if (ret > 0) {
			printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
			       ret, parser->name, master->name);
		}
		put_partition_parser(parser);
	}
	return ret;
}

EXPORT_SYMBOL_GPL(parse_mtd_partitions);
EXPORT_SYMBOL_GPL(register_mtd_parser);
EXPORT_SYMBOL_GPL(deregister_mtd_parser);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Simple MTD partitioning layer
	3	*
	4	* (C) 2000 Nicolas Pitre <nico@cam.org>
	5	*
	6	* This code is GPL
	7	*
1da177e4 LT	8	* 02-21-2002 Thomas Gleixner <gleixner@autronix.de>
1da177e4 LT	9	* added support for read_oob, write_oob
97894cda	10	*/
1da177e4 LT	11
	12	#include <linux/module.h>
	13	#include <linux/types.h>
	14	#include <linux/kernel.h>
	15	#include <linux/slab.h>
	16	#include <linux/list.h>
1da177e4 LT	17	#include <linux/kmod.h>
	18	#include <linux/mtd/mtd.h>
	19	#include <linux/mtd/partitions.h>
	20	#include <linux/mtd/compatmac.h>
	21
	22	/* Our partition linked list */
	23	static LIST_HEAD(mtd_partitions);
	24
	25	/* Our partition node structure */
	26	struct mtd_part {
	27	struct mtd_info mtd;
	28	struct mtd_info *master;
	29	u_int32_t offset;
	30	int index;
	31	struct list_head list;
	32	int registered;
	33	};
	34
	35	/*
	36	* Given a pointer to the MTD object in the mtd_part structure, we can retrieve
	37	* the pointer to that structure with this macro.
	38	*/
	39	#define PART(x) ((struct mtd_part *)(x))
	40
97894cda TG	41
97894cda TG	42	/*
1da177e4 LT	43	* MTD methods which simply translate the effective address and pass through
	44	* to the _real_ device.
	45	*/
	46
97894cda	47	static int part_read (struct mtd_info *mtd, loff_t from, size_t len,
1da177e4 LT	48	size_t retlen, u_char buf)
	49	{
	50	struct mtd_part *part = PART(mtd);
f1a28c02 TG	51	int res;
f1a28c02 TG	52
1da177e4 LT	53	if (from >= mtd->size)
	54	len = 0;
	55	else if (from + len > mtd->size)
	56	len = mtd->size - from;
f1a28c02	57	res = part->master->read (part->master, from + part->offset,
9223a456	58	len, retlen, buf);
f1a28c02 TG	59	if (unlikely(res)) {
	60	if (res == -EUCLEAN)
	61	mtd->ecc_stats.corrected++;
	62	if (res == -EBADMSG)
	63	mtd->ecc_stats.failed++;
	64	}
	65	return res;
1da177e4 LT	66	}
1da177e4 LT	67
97894cda	68	static int part_point (struct mtd_info *mtd, loff_t from, size_t len,
a98889f3	69	size_t retlen, void virt, resource_size_t phys)
1da177e4 LT	70	{
	71	struct mtd_part *part = PART(mtd);
	72	if (from >= mtd->size)
	73	len = 0;
	74	else if (from + len > mtd->size)
	75	len = mtd->size - from;
97894cda	76	return part->master->point (part->master, from + part->offset,
a98889f3	77	len, retlen, virt, phys);
1da177e4	78	}
9223a456	79
a98889f3	80	static void part_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1da177e4 LT	81	{
	82	struct mtd_part *part = PART(mtd);
	83
a98889f3	84	part->master->unpoint(part->master, from + part->offset, len);
1da177e4 LT	85	}
1da177e4 LT	86
8593fbc6 TG	87	static int part_read_oob(struct mtd_info *mtd, loff_t from,
8593fbc6 TG	88	struct mtd_oob_ops *ops)
1da177e4 LT	89	{
1da177e4 LT	90	struct mtd_part *part = PART(mtd);
f1a28c02	91	int res;
8593fbc6	92
1da177e4	93	if (from >= mtd->size)
8593fbc6	94	return -EINVAL;
7014568b	95	if (ops->datbuf && from + ops->len > mtd->size)
8593fbc6	96	return -EINVAL;
f1a28c02 TG	97	res = part->master->read_oob(part->master, from + part->offset, ops);
	98
	99	if (unlikely(res)) {
	100	if (res == -EUCLEAN)
	101	mtd->ecc_stats.corrected++;
	102	if (res == -EBADMSG)
	103	mtd->ecc_stats.failed++;
	104	}
	105	return res;
1da177e4 LT	106	}
1da177e4 LT	107
97894cda	108	static int part_read_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
1da177e4 LT	109	size_t retlen, u_char buf)
	110	{
	111	struct mtd_part *part = PART(mtd);
97894cda	112	return part->master->read_user_prot_reg (part->master, from,
1da177e4 LT	113	len, retlen, buf);
	114	}
	115
f77814dd NP	116	static int part_get_user_prot_info (struct mtd_info *mtd,
	117	struct otp_info *buf, size_t len)
	118	{
	119	struct mtd_part *part = PART(mtd);
	120	return part->master->get_user_prot_info (part->master, buf, len);
	121	}
	122
97894cda	123	static int part_read_fact_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
1da177e4 LT	124	size_t retlen, u_char buf)
	125	{
	126	struct mtd_part *part = PART(mtd);
97894cda	127	return part->master->read_fact_prot_reg (part->master, from,
1da177e4 LT	128	len, retlen, buf);
	129	}
	130
f77814dd NP	131	static int part_get_fact_prot_info (struct mtd_info *mtd,
	132	struct otp_info *buf, size_t len)
	133	{
	134	struct mtd_part *part = PART(mtd);
	135	return part->master->get_fact_prot_info (part->master, buf, len);
	136	}
	137
1da177e4 LT	138	static int part_write (struct mtd_info *mtd, loff_t to, size_t len,
	139	size_t retlen, const u_char buf)
	140	{
	141	struct mtd_part *part = PART(mtd);
	142	if (!(mtd->flags & MTD_WRITEABLE))
	143	return -EROFS;
	144	if (to >= mtd->size)
	145	len = 0;
	146	else if (to + len > mtd->size)
	147	len = mtd->size - to;
9223a456 TG	148	return part->master->write (part->master, to + part->offset,
9223a456 TG	149	len, retlen, buf);
1da177e4 LT	150	}
1da177e4 LT	151
388bbb09 RP	152	static int part_panic_write (struct mtd_info *mtd, loff_t to, size_t len,
	153	size_t retlen, const u_char buf)
	154	{
	155	struct mtd_part *part = PART(mtd);
	156	if (!(mtd->flags & MTD_WRITEABLE))
	157	return -EROFS;
	158	if (to >= mtd->size)
	159	len = 0;
	160	else if (to + len > mtd->size)
	161	len = mtd->size - to;
	162	return part->master->panic_write (part->master, to + part->offset,
	163	len, retlen, buf);
	164	}
	165
8593fbc6 TG	166	static int part_write_oob(struct mtd_info *mtd, loff_t to,
8593fbc6 TG	167	struct mtd_oob_ops *ops)
1da177e4 LT	168	{
1da177e4 LT	169	struct mtd_part *part = PART(mtd);
8593fbc6	170
1da177e4 LT	171	if (!(mtd->flags & MTD_WRITEABLE))
1da177e4 LT	172	return -EROFS;
8593fbc6	173
1da177e4	174	if (to >= mtd->size)
8593fbc6	175	return -EINVAL;
7014568b	176	if (ops->datbuf && to + ops->len > mtd->size)
8593fbc6 TG	177	return -EINVAL;
8593fbc6 TG	178	return part->master->write_oob(part->master, to + part->offset, ops);
1da177e4 LT	179	}
1da177e4 LT	180
97894cda	181	static int part_write_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
1da177e4 LT	182	size_t retlen, u_char buf)
	183	{
	184	struct mtd_part *part = PART(mtd);
97894cda	185	return part->master->write_user_prot_reg (part->master, from,
1da177e4 LT	186	len, retlen, buf);
	187	}
	188
97894cda	189	static int part_lock_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len)
f77814dd NP	190	{
	191	struct mtd_part *part = PART(mtd);
	192	return part->master->lock_user_prot_reg (part->master, from, len);
	193	}
	194
1da177e4 LT	195	static int part_writev (struct mtd_info mtd, const struct kvec vecs,
	196	unsigned long count, loff_t to, size_t *retlen)
	197	{
	198	struct mtd_part *part = PART(mtd);
	199	if (!(mtd->flags & MTD_WRITEABLE))
	200	return -EROFS;
9d8522df	201	return part->master->writev (part->master, vecs, count,
1da177e4	202	to + part->offset, retlen);
1da177e4 LT	203	}
1da177e4 LT	204
1da177e4 LT	205	static int part_erase (struct mtd_info mtd, struct erase_info instr)
	206	{
	207	struct mtd_part *part = PART(mtd);
	208	int ret;
	209	if (!(mtd->flags & MTD_WRITEABLE))
	210	return -EROFS;
	211	if (instr->addr >= mtd->size)
	212	return -EINVAL;
	213	instr->addr += part->offset;
	214	ret = part->master->erase(part->master, instr);
74641d75 AH	215	if (ret) {
	216	if (instr->fail_addr != 0xffffffff)
	217	instr->fail_addr -= part->offset;
	218	instr->addr -= part->offset;
	219	}
1da177e4 LT	220	return ret;
	221	}
	222
	223	void mtd_erase_callback(struct erase_info *instr)
	224	{
	225	if (instr->mtd->erase == part_erase) {
	226	struct mtd_part *part = PART(instr->mtd);
	227
	228	if (instr->fail_addr != 0xffffffff)
	229	instr->fail_addr -= part->offset;
	230	instr->addr -= part->offset;
	231	}
	232	if (instr->callback)
	233	instr->callback(instr);
	234	}
	235	EXPORT_SYMBOL_GPL(mtd_erase_callback);
	236
	237	static int part_lock (struct mtd_info *mtd, loff_t ofs, size_t len)
	238	{
	239	struct mtd_part *part = PART(mtd);
97894cda	240	if ((len + ofs) > mtd->size)
1da177e4 LT	241	return -EINVAL;
	242	return part->master->lock(part->master, ofs + part->offset, len);
	243	}
	244
	245	static int part_unlock (struct mtd_info *mtd, loff_t ofs, size_t len)
	246	{
	247	struct mtd_part *part = PART(mtd);
97894cda	248	if ((len + ofs) > mtd->size)
1da177e4 LT	249	return -EINVAL;
	250	return part->master->unlock(part->master, ofs + part->offset, len);
	251	}
	252
	253	static void part_sync(struct mtd_info *mtd)
	254	{
	255	struct mtd_part *part = PART(mtd);
	256	part->master->sync(part->master);
	257	}
	258
	259	static int part_suspend(struct mtd_info *mtd)
	260	{
	261	struct mtd_part *part = PART(mtd);
	262	return part->master->suspend(part->master);
	263	}
	264
	265	static void part_resume(struct mtd_info *mtd)
	266	{
	267	struct mtd_part *part = PART(mtd);
	268	part->master->resume(part->master);
	269	}
	270
	271	static int part_block_isbad (struct mtd_info *mtd, loff_t ofs)
	272	{
	273	struct mtd_part *part = PART(mtd);
	274	if (ofs >= mtd->size)
	275	return -EINVAL;
	276	ofs += part->offset;
	277	return part->master->block_isbad(part->master, ofs);
	278	}
	279
	280	static int part_block_markbad (struct mtd_info *mtd, loff_t ofs)
	281	{
	282	struct mtd_part *part = PART(mtd);
f1a28c02 TG	283	int res;
f1a28c02 TG	284
1da177e4 LT	285	if (!(mtd->flags & MTD_WRITEABLE))
	286	return -EROFS;
	287	if (ofs >= mtd->size)
	288	return -EINVAL;
	289	ofs += part->offset;
f1a28c02 TG	290	res = part->master->block_markbad(part->master, ofs);
	291	if (!res)
	292	mtd->ecc_stats.badblocks++;
	293	return res;
1da177e4 LT	294	}
1da177e4 LT	295
97894cda TG	296	/*
97894cda TG	297	* This function unregisters and destroy all slave MTD objects which are
1da177e4 LT	298	* attached to the given master MTD object.
	299	*/
	300
	301	int del_mtd_partitions(struct mtd_info *master)
	302	{
71a928c0	303	struct mtd_part slave, next;
1da177e4	304
71a928c0	305	list_for_each_entry_safe(slave, next, &mtd_partitions, list)
1da177e4	306	if (slave->master == master) {
71a928c0	307	list_del(&slave->list);
1da177e4 LT	308	if(slave->registered)
	309	del_mtd_device(&slave->mtd);
	310	kfree(slave);
1da177e4	311	}
1da177e4 LT	312
	313	return 0;
	314	}
	315
7788ba71 AN	316	static struct mtd_part add_one_partition(struct mtd_info master,
	317	const struct mtd_partition *part, int partno,
	318	u_int32_t cur_offset)
	319	{
	320	struct mtd_part *slave;
	321
	322	/* allocate the partition structure */
	323	slave = kzalloc (sizeof(*slave), GFP_KERNEL);
	324	if (!slave) {
	325	printk("memory allocation error while creating partitions for \"%s\"\n",
	326	master->name);
	327	del_mtd_partitions(master);
	328	return NULL;
	329	}
	330	list_add(&slave->list, &mtd_partitions);
	331
	332	/* set up the MTD object for this partition */
	333	slave->mtd.type = master->type;
	334	slave->mtd.flags = master->flags & ~part->mask_flags;
	335	slave->mtd.size = part->size;
	336	slave->mtd.writesize = master->writesize;
	337	slave->mtd.oobsize = master->oobsize;
	338	slave->mtd.oobavail = master->oobavail;
	339	slave->mtd.subpage_sft = master->subpage_sft;
	340
	341	slave->mtd.name = part->name;
	342	slave->mtd.owner = master->owner;
	343
	344	slave->mtd.read = part_read;
	345	slave->mtd.write = part_write;
	346
	347	if (master->panic_write)
	348	slave->mtd.panic_write = part_panic_write;
	349
	350	if(master->point && master->unpoint){
	351	slave->mtd.point = part_point;
	352	slave->mtd.unpoint = part_unpoint;
	353	}
	354
	355	if (master->read_oob)
	356	slave->mtd.read_oob = part_read_oob;
	357	if (master->write_oob)
	358	slave->mtd.write_oob = part_write_oob;
	359	if(master->read_user_prot_reg)
	360	slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
	361	if(master->read_fact_prot_reg)
	362	slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
	363	if(master->write_user_prot_reg)
	364	slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
	365	if(master->lock_user_prot_reg)
	366	slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
	367	if(master->get_user_prot_info)
	368	slave->mtd.get_user_prot_info = part_get_user_prot_info;
	369	if(master->get_fact_prot_info)
	370	slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
	371	if (master->sync)
	372	slave->mtd.sync = part_sync;
	373	if (!partno && master->suspend && master->resume) {
	374	slave->mtd.suspend = part_suspend;
	375	slave->mtd.resume = part_resume;
	376	}
	377	if (master->writev)
	378	slave->mtd.writev = part_writev;
	379	if (master->lock)
380	slave->mtd.lock = part_lock;
381	if (master->unlock)
382	slave->mtd.unlock = part_unlock;
383	if (master->block_isbad)
384	slave->mtd.block_isbad = part_block_isbad;
385	if (master->block_markbad)
386	slave->mtd.block_markbad = part_block_markbad;
387	slave->mtd.erase = part_erase;
388	slave->master = master;
389	slave->offset = part->offset;
390	slave->index = partno;
391
392	if (slave->offset == MTDPART_OFS_APPEND)
393	slave->offset = cur_offset;
394	if (slave->offset == MTDPART_OFS_NXTBLK) {
395	slave->offset = cur_offset;
396	if ((cur_offset % master->erasesize) != 0) {
397	/* Round up to next erasesize */
398	slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
399	printk(KERN_NOTICE "Moving partition %d: "
400	"0x%08x -> 0x%08x\n", partno,
401	cur_offset, slave->offset);
402	}
403	}
404	if (slave->mtd.size == MTDPART_SIZ_FULL)
405	slave->mtd.size = master->size - slave->offset;
406
407	printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
408	slave->offset + slave->mtd.size, slave->mtd.name);
409
410	/* let's do some sanity checks */
411	if (slave->offset >= master->size) {
412	/* let's register it anyway to preserve ordering */
413	slave->offset = 0;
414	slave->mtd.size = 0;
415	printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
416	part->name);
417	}
418	if (slave->offset + slave->mtd.size > master->size) {
419	slave->mtd.size = master->size - slave->offset;
420	printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
421	part->name, master->name, slave->mtd.size);
422	}
423	if (master->numeraseregions>1) {
424	/* Deal with variable erase size stuff */
425	int i;
426	struct mtd_erase_region_info *regions = master->eraseregions;
427
428	/* Find the first erase regions which is part of this partition. */
429	for (i=0; i < master->numeraseregions && regions[i].offset <= slave->offset; i++)
430	;
431
432	for (i--; i < master->numeraseregions && regions[i].offset < slave->offset + slave->mtd.size; i++) {
433	if (slave->mtd.erasesize < regions[i].erasesize) {
434	slave->mtd.erasesize = regions[i].erasesize;
435	}
436	}
437	} else {
438	/* Single erase size */
439	slave->mtd.erasesize = master->erasesize;
440	}
441
442	if ((slave->mtd.flags & MTD_WRITEABLE) &&
443	(slave->offset % slave->mtd.erasesize)) {
444	/* Doesn't start on a boundary of major erase size */
445	/* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
446	slave->mtd.flags &= ~MTD_WRITEABLE;
447	printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
448	part->name);
449	}
450	if ((slave->mtd.flags & MTD_WRITEABLE) &&
451	(slave->mtd.size % slave->mtd.erasesize)) {
452	slave->mtd.flags &= ~MTD_WRITEABLE;
453	printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
454	part->name);
455	}
456
457	slave->mtd.ecclayout = master->ecclayout;
458	if (master->block_isbad) {
459	uint32_t offs = 0;
460
461	while(offs < slave->mtd.size) {
462	if (master->block_isbad(master,
463	offs + slave->offset))
464	slave->mtd.ecc_stats.badblocks++;
465	offs += slave->mtd.erasesize;
466	}
467	}
468
469	if(part->mtdp) { /* store the object pointer (caller may or may not register it */
470	*part->mtdp = &slave->mtd;
471	slave->registered = 0;
472	} else {
473	/* register our partition */
474	add_mtd_device(&slave->mtd);
475	slave->registered = 1;
476	}
477	return slave;
478	}
479
1da177e4 LT	480	/*
	481	* This function, given a master MTD object and a partition table, creates
	482	* and registers slave MTD objects which are bound to the master according to
	483	* the partition definitions.
	484	* (Q: should we register the master MTD object as well?)
	485	*/
	486
97894cda	487	int add_mtd_partitions(struct mtd_info *master,
1da177e4 LT	488	const struct mtd_partition *parts,
	489	int nbparts)
	490	{
	491	struct mtd_part *slave;
	492	u_int32_t cur_offset = 0;
	493	int i;
	494
	495	printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
	496
	497	for (i = 0; i < nbparts; i++) {
7788ba71 AN	498	slave = add_one_partition(master, parts + i, i, cur_offset);
7788ba71 AN	499	if (!slave)
1da177e4	500	return -ENOMEM;
1da177e4	501	cur_offset = slave->offset + slave->mtd.size;
1da177e4 LT	502	}
	503
	504	return 0;
	505	}
	506
	507	EXPORT_SYMBOL(add_mtd_partitions);
	508	EXPORT_SYMBOL(del_mtd_partitions);
	509
	510	static DEFINE_SPINLOCK(part_parser_lock);
	511	static LIST_HEAD(part_parsers);
	512
	513	static struct mtd_part_parser get_partition_parser(const char name)
	514	{
71a928c0	515	struct mtd_part_parser p, ret = NULL;
1da177e4	516
71a928c0	517	spin_lock(&part_parser_lock);
1da177e4	518
71a928c0	519	list_for_each_entry(p, &part_parsers, list)
1da177e4 LT	520	if (!strcmp(p->name, name) && try_module_get(p->owner)) {
	521	ret = p;
	522	break;
	523	}
71a928c0	524
1da177e4 LT	525	spin_unlock(&part_parser_lock);
	526
	527	return ret;
	528	}
	529
	530	int register_mtd_parser(struct mtd_part_parser *p)
	531	{
	532	spin_lock(&part_parser_lock);
	533	list_add(&p->list, &part_parsers);
	534	spin_unlock(&part_parser_lock);
	535
	536	return 0;
	537	}
	538
	539	int deregister_mtd_parser(struct mtd_part_parser *p)
	540	{
	541	spin_lock(&part_parser_lock);
	542	list_del(&p->list);
	543	spin_unlock(&part_parser_lock);
	544	return 0;
	545	}
	546
97894cda	547	int parse_mtd_partitions(struct mtd_info master, const char *types,
1da177e4 LT	548	struct mtd_partition **pparts, unsigned long origin)
	549	{
	550	struct mtd_part_parser *parser;
	551	int ret = 0;
97894cda	552
1da177e4 LT	553	for ( ; ret <= 0 && *types; types++) {
	554	parser = get_partition_parser(*types);
	555	#ifdef CONFIG_KMOD
	556	if (!parser && !request_module("%s", *types))
	557	parser = get_partition_parser(*types);
	558	#endif
	559	if (!parser) {
	560	printk(KERN_NOTICE "%s partition parsing not available\n",
	561	*types);
	562	continue;
	563	}
	564	ret = (*parser->parse_fn)(master, pparts, origin);
	565	if (ret > 0) {
97894cda	566	printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
1da177e4 LT	567	ret, parser->name, master->name);
	568	}
	569	put_partition_parser(parser);
	570	}
	571	return ret;
	572	}
	573
	574	EXPORT_SYMBOL_GPL(parse_mtd_partitions);
	575	EXPORT_SYMBOL_GPL(register_mtd_parser);
	576	EXPORT_SYMBOL_GPL(deregister_mtd_parser);