[mirror_ubuntu-artful-kernel.git] / drivers / mtd / afs.c

/*======================================================================

    drivers/mtd/afs.c: ARM Flash Layout/Partitioning

    Copyright (C) 2000 ARM Limited

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

   This is access code for flashes using ARM's flash partitioning
   standards.

   $Id: afs.c,v 1.15 2005/11/07 11:14:19 gleixner Exp $

======================================================================*/

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/init.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>

struct footer_struct {
	u32 image_info_base;	/* Address of first word of ImageFooter  */
	u32 image_start;	/* Start of area reserved by this footer */
	u32 signature;		/* 'Magic' number proves it's a footer   */
	u32 type;		/* Area type: ARM Image, SIB, customer   */
	u32 checksum;		/* Just this structure                   */
};

struct image_info_struct {
	u32 bootFlags;		/* Boot flags, compression etc.          */
	u32 imageNumber;	/* Unique number, selects for boot etc.  */
	u32 loadAddress;	/* Address program should be loaded to   */
	u32 length;		/* Actual size of image                  */
	u32 address;		/* Image is executed from here           */
	char name[16];		/* Null terminated                       */
	u32 headerBase;		/* Flash Address of any stripped header  */
	u32 header_length;	/* Length of header in memory            */
	u32 headerType;		/* AIF, RLF, s-record etc.               */
	u32 checksum;		/* Image checksum (inc. this struct)     */
};

static u32 word_sum(void *words, int num)
{
	u32 *p = words;
	u32 sum = 0;

	while (num--)
		sum += *p++;

	return sum;
}

static int
afs_read_footer(struct mtd_info *mtd, u_int *img_start, u_int *iis_start,
		u_int off, u_int mask)
{
	struct footer_struct fs;
	u_int ptr = off + mtd->erasesize - sizeof(fs);
	size_t sz;
	int ret;

	ret = mtd->read(mtd, ptr, sizeof(fs), &sz, (u_char *) &fs);
	if (ret >= 0 && sz != sizeof(fs))
		ret = -EINVAL;

	if (ret < 0) {
		printk(KERN_ERR "AFS: mtd read failed at 0x%x: %d\n",
			ptr, ret);
		return ret;
	}

	ret = 1;

	/*
	 * Does it contain the magic number?
	 */
	if (fs.signature != 0xa0ffff9f)
		ret = 0;

	/*
	 * Check the checksum.
	 */
	if (word_sum(&fs, sizeof(fs) / sizeof(u32)) != 0xffffffff)
		ret = 0;

	/*
	 * Don't touch the SIB.
	 */
	if (fs.type == 2)
		ret = 0;

	*iis_start = fs.image_info_base & mask;
	*img_start = fs.image_start & mask;

	/*
	 * Check the image info base.  This can not
	 * be located after the footer structure.
	 */
	if (*iis_start >= ptr)
		ret = 0;

	/*
	 * Check the start of this image.  The image
	 * data can not be located after this block.
	 */
	if (*img_start > off)
		ret = 0;

	return ret;
}

static int
afs_read_iis(struct mtd_info *mtd, struct image_info_struct *iis, u_int ptr)
{
	size_t sz;
	int ret, i;

	memset(iis, 0, sizeof(*iis));
	ret = mtd->read(mtd, ptr, sizeof(*iis), &sz, (u_char *) iis);
	if (ret < 0)
		goto failed;

	if (sz != sizeof(*iis)) {
		ret = -EINVAL;
		goto failed;
	}

	ret = 0;

	/*
	 * Validate the name - it must be NUL terminated.
	 */
	for (i = 0; i < sizeof(iis->name); i++)
		if (iis->name[i] == '\0')
			break;

	if (i < sizeof(iis->name))
		ret = 1;

	return ret;

 failed:
	printk(KERN_ERR "AFS: mtd read failed at 0x%x: %d\n",
		ptr, ret);
	return ret;
}

