[deliverable/linux.git] / drivers / mtd / maps / tqm834x.c

/*
 * drivers/mtd/maps/tqm834x.c
 *
 * MTD mapping driver for TQM834x boards
 *
 * Copyright 2005 Wolfgang Denk, DENX Software Engineering, <wd@denx.de>.
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2.  This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 *
 */

#include <linux/config.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <asm/ppcboot.h>

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

#define FLASH_BANK_MAX	2

extern unsigned char __res[];

/* trivial struct to describe partition information */
struct mtd_part_def
{
	int nums;
	unsigned char *type;
	struct mtd_partition* mtd_part;
};

static struct mtd_info* mtd_banks[FLASH_BANK_MAX];
static struct map_info* map_banks[FLASH_BANK_MAX];
static struct mtd_part_def part_banks[FLASH_BANK_MAX];

static unsigned long num_banks;
static unsigned long start_scan_addr;

#ifdef CONFIG_MTD_PARTITIONS
/*
 * The following defines the partition layout of TQM834x boards.
 *
 * See include/linux/mtd/partitions.h for definition of the
 * mtd_partition structure.
 *
 * Assume minimal initial size of 4 MiB per bank, will be updated
 * later in init_tqm834x_mtd() routine.
 */

/* Partition definition for the first flash bank which is always present. */
static struct mtd_partition tqm834x_partitions_bank1[] = {
	{
		.name	= "u-boot",		/* u-boot firmware	*/
		.offset	= 0x00000000,
		.size	= 0x00040000,		/* 256 KiB		*/
		/*mask_flags: MTD_WRITEABLE,	 * force read-only	*/
	},
	{
		.name	= "env",		/* u-boot environment	*/
		.offset	= 0x00040000,
		.size	= 0x00020000,		/* 128 KiB		*/
		/*mask_flags: MTD_WRITEABLE,	 * force read-only	*/
	},
	{
		.name	= "kernel",		/* linux kernel image	*/
		.offset	= 0x00060000,
		.size	= 0x00100000,		/* 1 MiB		*/
		/*mask_flags: MTD_WRITEABLE,	 * force read-only	*/
	},
	{
		.name	= "initrd",		/* ramdisk image	*/
		.offset	= 0x00160000,
		.size	= 0x00200000,		/* 2 MiB		*/
	},
	{
		.name	= "user",		/* user data		*/
		.offset	= 0x00360000,
		.size	= 0x000a0000,		/* remaining space	*/
		/* NOTE: this parttion size is re-calcated in		*/
		/* init_tqm834x_mtd() to cover actual remaining space.	*/
	},
};

/* Partition definition for the second flash bank which may be present on some
 * TQM834x boards.
 */
static struct mtd_partition tqm834x_partitions_bank2[] = {
	{
		.name	= "jffs2",		/* jffs2 filesystem	*/
		.offset	= 0x00000000,
		.size	= 0x00400000,		/* whole device		*/
		/* NOTE: this parttion size is re-calcated in		*/
		/* init_tqm834x_mtd() to cover actual device size.	*/
	},
};

#endif	/* CONFIG_MTD_PARTITIONS */

