[linux-2.6-block.git] / drivers / mtd / maps / ceiva.c

/*
 * Ceiva flash memory driver.
 * Copyright (C) 2002 Rob Scott <rscott@mtrob.fdns.net>
 *
 * Note: this driver supports jedec compatible devices. Modification
 * for CFI compatible devices should be straight forward: change
 * jedec_probe to cfi_probe.
 *
 * Based on: sa1100-flash.c, which has the following copyright:
 * Flash memory access on SA11x0 based devices
 *
 * (C) 2000 Nicolas Pitre <nico@fluxnic.net>
 *
 */

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

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

#include <mach/hardware.h>
#include <asm/mach-types.h>
#include <asm/io.h>
#include <asm/sizes.h>

/*
 * This isn't complete yet, so...
 */
#define CONFIG_MTD_CEIVA_STATICMAP

#ifdef CONFIG_MTD_CEIVA_STATICMAP
/*
 * See include/linux/mtd/partitions.h for definition of the mtd_partition
 * structure.
 *
 * Please note:
 *  1. The flash size given should be the largest flash size that can
 *     be accomodated.
 *
 *  2. The bus width must defined in clps_setup_flash.
 *
 * The MTD layer will detect flash chip aliasing and reduce the size of
 * the map accordingly.
 *
 */

#ifdef CONFIG_ARCH_CEIVA
/* Flash / Partition sizing */
/* For the 28F8003, we use the block mapping to calcuate the sizes */
#define MAX_SIZE_KiB                  (16 + 8 + 8 + 96 + (7*128))
#define BOOT_PARTITION_SIZE_KiB       (16)
#define PARAMS_PARTITION_SIZE_KiB     (8)
#define KERNEL_PARTITION_SIZE_KiB     (4*128)
/* Use both remaing portion of first flash, and all of second flash */
#define ROOT_PARTITION_SIZE_KiB       (3*128) + (8*128)

static struct mtd_partition ceiva_partitions[] = {
	{
		.name = "Ceiva BOOT partition",
		.size   = BOOT_PARTITION_SIZE_KiB*1024,
		.offset = 0,

	},{
		.name = "Ceiva parameters partition",
		.size   = PARAMS_PARTITION_SIZE_KiB*1024,
		.offset = (16 + 8) * 1024,
	},{
		.name = "Ceiva kernel partition",
		.size = (KERNEL_PARTITION_SIZE_KiB)*1024,
		.offset = 0x20000,

	},{
		.name = "Ceiva root filesystem partition",
		.offset = MTDPART_OFS_APPEND,
		.size = (ROOT_PARTITION_SIZE_KiB)*1024,
	}
};
#endif

static int __init clps_static_partitions(struct mtd_partition **parts)
{
	int nb_parts = 0;

#ifdef CONFIG_ARCH_CEIVA
	if (machine_is_ceiva()) {
		*parts       = ceiva_partitions;
		nb_parts     = ARRAY_SIZE(ceiva_partitions);
	}
#endif
	return nb_parts;
}
#endif

struct clps_info {
	unsigned long base;
	unsigned long size;
	int width;
	void *vbase;
	struct map_info *map;
	struct mtd_info *mtd;
	struct resource *res;
};

#define NR_SUBMTD 4

static struct clps_info info[NR_SUBMTD];