static int parse_afs_partitions(struct mtd_info *mtd,
                         struct mtd_partition **pparts,
                         unsigned long origin)
{
	struct mtd_partition *parts;
	u_int mask, off, idx, sz;
	int ret = 0;
	char *str;

	/*
	 * This is the address mask; we use this to mask off out of
	 * range address bits.
	 */
	mask = mtd->size - 1;

	/*
	 * First, calculate the size of the array we need for the
	 * partition information.  We include in this the size of
	 * the strings.
	 */
	for (idx = off = sz = 0; off < mtd->size; off += mtd->erasesize) {
		struct image_info_struct iis;
		u_int iis_ptr, img_ptr;

		ret = afs_read_footer(mtd, &img_ptr, &iis_ptr, off, mask);
		if (ret < 0)
			break;
		if (ret == 0)
			continue;

		ret = afs_read_iis(mtd, &iis, iis_ptr);
		if (ret < 0)
			break;
		if (ret == 0)
			continue;

		sz += sizeof(struct mtd_partition);
		sz += strlen(iis.name) + 1;
		idx += 1;
	}

	if (!sz)
		return ret;

	parts = kmalloc(sz, GFP_KERNEL);
	if (!parts)
		return -ENOMEM;

	memset(parts, 0, sz);
	str = (char *)(parts + idx);

	/*
	 * Identify the partitions
	 */
	for (idx = off = 0; off < mtd->size; off += mtd->erasesize) {
		struct image_info_struct iis;
		u_int iis_ptr, img_ptr;

		/* Read the footer. */
		ret = afs_read_footer(mtd, &img_ptr, &iis_ptr, off, mask);
		if (ret < 0)
			break;
		if (ret == 0)
			continue;

		/* Read the image info block */
		ret = afs_read_iis(mtd, &iis, iis_ptr);
		if (ret < 0)
			break;
		if (ret == 0)
			continue;

		strcpy(str, iis.name);

		parts[idx].name		= str;
		parts[idx].size		= (iis.length + mtd->erasesize - 1) & ~(mtd->erasesize - 1);
		parts[idx].offset	= img_ptr;
		parts[idx].mask_flags	= 0;

		printk("  mtd%d: at 0x%08x, %5dKB, %8u, %s\n",
			idx, img_ptr, parts[idx].size / 1024,
			iis.imageNumber, str);

		idx += 1;
		str = str + strlen(iis.name) + 1;
	}

	if (!idx) {
		kfree(parts);
		parts = NULL;
	}

	*pparts = parts;
	return idx ? idx : ret;
}

static struct mtd_part_parser afs_parser = {
	.owner = THIS_MODULE,
	.parse_fn = parse_afs_partitions,
	.name = "afs",
};

static int __init afs_parser_init(void)
{
	return register_mtd_parser(&afs_parser);
}

static void __exit afs_parser_exit(void)
{
	deregister_mtd_parser(&afs_parser);
}

module_init(afs_parser_init);
module_exit(afs_parser_exit);


