URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mtd/] [mtdpart.c] - Blame information for rev 81

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Simple MTD partitioning layer
 *
 * (C) 2000 Nicolas Pitre <nico@cam.org>
 *
 * This code is GPL
 *
 * $Id: mtdpart.c,v 1.55 2005/11/07 11:14:20 gleixner Exp $
 *
 *      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, u_char **buf)
{
        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, buf);
}
 
static void part_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
{
        struct mtd_part *part = PART(mtd);
 
        part->master->unpoint (part->master, addr, 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_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 list_head *node;
        struct mtd_part *slave;
 
        for (node = mtd_partitions.next;
             node != &mtd_partitions;
             node = node->next) {
                slave = list_entry(node, struct mtd_part, list);
                if (slave->master == master) {
                        struct list_head *prev = node->prev;
                        __list_del(prev, node->next);
                        if(slave->registered)
                                del_mtd_device(&slave->mtd);
                        kfree(slave);
                        node = prev;
                }
        }
 
        return 0;
}
 
/*
 * 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++) {
 
                /* 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 -ENOMEM;
                }
                list_add(&slave->list, &mtd_partitions);
 
                /* set up the MTD object for this partition */
                slave->mtd.type = master->type;
                slave->mtd.flags = master->flags & ~parts[i].mask_flags;
                slave->mtd.size = parts[i].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 = parts[i].name;
                slave->mtd.owner = master->owner;
 
                slave->mtd.read = part_read;
                slave->mtd.write = part_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 (!i && 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 = parts[i].offset;
                slave->index = i;
 
                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", i,
                                       cur_offset, slave->offset);
                        }
                }
                if (slave->mtd.size == MTDPART_SIZ_FULL)
                        slave->mtd.size = master->size - slave->offset;
                cur_offset = slave->offset + slave->mtd.size;
 
                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",
                                parts[i].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",
                                parts[i].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 && slave->offset >= regions[i].offset; i++)
                                ;
 
                        for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; 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",
                                parts[i].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",
                                parts[i].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(parts[i].mtdp)
                {       /* store the object pointer (caller may or may not register it */
                        *parts[i].mtdp = &slave->mtd;
                        slave->registered = 0;
                }
                else
                {
                        /* register our partition */
                        add_mtd_device(&slave->mtd);
                        slave->registered = 1;
                }
        }
 
        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 list_head *this;
        void *ret = NULL;
        spin_lock(&part_parser_lock);
 
        list_for_each(this, &part_parsers) {
                struct mtd_part_parser *p = list_entry(this, struct mtd_part_parser, 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);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mtd/] [mtdpart.c] - Blame information for rev 81

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