static int __init clps_setup_mtd(struct clps_info *clps, int nr, struct mtd_info **rmtd)
{
	struct mtd_info *subdev[nr];
	struct map_info *maps;
	int i, found = 0, ret = 0;

	/*
	 * Allocate the map_info structs in one go.
	 */
	maps = kzalloc(sizeof(struct map_info) * nr, GFP_KERNEL);
	if (!maps)
		return -ENOMEM;
	/*
	 * Claim and then map the memory regions.
	 */
	for (i = 0; i < nr; i++) {
		if (clps[i].base == (unsigned long)-1)
			break;

		clps[i].res = request_mem_region(clps[i].base, clps[i].size, "clps flash");
		if (!clps[i].res) {
			ret = -EBUSY;
			break;
		}

		clps[i].map = maps + i;

		clps[i].map->name = "clps flash";
		clps[i].map->phys = clps[i].base;

		clps[i].vbase = ioremap(clps[i].base, clps[i].size);
		if (!clps[i].vbase) {
			ret = -ENOMEM;
			break;
		}

		clps[i].map->virt = (void __iomem *)clps[i].vbase;
		clps[i].map->bankwidth = clps[i].width;
		clps[i].map->size = clps[i].size;

		simple_map_init(&clps[i].map);

		clps[i].mtd = do_map_probe("jedec_probe", clps[i].map);
		if (clps[i].mtd == NULL) {
			ret = -ENXIO;
			break;
		}
		clps[i].mtd->owner = THIS_MODULE;
		subdev[i] = clps[i].mtd;

		printk(KERN_INFO "clps flash: JEDEC device at 0x%08lx, %dMiB, "
			"%d-bit\n", clps[i].base, clps[i].mtd->size >> 20,
			clps[i].width * 8);
		found += 1;
	}

	/*
	 * ENXIO is special.  It means we didn't find a chip when
	 * we probed.  We need to tear down the mapping, free the
	 * resource and mark it as such.
	 */
	if (ret == -ENXIO) {
		iounmap(clps[i].vbase);
		clps[i].vbase = NULL;
		release_resource(clps[i].res);
		clps[i].res = NULL;
	}

	/*
	 * If we found one device, don't bother with concat support.
	 * If we found multiple devices, use concat if we have it
	 * available, otherwise fail.
	 */
	if (ret == 0 || ret == -ENXIO) {
		if (found == 1) {
			*rmtd = subdev[0];
			ret = 0;
		} else if (found > 1) {
			/*
			 * We detected multiple devices.  Concatenate
			 * them together.
			 */
#ifdef CONFIG_MTD_CONCAT
			*rmtd = mtd_concat_create(subdev, found,
						  "clps flash");
			if (*rmtd == NULL)
				ret = -ENXIO;
#else
			printk(KERN_ERR "clps flash: multiple devices "
			       "found but MTD concat support disabled.\n");
			ret = -ENXIO;
#endif
		}
	}

	/*
	 * If we failed, clean up.
	 */
	if (ret) {
		do {
			if (clps[i].mtd)
				map_destroy(clps[i].mtd);
			if (clps[i].vbase)
				iounmap(clps[i].vbase);
			if (clps[i].res)
				release_resource(clps[i].res);
		} while (i--);

		kfree(maps);
	}

	return ret;
}

static void __exit clps_destroy_mtd(struct clps_info *clps, struct mtd_info *mtd)
{
	int i;

	del_mtd_partitions(mtd);

	if (mtd != clps[0].mtd)
		mtd_concat_destroy(mtd);

	for (i = NR_SUBMTD; i >= 0; i--) {
		if (clps[i].mtd)
			map_destroy(clps[i].mtd);
		if (clps[i].vbase)
			iounmap(clps[i].vbase);
		if (clps[i].res)
			release_resource(clps[i].res);
	}
	kfree(clps[0].map);
}

/*
 * We define the memory space, size, and width for the flash memory
 * space here.
 */

static int __init clps_setup_flash(void)
{
	int nr;

#ifdef CONFIG_ARCH_CEIVA
	if (machine_is_ceiva()) {
		info[0].base = CS0_PHYS_BASE;
		info[0].size = SZ_32M;
		info[0].width = CEIVA_FLASH_WIDTH;
		info[1].base = CS1_PHYS_BASE;
		info[1].size = SZ_32M;
		info[1].width = CEIVA_FLASH_WIDTH;
		nr = 2;
	}
#endif
	return nr;
}

static struct mtd_partition *parsed_parts;
static const char *probes[] = { "cmdlinepart", "RedBoot", NULL };

static void __init clps_locate_partitions(struct mtd_info *mtd)
{
	const char *part_type = NULL;
	int nr_parts = 0;
	do {
		/*
		 * Partition selection stuff.
		 */
		nr_parts = parse_mtd_partitions(mtd, probes, &parsed_parts, 0);
		if (nr_parts > 0) {
			part_type = "command line";
			break;
		}
#ifdef CONFIG_MTD_CEIVA_STATICMAP
		nr_parts = clps_static_partitions(&parsed_parts);
		if (nr_parts > 0) {
			part_type = "static";
			break;
		}
		printk("found: %d partitions\n", nr_parts);
#endif
	} while (0);

	if (nr_parts == 0) {
		printk(KERN_NOTICE "clps flash: no partition info "
			"available, registering whole flash\n");
		add_mtd_device(mtd);
	} else {
		printk(KERN_NOTICE "clps flash: using %s partition "
			"definition\n", part_type);
		add_mtd_partitions(mtd, parsed_parts, nr_parts);
	}

	/* Always succeeds. */
}