MODULE_AUTHOR("ARM Ltd");
MODULE_DESCRIPTION("ARM Firmware Suite partition parser");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	drivers/mtd/afs.c: ARM Flash Layout/Partitioning
97894cda	4
1da177e4	5	Copyright (C) 2000 ARM Limited
97894cda	6
1da177e4 LT	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
97894cda	11
1da177e4 LT	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
97894cda	16
1da177e4 LT	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
97894cda TG	20
97894cda TG	21	This is access code for flashes using ARM's flash partitioning
1da177e4 LT	22	standards.
1da177e4 LT	23
97894cda	24	$Id: afs.c,v 1.15 2005/11/07 11:14:19 gleixner Exp $
1da177e4 LT	25
	26	======================================================================*/
	27
	28	#include <linux/module.h>
	29	#include <linux/types.h>
	30	#include <linux/kernel.h>
	31	#include <linux/slab.h>
	32	#include <linux/string.h>
	33	#include <linux/init.h>
	34
	35	#include <linux/mtd/mtd.h>
	36	#include <linux/mtd/map.h>
	37	#include <linux/mtd/partitions.h>
	38
	39	struct footer_struct {
	40	u32 image_info_base; /* Address of first word of ImageFooter */
	41	u32 image_start; /* Start of area reserved by this footer */
	42	u32 signature; /* 'Magic' number proves it's a footer */
	43	u32 type; /* Area type: ARM Image, SIB, customer */
	44	u32 checksum; /* Just this structure */
	45	};
	46
	47	struct image_info_struct {
	48	u32 bootFlags; /* Boot flags, compression etc. */
	49	u32 imageNumber; /* Unique number, selects for boot etc. */
	50	u32 loadAddress; /* Address program should be loaded to */
	51	u32 length; /* Actual size of image */
	52	u32 address; /* Image is executed from here */
	53	char name[16]; /* Null terminated */
	54	u32 headerBase; /* Flash Address of any stripped header */
	55	u32 header_length; /* Length of header in memory */
	56	u32 headerType; /* AIF, RLF, s-record etc. */
	57	u32 checksum; /* Image checksum (inc. this struct) */
	58	};
	59
	60	static u32 word_sum(void *words, int num)
	61	{
	62	u32 *p = words;
	63	u32 sum = 0;
	64
	65	while (num--)
	66	sum += *p++;
	67
	68	return sum;
	69	}
	70
	71	static int
	72	afs_read_footer(struct mtd_info mtd, u_int img_start, u_int *iis_start,
	73	u_int off, u_int mask)
	74	{
	75	struct footer_struct fs;
	76	u_int ptr = off + mtd->erasesize - sizeof(fs);
	77	size_t sz;
	78	int ret;
	79
	80	ret = mtd->read(mtd, ptr, sizeof(fs), &sz, (u_char *) &fs);
	81	if (ret >= 0 && sz != sizeof(fs))
	82	ret = -EINVAL;
	83
	84	if (ret < 0) {
	85	printk(KERN_ERR "AFS: mtd read failed at 0x%x: %d\n",
	86	ptr, ret);
	87	return ret;
	88	}
89
90	ret = 1;
91
92	/*
93	* Does it contain the magic number?
94	*/
95	if (fs.signature != 0xa0ffff9f)
96	ret = 0;
97
98	/*
99	* Check the checksum.
100	*/
101	if (word_sum(&fs, sizeof(fs) / sizeof(u32)) != 0xffffffff)
102	ret = 0;
103
104	/*
105	* Don't touch the SIB.
106	*/
107	if (fs.type == 2)
108	ret = 0;
109
110	*iis_start = fs.image_info_base & mask;
111	*img_start = fs.image_start & mask;
112
113	/*
114	* Check the image info base. This can not
115	* be located after the footer structure.
116	*/
117	if (*iis_start >= ptr)
118	ret = 0;
119
120	/*
121	* Check the start of this image. The image
122	* data can not be located after this block.
123	*/
124	if (*img_start > off)
125	ret = 0;
126
127	return ret;
128	}
129
130	static int
131	afs_read_iis(struct mtd_info mtd, struct image_info_struct iis, u_int ptr)
132	{
133	size_t sz;
134	int ret, i;
135
136	memset(iis, 0, sizeof(*iis));
137	ret = mtd->read(mtd, ptr, sizeof(iis), &sz, (u_char ) iis);
138	if (ret < 0)
139	goto failed;
140
141	if (sz != sizeof(*iis)) {
142	ret = -EINVAL;
143	goto failed;
144	}
145
146	ret = 0;
147
148	/*
149	* Validate the name - it must be NUL terminated.
150	*/
151	for (i = 0; i < sizeof(iis->name); i++)
152	if (iis->name[i] == '\0')
153	break;
154
155	if (i < sizeof(iis->name))
156	ret = 1;
157
158	return ret;
159
160	failed:
161	printk(KERN_ERR "AFS: mtd read failed at 0x%x: %d\n",
162	ptr, ret);
163	return ret;
164	}
165
97894cda	166	static int parse_afs_partitions(struct mtd_info *mtd,
1da177e4 LT	167	struct mtd_partition **pparts,
	168	unsigned long origin)
	169	{
	170	struct mtd_partition *parts;
	171	u_int mask, off, idx, sz;
	172	int ret = 0;
	173	char *str;
	174
	175	/*
	176	* This is the address mask; we use this to mask off out of
	177	* range address bits.
	178	*/
	179	mask = mtd->size - 1;
	180
	181	/*
	182	* First, calculate the size of the array we need for the
	183	* partition information. We include in this the size of
	184	* the strings.
	185	*/
	186	for (idx = off = sz = 0; off < mtd->size; off += mtd->erasesize) {
	187	struct image_info_struct iis;
	188	u_int iis_ptr, img_ptr;
	189
	190	ret = afs_read_footer(mtd, &img_ptr, &iis_ptr, off, mask);
	191	if (ret < 0)
	192	break;
	193	if (ret == 0)
	194	continue;
	195
	196	ret = afs_read_iis(mtd, &iis, iis_ptr);
	197	if (ret < 0)
	198	break;
	199	if (ret == 0)
	200	continue;
	201
	202	sz += sizeof(struct mtd_partition);
	203	sz += strlen(iis.name) + 1;
	204	idx += 1;
	205	}
	206
	207	if (!sz)
	208	return ret;
	209
	210	parts = kmalloc(sz, GFP_KERNEL);
	211	if (!parts)
	212	return -ENOMEM;
	213
	214	memset(parts, 0, sz);
	215	str = (char *)(parts + idx);
	216
	217	/*
	218	* Identify the partitions
	219	*/
	220	for (idx = off = 0; off < mtd->size; off += mtd->erasesize) {
	221	struct image_info_struct iis;
747aead3	222	u_int iis_ptr, img_ptr;
1da177e4 LT	223
	224	/* Read the footer. */
	225	ret = afs_read_footer(mtd, &img_ptr, &iis_ptr, off, mask);
	226	if (ret < 0)
	227	break;
	228	if (ret == 0)
	229	continue;
	230
	231	/* Read the image info block */
	232	ret = afs_read_iis(mtd, &iis, iis_ptr);
	233	if (ret < 0)
	234	break;
	235	if (ret == 0)
	236	continue;
	237
	238	strcpy(str, iis.name);
1da177e4 LT	239
1da177e4 LT	240	parts[idx].name = str;
747aead3	241	parts[idx].size = (iis.length + mtd->erasesize - 1) & ~(mtd->erasesize - 1);
1da177e4 LT	242	parts[idx].offset = img_ptr;
	243	parts[idx].mask_flags = 0;
	244
	245	printk(" mtd%d: at 0x%08x, %5dKB, %8u, %s\n",
	246	idx, img_ptr, parts[idx].size / 1024,
	247	iis.imageNumber, str);
	248
	249	idx += 1;
	250	str = str + strlen(iis.name) + 1;
	251	}
	252
	253	if (!idx) {
	254	kfree(parts);
	255	parts = NULL;
	256	}
	257
	258	*pparts = parts;
	259	return idx ? idx : ret;
	260	}
	261
	262	static struct mtd_part_parser afs_parser = {
	263	.owner = THIS_MODULE,
	264	.parse_fn = parse_afs_partitions,
	265	.name = "afs",
	266	};
	267
	268	static int __init afs_parser_init(void)
	269	{
	270	return register_mtd_parser(&afs_parser);
	271	}
	272
	273	static void __exit afs_parser_exit(void)
	274	{
	275	deregister_mtd_parser(&afs_parser);
	276	}
	277
	278	module_init(afs_parser_init);
	279	module_exit(afs_parser_exit);
	280
	281
	282	MODULE_AUTHOR("ARM Ltd");
	283	MODULE_DESCRIPTION("ARM Firmware Suite partition parser");
	284	MODULE_LICENSE("GPL");