static int __init init_tqm834x_mtd(void)
{
	int idx = 0, ret = 0;
	unsigned long flash_addr, flash_size, mtd_size = 0;

	/* pointer to TQM834x board info data */
	bd_t *bd = (bd_t *)__res;
#ifdef CONFIG_MTD_CMDLINE_PARTS
	int n;
	char mtdid[4];
	const char *part_probes[] = { "cmdlinepart", NULL };
#endif

	flash_addr = bd->bi_flashstart;
	flash_size = bd->bi_flashsize;

	/* request maximum flash size address space */
	start_scan_addr = (unsigned long)ioremap(flash_addr, flash_size);
	if (!start_scan_addr) {
		printk("%s: Failed to ioremap address: 0x%lx\n",
		       __FUNCTION__, flash_addr);
		return -EIO;
	}

	for(idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
		if (mtd_size >= flash_size)
			break;

		pr_debug("%s: chip probing count %d\n", __FUNCTION__, idx);

		map_banks[idx] =
			(struct map_info *)kmalloc(sizeof(struct map_info),
						   GFP_KERNEL);
		if (map_banks[idx] == NULL) {
			ret = -ENOMEM;
			goto error_mem;
		}
		memset((void *)map_banks[idx], 0, sizeof(struct map_info));
		map_banks[idx]->name = (char *)kmalloc(16, GFP_KERNEL);
		if (map_banks[idx]->name == NULL) {
			ret = -ENOMEM;
			goto error_mem;
		}
		memset((void *)map_banks[idx]->name, 0, 16);

		sprintf(map_banks[idx]->name, "TQM834x-%d", idx);
		map_banks[idx]->size = flash_size;
		map_banks[idx]->bankwidth = 4;

		simple_map_init(map_banks[idx]);

		map_banks[idx]->virt = (void __iomem *)
			(start_scan_addr + ((idx > 0) ?
			(mtd_banks[idx-1] ? mtd_banks[idx-1]->size : 0) : 0));
		map_banks[idx]->phys =
			flash_addr + ((idx > 0) ?
			(mtd_banks[idx-1] ? mtd_banks[idx-1]->size : 0) : 0);

		/* start to probe flash chips */
		mtd_banks[idx] = do_map_probe("cfi_probe", map_banks[idx]);
		if (mtd_banks[idx]) {
			mtd_banks[idx]->owner = THIS_MODULE;
			mtd_size += mtd_banks[idx]->size;
			num_banks++;
			pr_debug("%s: bank %ld, name: %s, size: %d bytes \n",
				 __FUNCTION__, num_banks,
				 mtd_banks[idx]->name, mtd_banks[idx]->size);
		}
	}

	/* no supported flash chips found */
	if (!num_banks) {
		printk("TQM834x: No supported flash chips found!\n");
		ret = -ENXIO;
		goto error_mem;
	}

#ifdef CONFIG_MTD_PARTITIONS
	/*
	 * Select static partition definitions
	 */
	n = ARRAY_SIZE(tqm834x_partitions_bank1);
	part_banks[0].mtd_part	= tqm834x_partitions_bank1;
	part_banks[0].type	= "static image bank1";
	part_banks[0].nums	= n;

	/* update last partition size to cover actual remaining space */
	tqm834x_partitions_bank1[n - 1].size =
		mtd_banks[0]->size -
		tqm834x_partitions_bank1[n - 1].offset;

	/* check if we have second bank? */
	if (num_banks == 2) {
		n = ARRAY_SIZE(tqm834x_partitions_bank2);
		part_banks[1].mtd_part	= tqm834x_partitions_bank2;
		part_banks[1].type	= "static image bank2";
		part_banks[1].nums	= n;

		/* update last partition size to cover actual remaining space */
		tqm834x_partitions_bank2[n - 1].size =
			mtd_banks[1]->size -
			tqm834x_partitions_bank2[n - 1].offset;
	}

	for(idx = 0; idx < num_banks ; idx++) {
#ifdef CONFIG_MTD_CMDLINE_PARTS
		sprintf(mtdid, "%d", idx);
		n = parse_mtd_partitions(mtd_banks[idx],
					 part_probes,
					 &part_banks[idx].mtd_part,
					 0);
		pr_debug("%s: %d command line partitions on bank %s\n",
			 __FUNCTION__, n, mtdid);
		if (n > 0) {
			part_banks[idx].type = "command line";
			part_banks[idx].nums = n;
		}
#endif	/* CONFIG_MTD_CMDLINE_PARTS */
		if (part_banks[idx].nums == 0) {
			printk(KERN_NOTICE
			       "TQM834x flash bank %d: no partition info "
			       "available, registering whole device\n", idx);
			add_mtd_device(mtd_banks[idx]);
		} else {
			printk(KERN_NOTICE
			       "TQM834x flash bank %d: Using %s partition "
			       "definition\n", idx, part_banks[idx].type);
			add_mtd_partitions(mtd_banks[idx],
					   part_banks[idx].mtd_part,
					   part_banks[idx].nums);
		}
	}
#else	/* ! CONFIG_MTD_PARTITIONS */
	printk(KERN_NOTICE "TQM834x flash: registering %d flash banks "
			"at once\n", num_banks);

	for(idx = 0 ; idx < num_banks ; idx++)
		add_mtd_device(mtd_banks[idx]);

#endif	/* CONFIG_MTD_PARTITIONS */

	return 0;
error_mem:
	for (idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
		if (map_banks[idx] != NULL) {
			if (map_banks[idx]->name != NULL) {
				kfree(map_banks[idx]->name);
				map_banks[idx]->name = NULL;
			}
			kfree(map_banks[idx]);
			map_banks[idx] = NULL;
		}
	}

	iounmap((void *)start_scan_addr);

	return ret;
}