static void __exit clps_destroy_partitions(void)
{
	kfree(parsed_parts);
}

static struct mtd_info *mymtd;

static int __init clps_mtd_init(void)
{
	int ret;
	int nr;

	nr = clps_setup_flash();
	if (nr < 0)
		return nr;

	ret = clps_setup_mtd(info, nr, &mymtd);
	if (ret)
		return ret;

	clps_locate_partitions(mymtd);

	return 0;
}

static void __exit clps_mtd_cleanup(void)
{
	clps_destroy_mtd(info, mymtd);
	clps_destroy_partitions();
}

module_init(clps_mtd_init);
module_exit(clps_mtd_cleanup);

MODULE_AUTHOR("Rob Scott");
MODULE_DESCRIPTION("Cirrus Logic JEDEC map driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Ceiva flash memory driver.
	3	* Copyright (C) 2002 Rob Scott <rscott@mtrob.fdns.net>
	4	*
	5	* Note: this driver supports jedec compatible devices. Modification
	6	* for CFI compatible devices should be straight forward: change
	7	* jedec_probe to cfi_probe.
	8	*
	9	* Based on: sa1100-flash.c, which has the following copyright:
	10	* Flash memory access on SA11x0 based devices
	11	*
2f82af08	12	* (C) 2000 Nicolas Pitre <nico@fluxnic.net>
1da177e4	13	*
1da177e4 LT	14	*/
1da177e4 LT	15
1da177e4 LT	16	#include <linux/module.h>
	17	#include <linux/types.h>
	18	#include <linux/ioport.h>
	19	#include <linux/kernel.h>
	20	#include <linux/init.h>
4e57b681	21	#include <linux/slab.h>
1da177e4 LT	22
	23	#include <linux/mtd/mtd.h>
	24	#include <linux/mtd/map.h>
	25	#include <linux/mtd/partitions.h>
	26	#include <linux/mtd/concat.h>
	27
a09e64fb	28	#include <mach/hardware.h>
1da177e4 LT	29	#include <asm/mach-types.h>
	30	#include <asm/io.h>
	31	#include <asm/sizes.h>
	32
	33	/*
	34	* This isn't complete yet, so...
	35	*/
	36	#define CONFIG_MTD_CEIVA_STATICMAP
	37
	38	#ifdef CONFIG_MTD_CEIVA_STATICMAP
	39	/*
	40	* See include/linux/mtd/partitions.h for definition of the mtd_partition
	41	* structure.
	42	*
	43	* Please note:
	44	* 1. The flash size given should be the largest flash size that can
	45	* be accomodated.
	46	*
	47	* 2. The bus width must defined in clps_setup_flash.
	48	*
	49	* The MTD layer will detect flash chip aliasing and reduce the size of
	50	* the map accordingly.
	51	*
	52	*/
	53
	54	#ifdef CONFIG_ARCH_CEIVA
	55	/* Flash / Partition sizing */
	56	/* For the 28F8003, we use the block mapping to calcuate the sizes */
	57	#define MAX_SIZE_KiB (16 + 8 + 8 + 96 + (7*128))
	58	#define BOOT_PARTITION_SIZE_KiB (16)
	59	#define PARAMS_PARTITION_SIZE_KiB (8)
	60	#define KERNEL_PARTITION_SIZE_KiB (4*128)
	61	/* Use both remaing portion of first flash, and all of second flash */
	62	#define ROOT_PARTITION_SIZE_KiB (3128) + (8128)
	63
	64	static struct mtd_partition ceiva_partitions[] = {
	65	{
	66	.name = "Ceiva BOOT partition",
	67	.size = BOOT_PARTITION_SIZE_KiB*1024,
	68	.offset = 0,
	69
	70	},{
	71	.name = "Ceiva parameters partition",
	72	.size = PARAMS_PARTITION_SIZE_KiB*1024,
	73	.offset = (16 + 8) * 1024,
	74	},{
	75	.name = "Ceiva kernel partition",
	76	.size = (KERNEL_PARTITION_SIZE_KiB)*1024,
	77	.offset = 0x20000,
	78
	79	},{
	80	.name = "Ceiva root filesystem partition",
	81	.offset = MTDPART_OFS_APPEND,
	82	.size = (ROOT_PARTITION_SIZE_KiB)*1024,
	83	}
	84	};
	85	#endif
	86
	87	static int __init clps_static_partitions(struct mtd_partition **parts)
	88	{
	89	int nb_parts = 0;
	90
	91	#ifdef CONFIG_ARCH_CEIVA
	92	if (machine_is_ceiva()) {
93	*parts = ceiva_partitions;
94	nb_parts = ARRAY_SIZE(ceiva_partitions);
95	}
96	#endif
97	return nb_parts;
98	}
99	#endif
100
101	struct clps_info {
102	unsigned long base;
103	unsigned long size;
104	int width;
105	void *vbase;
106	struct map_info *map;
107	struct mtd_info *mtd;
108	struct resource *res;
109	};
110
111	#define NR_SUBMTD 4
112
113	static struct clps_info info[NR_SUBMTD];
114
115	static int __init clps_setup_mtd(struct clps_info clps, int nr, struct mtd_info *rmtd)
116	{
117	struct mtd_info *subdev[nr];
118	struct map_info *maps;
119	int i, found = 0, ret = 0;
120
121	/*
122	* Allocate the map_info structs in one go.
123	*/
95b93a0c	124	maps = kzalloc(sizeof(struct map_info) * nr, GFP_KERNEL);
1da177e4 LT	125	if (!maps)
1da177e4 LT	126	return -ENOMEM;
1da177e4 LT	127	/*
	128	* Claim and then map the memory regions.
	129	*/
	130	for (i = 0; i < nr; i++) {
	131	if (clps[i].base == (unsigned long)-1)
	132	break;
	133
	134	clps[i].res = request_mem_region(clps[i].base, clps[i].size, "clps flash");
	135	if (!clps[i].res) {
	136	ret = -EBUSY;
	137	break;
	138	}
	139
	140	clps[i].map = maps + i;
	141
	142	clps[i].map->name = "clps flash";
	143	clps[i].map->phys = clps[i].base;
	144
	145	clps[i].vbase = ioremap(clps[i].base, clps[i].size);
	146	if (!clps[i].vbase) {
	147	ret = -ENOMEM;
	148	break;
	149	}
	150
	151	clps[i].map->virt = (void __iomem *)clps[i].vbase;
	152	clps[i].map->bankwidth = clps[i].width;
	153	clps[i].map->size = clps[i].size;
	154
	155	simple_map_init(&clps[i].map);
	156
	157	clps[i].mtd = do_map_probe("jedec_probe", clps[i].map);
	158	if (clps[i].mtd == NULL) {
	159	ret = -ENXIO;
	160	break;
	161	}
	162	clps[i].mtd->owner = THIS_MODULE;
	163	subdev[i] = clps[i].mtd;
	164
	165	printk(KERN_INFO "clps flash: JEDEC device at 0x%08lx, %dMiB, "
	166	"%d-bit\n", clps[i].base, clps[i].mtd->size >> 20,
	167	clps[i].width * 8);
	168	found += 1;
	169	}
	170
	171	/*
	172	* ENXIO is special. It means we didn't find a chip when
	173	* we probed. We need to tear down the mapping, free the
	174	* resource and mark it as such.
	175	*/
	176	if (ret == -ENXIO) {
	177	iounmap(clps[i].vbase);
	178	clps[i].vbase = NULL;
	179	release_resource(clps[i].res);
	180	clps[i].res = NULL;
	181	}
	182
	183	/*
	184	* If we found one device, don't bother with concat support.
	185	* If we found multiple devices, use concat if we have it
	186	* available, otherwise fail.
	187	*/
	188	if (ret == 0 \|\| ret == -ENXIO) {
	189	if (found == 1) {
	190	*rmtd = subdev[0];
191	ret = 0;
192	} else if (found > 1) {
193	/*
194	* We detected multiple devices. Concatenate
195	* them together.
196	*/
197	#ifdef CONFIG_MTD_CONCAT
198	*rmtd = mtd_concat_create(subdev, found,
199	"clps flash");
200	if (*rmtd == NULL)
201	ret = -ENXIO;
202	#else
203	printk(KERN_ERR "clps flash: multiple devices "
204	"found but MTD concat support disabled.\n");
205	ret = -ENXIO;
206	#endif
207	}
208	}
209
210	/*
211	* If we failed, clean up.
212	*/
213	if (ret) {
214	do {
215	if (clps[i].mtd)
216	map_destroy(clps[i].mtd);
217	if (clps[i].vbase)
218	iounmap(clps[i].vbase);
219	if (clps[i].res)
220	release_resource(clps[i].res);
221	} while (i--);
222
223	kfree(maps);
224	}
225
226	return ret;
227	}
228
229	static void __exit clps_destroy_mtd(struct clps_info clps, struct mtd_info mtd)
230	{
231	int i;
232
233	del_mtd_partitions(mtd);
234
235	if (mtd != clps[0].mtd)
236	mtd_concat_destroy(mtd);
237
238	for (i = NR_SUBMTD; i >= 0; i--) {
239	if (clps[i].mtd)
240	map_destroy(clps[i].mtd);
241	if (clps[i].vbase)
242	iounmap(clps[i].vbase);
243	if (clps[i].res)
244	release_resource(clps[i].res);
245	}
246	kfree(clps[0].map);
247	}
248
249	/*
250	* We define the memory space, size, and width for the flash memory
251	* space here.
252	*/
253
254	static int __init clps_setup_flash(void)
255	{
256	int nr;
257
258	#ifdef CONFIG_ARCH_CEIVA
259	if (machine_is_ceiva()) {
260	info[0].base = CS0_PHYS_BASE;
261	info[0].size = SZ_32M;
262	info[0].width = CEIVA_FLASH_WIDTH;
263	info[1].base = CS1_PHYS_BASE;
264	info[1].size = SZ_32M;
265	info[1].width = CEIVA_FLASH_WIDTH;
266	nr = 2;
267	}
268	#endif
269	return nr;
270	}
271
272	static struct mtd_partition *parsed_parts;
273	static const char *probes[] = { "cmdlinepart", "RedBoot", NULL };
274
275	static void __init clps_locate_partitions(struct mtd_info *mtd)
276	{
277	const char *part_type = NULL;
278	int nr_parts = 0;
279	do {
280	/*
281	* Partition selection stuff.
282	*/
283	nr_parts = parse_mtd_partitions(mtd, probes, &parsed_parts, 0);
284	if (nr_parts > 0) {
285	part_type = "command line";
286	break;
287	}
288	#ifdef CONFIG_MTD_CEIVA_STATICMAP
289	nr_parts = clps_static_partitions(&parsed_parts);
290	if (nr_parts > 0) {
291	part_type = "static";
292	break;
293	}
294	printk("found: %d partitions\n", nr_parts);
295	#endif
296	} while (0);
297
298	if (nr_parts == 0) {
299	printk(KERN_NOTICE "clps flash: no partition info "
300	"available, registering whole flash\n");
301	add_mtd_device(mtd);
302	} else {
303	printk(KERN_NOTICE "clps flash: using %s partition "
304	"definition\n", part_type);
305	add_mtd_partitions(mtd, parsed_parts, nr_parts);
306	}
307
308	/* Always succeeds. */
309	}
310
311	static void __exit clps_destroy_partitions(void)
312	{
fa671646	313	kfree(parsed_parts);
1da177e4 LT	314	}
	315
	316	static struct mtd_info *mymtd;
	317
	318	static int __init clps_mtd_init(void)
	319	{
	320	int ret;
	321	int nr;
	322
	323	nr = clps_setup_flash();
	324	if (nr < 0)
	325	return nr;
	326
	327	ret = clps_setup_mtd(info, nr, &mymtd);
	328	if (ret)
	329	return ret;
	330
	331	clps_locate_partitions(mymtd);
	332
	333	return 0;
	334	}
	335
	336	static void __exit clps_mtd_cleanup(void)
	337	{
	338	clps_destroy_mtd(info, mymtd);
	339	clps_destroy_partitions();
	340	}
	341
	342	module_init(clps_mtd_init);
	343	module_exit(clps_mtd_cleanup);
	344
	345	MODULE_AUTHOR("Rob Scott");
	346	MODULE_DESCRIPTION("Cirrus Logic JEDEC map driver");
	347	MODULE_LICENSE("GPL");