static void __exit cleanup_tqm834x_mtd(void)
{
	unsigned int idx = 0;
	for(idx = 0 ; idx < num_banks ; idx++) {
		/* destroy mtd_info previously allocated */
		if (mtd_banks[idx]) {
			del_mtd_partitions(mtd_banks[idx]);
			map_destroy(mtd_banks[idx]);
		}

		/* release map_info not used anymore */
		kfree(map_banks[idx]->name);
		kfree(map_banks[idx]);
	}

	if (start_scan_addr) {
		iounmap((void *)start_scan_addr);
		start_scan_addr = 0;
	}
}

module_init(init_tqm834x_mtd);
module_exit(cleanup_tqm834x_mtd);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Wolfgang Denk <wd@denx.de>");
MODULE_DESCRIPTION("MTD map driver for TQM834x boards");
Commit	Line	Data
be30c10f MB	1	/*
	2	* drivers/mtd/maps/tqm834x.c
	3	*
	4	* MTD mapping driver for TQM834x boards
	5	*
	6	* Copyright 2005 Wolfgang Denk, DENX Software Engineering, <wd@denx.de>.
	7	*
	8	* This file is licensed under the terms of the GNU General Public License
	9	* version 2. This program is licensed "as is" without any warranty of any
	10	* kind, whether express or implied.
	11	*
	12	*/
	13
	14	#include <linux/config.h>
	15	#include <linux/init.h>
	16	#include <linux/module.h>
	17	#include <linux/types.h>
	18	#include <linux/kernel.h>
	19	#include <linux/slab.h>
	20	#include <asm/io.h>
	21	#include <asm/ppcboot.h>
	22
	23	#include <linux/mtd/mtd.h>
	24	#include <linux/mtd/map.h>
	25	#include <linux/mtd/partitions.h>
	26
	27	#define FLASH_BANK_MAX 2
	28
	29	extern unsigned char __res[];
	30
	31	/* trivial struct to describe partition information */
	32	struct mtd_part_def
	33	{
	34	int nums;
	35	unsigned char *type;
	36	struct mtd_partition* mtd_part;
	37	};
	38
	39	static struct mtd_info* mtd_banks[FLASH_BANK_MAX];
	40	static struct map_info* map_banks[FLASH_BANK_MAX];
	41	static struct mtd_part_def part_banks[FLASH_BANK_MAX];
	42
	43	static unsigned long num_banks;
	44	static unsigned long start_scan_addr;
	45
	46	#ifdef CONFIG_MTD_PARTITIONS
	47	/*
	48	* The following defines the partition layout of TQM834x boards.
	49	*
	50	* See include/linux/mtd/partitions.h for definition of the
	51	* mtd_partition structure.
	52	*
	53	* Assume minimal initial size of 4 MiB per bank, will be updated
	54	* later in init_tqm834x_mtd() routine.
	55	*/
	56
	57	/* Partition definition for the first flash bank which is always present. */
	58	static struct mtd_partition tqm834x_partitions_bank1[] = {
	59	{
	60	.name = "u-boot", /* u-boot firmware */
	61	.offset = 0x00000000,
	62	.size = 0x00040000, /* 256 KiB */
	63	/mask_flags: MTD_WRITEABLE, force read-only */
	64	},
65	{
66	.name = "env", /* u-boot environment */
67	.offset = 0x00040000,
68	.size = 0x00020000, /* 128 KiB */
69	/mask_flags: MTD_WRITEABLE, force read-only */
70	},
71	{
72	.name = "kernel", /* linux kernel image */
73	.offset = 0x00060000,
74	.size = 0x00100000, /* 1 MiB */
75	/mask_flags: MTD_WRITEABLE, force read-only */
76	},
77	{
78	.name = "initrd", /* ramdisk image */
79	.offset = 0x00160000,
80	.size = 0x00200000, /* 2 MiB */
81	},
82	{
83	.name = "user", /* user data */
84	.offset = 0x00360000,
85	.size = 0x000a0000, /* remaining space */
86	/* NOTE: this parttion size is re-calcated in */
87	/* init_tqm834x_mtd() to cover actual remaining space. */
88	},
89	};
90
91	/* Partition definition for the second flash bank which may be present on some
92	* TQM834x boards.
93	*/
94	static struct mtd_partition tqm834x_partitions_bank2[] = {
95	{
96	.name = "jffs2", /* jffs2 filesystem */
97	.offset = 0x00000000,
98	.size = 0x00400000, /* whole device */
99	/* NOTE: this parttion size is re-calcated in */
100	/* init_tqm834x_mtd() to cover actual device size. */
101	},
102	};
103
104	#endif /* CONFIG_MTD_PARTITIONS */
105
106	static int __init init_tqm834x_mtd(void)
107	{
108	int idx = 0, ret = 0;
109	unsigned long flash_addr, flash_size, mtd_size = 0;
110
111	/* pointer to TQM834x board info data */
112	bd_t bd = (bd_t )__res;
113	#ifdef CONFIG_MTD_CMDLINE_PARTS
114	int n;
115	char mtdid[4];
116	const char *part_probes[] = { "cmdlinepart", NULL };
117	#endif
118
119	flash_addr = bd->bi_flashstart;
120	flash_size = bd->bi_flashsize;
121
122	/* request maximum flash size address space */
123	start_scan_addr = (unsigned long)ioremap(flash_addr, flash_size);
124	if (!start_scan_addr) {
125	printk("%s: Failed to ioremap address: 0x%lx\n",
126	__FUNCTION__, flash_addr);
127	return -EIO;
128	}
129
130	for(idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
131	if (mtd_size >= flash_size)
132	break;
133
134	pr_debug("%s: chip probing count %d\n", __FUNCTION__, idx);
135
69f34c98	136	map_banks[idx] =
be30c10f MB	137	(struct map_info *)kmalloc(sizeof(struct map_info),
	138	GFP_KERNEL);
	139	if (map_banks[idx] == NULL) {
	140	ret = -ENOMEM;
	141	goto error_mem;
	142	}
	143	memset((void *)map_banks[idx], 0, sizeof(struct map_info));
	144	map_banks[idx]->name = (char *)kmalloc(16, GFP_KERNEL);
	145	if (map_banks[idx]->name == NULL) {
	146	ret = -ENOMEM;
	147	goto error_mem;
	148	}
	149	memset((void *)map_banks[idx]->name, 0, 16);
	150
	151	sprintf(map_banks[idx]->name, "TQM834x-%d", idx);
	152	map_banks[idx]->size = flash_size;
	153	map_banks[idx]->bankwidth = 4;
	154
	155	simple_map_init(map_banks[idx]);
	156
	157	map_banks[idx]->virt = (void __iomem *)
	158	(start_scan_addr + ((idx > 0) ?
	159	(mtd_banks[idx-1] ? mtd_banks[idx-1]->size : 0) : 0));
	160	map_banks[idx]->phys =
	161	flash_addr + ((idx > 0) ?
	162	(mtd_banks[idx-1] ? mtd_banks[idx-1]->size : 0) : 0);
	163
	164	/* start to probe flash chips */
	165	mtd_banks[idx] = do_map_probe("cfi_probe", map_banks[idx]);
	166	if (mtd_banks[idx]) {
	167	mtd_banks[idx]->owner = THIS_MODULE;
	168	mtd_size += mtd_banks[idx]->size;
	169	num_banks++;
	170	pr_debug("%s: bank %ld, name: %s, size: %d bytes \n",
	171	__FUNCTION__, num_banks,
	172	mtd_banks[idx]->name, mtd_banks[idx]->size);
	173	}
	174	}
	175
	176	/* no supported flash chips found */
	177	if (!num_banks) {
	178	printk("TQM834x: No supported flash chips found!\n");
	179	ret = -ENXIO;
	180	goto error_mem;
	181	}
	182
	183	#ifdef CONFIG_MTD_PARTITIONS
	184	/*
	185	* Select static partition definitions
	186	*/
	187	n = ARRAY_SIZE(tqm834x_partitions_bank1);
	188	part_banks[0].mtd_part = tqm834x_partitions_bank1;
	189	part_banks[0].type = "static image bank1";
	190	part_banks[0].nums = n;
	191
	192	/* update last partition size to cover actual remaining space */
	193	tqm834x_partitions_bank1[n - 1].size =
	194	mtd_banks[0]->size -
	195	tqm834x_partitions_bank1[n - 1].offset;
69f34c98	196
be30c10f MB	197	/* check if we have second bank? */
	198	if (num_banks == 2) {
	199	n = ARRAY_SIZE(tqm834x_partitions_bank2);
	200	part_banks[1].mtd_part = tqm834x_partitions_bank2;
	201	part_banks[1].type = "static image bank2";
	202	part_banks[1].nums = n;
	203
	204	/* update last partition size to cover actual remaining space */
	205	tqm834x_partitions_bank2[n - 1].size =
	206	mtd_banks[1]->size -
	207	tqm834x_partitions_bank2[n - 1].offset;
	208	}
	209
	210	for(idx = 0; idx < num_banks ; idx++) {
	211	#ifdef CONFIG_MTD_CMDLINE_PARTS
	212	sprintf(mtdid, "%d", idx);
	213	n = parse_mtd_partitions(mtd_banks[idx],
	214	part_probes,
	215	&part_banks[idx].mtd_part,
	216	0);
	217	pr_debug("%s: %d command line partitions on bank %s\n",
	218	__FUNCTION__, n, mtdid);
	219	if (n > 0) {
	220	part_banks[idx].type = "command line";
	221	part_banks[idx].nums = n;
	222	}
	223	#endif /* CONFIG_MTD_CMDLINE_PARTS */
	224	if (part_banks[idx].nums == 0) {
	225	printk(KERN_NOTICE
	226	"TQM834x flash bank %d: no partition info "
	227	"available, registering whole device\n", idx);
	228	add_mtd_device(mtd_banks[idx]);
	229	} else {
69f34c98	230	printk(KERN_NOTICE
be30c10f MB	231	"TQM834x flash bank %d: Using %s partition "
	232	"definition\n", idx, part_banks[idx].type);
	233	add_mtd_partitions(mtd_banks[idx],
69f34c98	234	part_banks[idx].mtd_part,
be30c10f MB	235	part_banks[idx].nums);
	236	}
	237	}
	238	#else /* ! CONFIG_MTD_PARTITIONS */
	239	printk(KERN_NOTICE "TQM834x flash: registering %d flash banks "
	240	"at once\n", num_banks);
	241
	242	for(idx = 0 ; idx < num_banks ; idx++)
	243	add_mtd_device(mtd_banks[idx]);
	244
	245	#endif /* CONFIG_MTD_PARTITIONS */
	246
	247	return 0;
	248	error_mem:
	249	for (idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
	250	if (map_banks[idx] != NULL) {
	251	if (map_banks[idx]->name != NULL) {
	252	kfree(map_banks[idx]->name);
	253	map_banks[idx]->name = NULL;
	254	}
	255	kfree(map_banks[idx]);
	256	map_banks[idx] = NULL;
	257	}
	258	}
	259
	260	iounmap((void *)start_scan_addr);
	261
	262	return ret;
	263	}
	264
	265	static void __exit cleanup_tqm834x_mtd(void)
	266	{
	267	unsigned int idx = 0;
	268	for(idx = 0 ; idx < num_banks ; idx++) {
	269	/* destroy mtd_info previously allocated */
	270	if (mtd_banks[idx]) {
	271	del_mtd_partitions(mtd_banks[idx]);
	272	map_destroy(mtd_banks[idx]);
	273	}
	274
	275	/* release map_info not used anymore */
	276	kfree(map_banks[idx]->name);
	277	kfree(map_banks[idx]);
	278	}
	279
	280	if (start_scan_addr) {
	281	iounmap((void *)start_scan_addr);
	282	start_scan_addr = 0;
	283	}
	284	}
	285
	286	module_init(init_tqm834x_mtd);
	287	module_exit(cleanup_tqm834x_mtd);
	288
	289	MODULE_LICENSE("GPL");
	290	MODULE_AUTHOR("Wolfgang Denk <wd@denx.de>");
	291	MODULE_DESCRIPTION("MTD map driver for TQM834x boards");