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

/*
 * Flash mappings described by the OF (or flattened) device tree
 *
 * Copyright (C) 2006 MontaVista Software Inc.
 * Author: Vitaly Wool <vwool@ru.mvista.com>
 *
 * Revised to handle newer style flash binding by:
 *   Copyright (C) 2007 David Gibson, IBM Corporation.
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/concat.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_platform.h>
#include <linux/slab.h>

struct of_flash_list {
	struct mtd_info *mtd;
	struct map_info map;
	struct resource *res;
};

struct of_flash {
	struct mtd_info		*cmtd;
	int list_size; /* number of elements in of_flash_list */
	struct of_flash_list	list[0];
};

static int of_flash_remove(struct platform_device *dev)
{
	struct of_flash *info;
	int i;

	info = dev_get_drvdata(&dev->dev);
	if (!info)
		return 0;
	dev_set_drvdata(&dev->dev, NULL);

	if (info->cmtd) {
		mtd_device_unregister(info->cmtd);
		if (info->cmtd != info->list[0].mtd)
			mtd_concat_destroy(info->cmtd);
	}

	for (i = 0; i < info->list_size; i++) {
		if (info->list[i].mtd)
			map_destroy(info->list[i].mtd);

		if (info->list[i].map.virt)
			iounmap(info->list[i].map.virt);

		if (info->list[i].res) {
			release_resource(info->list[i].res);
			kfree(info->list[i].res);
		}
	}
	return 0;
}

static const char * const rom_probe_types[] = {
	"cfi_probe", "jedec_probe", "map_rom" };

/* Helper function to handle probing of the obsolete "direct-mapped"
 * compatible binding, which has an extra "probe-type" property
 * describing the type of flash probe necessary. */
static struct mtd_info *obsolete_probe(struct platform_device *dev,
				       struct map_info *map)
{
	struct device_node *dp = dev->dev.of_node;
	const char *of_probe;
	struct mtd_info *mtd;
	int i;

	dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
		 "flash binding\n");

	of_probe = of_get_property(dp, "probe-type", NULL);
	if (!of_probe) {
		for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
			mtd = do_map_probe(rom_probe_types[i], map);
			if (mtd)
				return mtd;
		}
		return NULL;
	} else if (strcmp(of_probe, "CFI") == 0) {
		return do_map_probe("cfi_probe", map);
	} else if (strcmp(of_probe, "JEDEC") == 0) {
		return do_map_probe("jedec_probe", map);
	} else {
		if (strcmp(of_probe, "ROM") != 0)
			dev_warn(&dev->dev, "obsolete_probe: don't know probe "
				 "type '%s', mapping as rom\n", of_probe);
		return do_map_probe("map_rom", map);
	}
}

/* When partitions are set we look for a linux,part-probe property which
   specifies the list of partition probers to use. If none is given then the
   default is use. These take precedence over other device tree
   information. */
static const char * const part_probe_types_def[] = {
	"cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };

static const char * const *of_get_probes(struct device_node *dp)
{
	const char *cp;
	int cplen;
	unsigned int l;
	unsigned int count;
	const char **res;

	cp = of_get_property(dp, "linux,part-probe", &cplen);
	if (cp == NULL)
		return part_probe_types_def;

	count = 0;
	for (l = 0; l != cplen; l++)
		if (cp[l] == 0)
			count++;

	res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
	count = 0;
	while (cplen > 0) {
		res[count] = cp;
		l = strlen(cp) + 1;
		cp += l;
		cplen -= l;
		count++;
	}
	return res;
}

static void of_free_probes(const char * const *probes)
{
	if (probes != part_probe_types_def)
		kfree(probes);
}

static struct of_device_id of_flash_match[];
static int of_flash_probe(struct platform_device *dev)
{
	const char * const *part_probe_types;
	const struct of_device_id *match;
	struct device_node *dp = dev->dev.of_node;
	struct resource res;
	struct of_flash *info;
	const char *probe_type;
	const __be32 *width;
	int err;
	int i;
	int count;
	const __be32 *p;
	int reg_tuple_size;
	struct mtd_info **mtd_list = NULL;
	resource_size_t res_size;
	struct mtd_part_parser_data ppdata;
	bool map_indirect;
	const char *mtd_name = NULL;

	match = of_match_device(of_flash_match, &dev->dev);
	if (!match)
		return -EINVAL;
	probe_type = match->data;

	reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);

	of_property_read_string(dp, "linux,mtd-name", &mtd_name);

	/*
	 * Get number of "reg" tuples. Scan for MTD devices on area's
	 * described by each "reg" region. This makes it possible (including
	 * the concat support) to support the Intel P30 48F4400 chips which
	 * consists internally of 2 non-identical NOR chips on one die.
	 */
	p = of_get_property(dp, "reg", &count);
	if (count % reg_tuple_size != 0) {
		dev_err(&dev->dev, "Malformed reg property on %s\n",
				dev->dev.of_node->full_name);
		err = -EINVAL;
		goto err_flash_remove;
	}
	count /= reg_tuple_size;

	map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");

	err = -ENOMEM;
	info = devm_kzalloc(&dev->dev,
			    sizeof(struct of_flash) +
			    sizeof(struct of_flash_list) * count, GFP_KERNEL);
	if (!info)
		goto err_flash_remove;

	dev_set_drvdata(&dev->dev, info);

	mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
	if (!mtd_list)
		goto err_flash_remove;

	for (i = 0; i < count; i++) {
		err = -ENXIO;
		if (of_address_to_resource(dp, i, &res)) {
			/*
			 * Continue with next register tuple if this
			 * one is not mappable
			 */
			continue;
		}

		dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);

		err = -EBUSY;
		res_size = resource_size(&res);
		info->list[i].res = request_mem_region(res.start, res_size,
						       dev_name(&dev->dev));
		if (!info->list[i].res)
			goto err_out;

		err = -ENXIO;
		width = of_get_property(dp, "bank-width", NULL);
		if (!width) {
			dev_err(&dev->dev, "Can't get bank width from device"
				" tree\n");
			goto err_out;
		}

		info->list[i].map.name = mtd_name ?: dev_name(&dev->dev);
		info->list[i].map.phys = res.start;
		info->list[i].map.size = res_size;
		info->list[i].map.bankwidth = be32_to_cpup(width);
		info->list[i].map.device_node = dp;

		err = -ENOMEM;
		info->list[i].map.virt = ioremap(info->list[i].map.phys,
						 info->list[i].map.size);
		if (!info->list[i].map.virt) {
			dev_err(&dev->dev, "Failed to ioremap() flash"
				" region\n");
			goto err_out;
		}

		simple_map_init(&info->list[i].map);

		/*
		 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
		 * may cause problems with JFFS2 usage, as the local bus (LPB)
		 * doesn't support unaligned accesses as implemented in the
		 * JFFS2 code via memcpy(). By setting NO_XIP, the
		 * flash will not be exposed directly to the MTD users
		 * (e.g. JFFS2) any more.
		 */
		if (map_indirect)
			info->list[i].map.phys = NO_XIP;

		if (probe_type) {
			info->list[i].mtd = do_map_probe(probe_type,
							 &info->list[i].map);
		} else {
			info->list[i].mtd = obsolete_probe(dev,
							   &info->list[i].map);
		}

		/* Fall back to mapping region as ROM */
		if (!info->list[i].mtd) {
			dev_warn(&dev->dev,
				"do_map_probe() failed for type %s\n",
				 probe_type);

			info->list[i].mtd = do_map_probe("map_rom",
							 &info->list[i].map);
		}
		mtd_list[i] = info->list[i].mtd;

		err = -ENXIO;
		if (!info->list[i].mtd) {
			dev_err(&dev->dev, "do_map_probe() failed\n");
			goto err_out;
		} else {
			info->list_size++;
		}
		info->list[i].mtd->owner = THIS_MODULE;
		info->list[i].mtd->dev.parent = &dev->dev;
	}

	err = 0;
	info->cmtd = NULL;
	if (info->list_size == 1) {
		info->cmtd = info->list[0].mtd;
	} else if (info->list_size > 1) {
		/*
		 * We detected multiple devices. Concatenate them together.
		 */
		info->cmtd = mtd_concat_create(mtd_list, info->list_size,
					       dev_name(&dev->dev));
	}
	if (info->cmtd == NULL)
		err = -ENXIO;

	if (err)
		goto err_out;

	ppdata.of_node = dp;
	part_probe_types = of_get_probes(dp);
	mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata,
			NULL, 0);
	of_free_probes(part_probe_types);

	kfree(mtd_list);

	return 0;

err_out:
	kfree(mtd_list);
err_flash_remove:
	of_flash_remove(dev);

	return err;
}

static struct of_device_id of_flash_match[] = {
	{
		.compatible	= "cfi-flash",
		.data		= (void *)"cfi_probe",
	},
	{
		/* FIXME: JEDEC chips can't be safely and reliably
		 * probed, although the mtd code gets it right in
		 * practice most of the time.  We should use the
		 * vendor and device ids specified by the binding to
		 * bypass the heuristic probe code, but the mtd layer
		 * provides, at present, no interface for doing so
		 * :(. */
		.compatible	= "jedec-flash",
		.data		= (void *)"jedec_probe",
	},
	{
		.compatible     = "mtd-ram",
		.data           = (void *)"map_ram",
	},
	{
		.compatible     = "mtd-rom",
		.data           = (void *)"map_rom",
	},
	{
		.type		= "rom",
		.compatible	= "direct-mapped"
	},
	{ },
};
MODULE_DEVICE_TABLE(of, of_flash_match);

static struct platform_driver of_flash_driver = {
	.driver = {
		.name = "of-flash",
		.of_match_table = of_flash_match,
	},
	.probe		= of_flash_probe,
	.remove		= of_flash_remove,
};

module_platform_driver(of_flash_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
MODULE_DESCRIPTION("Device tree based MTD map driver");
Commit	Line	Data
a2c2fe4b	1	/*
c4d5e375	2	* Flash mappings described by the OF (or flattened) device tree
a2c2fe4b VW	3	*
	4	* Copyright (C) 2006 MontaVista Software Inc.
	5	* Author: Vitaly Wool <vwool@ru.mvista.com>
	6	*
2099172d DG	7	* Revised to handle newer style flash binding by:
	8	* Copyright (C) 2007 David Gibson, IBM Corporation.
	9	*
a2c2fe4b VW	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the
	12	* Free Software Foundation; either version 2 of the License, or (at your
	13	* option) any later version.
	14	*/
	15
	16	#include <linux/module.h>
	17	#include <linux/types.h>
a2c2fe4b VW	18	#include <linux/device.h>
	19	#include <linux/mtd/mtd.h>
	20	#include <linux/mtd/map.h>
	21	#include <linux/mtd/partitions.h>
143070e7	22	#include <linux/mtd/concat.h>
c4d5e375	23	#include <linux/of.h>
7a50d06e	24	#include <linux/of_address.h>
c4d5e375	25	#include <linux/of_platform.h>
5a0e3ad6	26	#include <linux/slab.h>
a2c2fe4b	27
143070e7 SR	28	struct of_flash_list {
	29	struct mtd_info *mtd;
	30	struct map_info map;
	31	struct resource *res;
	32	};
	33
c4d5e375	34	struct of_flash {
143070e7	35	struct mtd_info *cmtd;
143070e7 SR	36	int list_size; /* number of elements in of_flash_list */
143070e7 SR	37	struct of_flash_list list[0];
a2c2fe4b VW	38	};
a2c2fe4b VW	39
2dc11581	40	static int of_flash_remove(struct platform_device *dev)
a2c2fe4b	41	{
c4d5e375	42	struct of_flash *info;
143070e7	43	int i;
a2c2fe4b VW	44
a2c2fe4b VW	45	info = dev_get_drvdata(&dev->dev);
c4d5e375	46	if (!info)
a2c2fe4b VW	47	return 0;
	48	dev_set_drvdata(&dev->dev, NULL);
	49
92b633a8	50	if (info->cmtd) {
984e6d8e	51	mtd_device_unregister(info->cmtd);
92b633a8 AB	52	if (info->cmtd != info->list[0].mtd)
92b633a8 AB	53	mtd_concat_destroy(info->cmtd);
143070e7	54	}
143070e7	55
143070e7 SR	56	for (i = 0; i < info->list_size; i++) {
	57	if (info->list[i].mtd)
	58	map_destroy(info->list[i].mtd);
a2c2fe4b	59
143070e7 SR	60	if (info->list[i].map.virt)
	61	iounmap(info->list[i].map.virt);
	62
	63	if (info->list[i].res) {
	64	release_resource(info->list[i].res);
	65	kfree(info->list[i].res);
	66	}
a2c2fe4b	67	}
a2c2fe4b VW	68	return 0;
	69	}
	70
cce2a026 AB	71	static const char * const rom_probe_types[] = {
	72	"cfi_probe", "jedec_probe", "map_rom" };
	73
2099172d DG	74	/* Helper function to handle probing of the obsolete "direct-mapped"
	75	* compatible binding, which has an extra "probe-type" property
	76	* describing the type of flash probe necessary. */
06f25510	77	static struct mtd_info obsolete_probe(struct platform_device dev,
d8929942	78	struct map_info *map)
a2c2fe4b	79	{
61c7a080	80	struct device_node *dp = dev->dev.of_node;
a2c2fe4b	81	const char *of_probe;
2099172d	82	struct mtd_info *mtd;
2099172d DG	83	int i;
	84
	85	dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
	86	"flash binding\n");
	87
	88	of_probe = of_get_property(dp, "probe-type", NULL);
	89	if (!of_probe) {
	90	for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
	91	mtd = do_map_probe(rom_probe_types[i], map);
	92	if (mtd)
	93	return mtd;
	94	}
	95	return NULL;
	96	} else if (strcmp(of_probe, "CFI") == 0) {
	97	return do_map_probe("cfi_probe", map);
	98	} else if (strcmp(of_probe, "JEDEC") == 0) {
	99	return do_map_probe("jedec_probe", map);
	100	} else {
	101	if (strcmp(of_probe, "ROM") != 0)
c4d5e375 DG	102	dev_warn(&dev->dev, "obsolete_probe: don't know probe "
c4d5e375 DG	103	"type '%s', mapping as rom\n", of_probe);
9b07a8d1	104	return do_map_probe("map_rom", map);
2099172d DG	105	}
	106	}
	107
9d5da3a9 JG	108	/* When partitions are set we look for a linux,part-probe property which
	109	specifies the list of partition probers to use. If none is given then the
	110	default is use. These take precedence over other device tree
	111	information. */
cce2a026 AB	112	static const char * const part_probe_types_def[] = {
	113	"cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
	114
	115	static const char * const of_get_probes(struct device_node dp)
9d5da3a9 JG	116	{
	117	const char *cp;
	118	int cplen;
	119	unsigned int l;
	120	unsigned int count;
	121	const char **res;
	122
	123	cp = of_get_property(dp, "linux,part-probe", &cplen);
	124	if (cp == NULL)
	125	return part_probe_types_def;
	126
	127	count = 0;
	128	for (l = 0; l != cplen; l++)
	129	if (cp[l] == 0)
	130	count++;
	131
	132	res = kzalloc((count + 1)sizeof(res), GFP_KERNEL);
	133	count = 0;
	134	while (cplen > 0) {
	135	res[count] = cp;
	136	l = strlen(cp) + 1;
	137	cp += l;
	138	cplen -= l;
	139	count++;
	140	}
	141	return res;
	142	}
	143
cce2a026	144	static void of_free_probes(const char * const *probes)
9d5da3a9 JG	145	{
	146	if (probes != part_probe_types_def)
	147	kfree(probes);
	148	}
9d5da3a9	149
b1608d69	150	static struct of_device_id of_flash_match[];
06f25510	151	static int of_flash_probe(struct platform_device *dev)
a2c2fe4b	152	{
cce2a026	153	const char * const *part_probe_types;
b1608d69	154	const struct of_device_id *match;
61c7a080	155	struct device_node *dp = dev->dev.of_node;
a2c2fe4b	156	struct resource res;
c4d5e375	157	struct of_flash *info;
1c48a5c9	158	const char *probe_type;
766f271a	159	const __be32 *width;
a2c2fe4b	160	int err;
143070e7 SR	161	int i;
143070e7 SR	162	int count;
766f271a	163	const __be32 *p;
143070e7 SR	164	int reg_tuple_size;
143070e7 SR	165	struct mtd_info **mtd_list = NULL;
2763c508	166	resource_size_t res_size;
5f4ba9f9	167	struct mtd_part_parser_data ppdata;
d0788ce4	168	bool map_indirect;
7dfe4be3	169	const char *mtd_name = NULL;
143070e7	170
b1608d69 GL	171	match = of_match_device(of_flash_match, &dev->dev);
b1608d69 GL	172	if (!match)
1c48a5c9	173	return -EINVAL;
b1608d69	174	probe_type = match->data;
1c48a5c9	175
143070e7 SR	176	reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
143070e7 SR	177
d68cbdd4 JCPV	178	of_property_read_string(dp, "linux,mtd-name", &mtd_name);
d68cbdd4 JCPV	179
143070e7 SR	180	/*
	181	* Get number of "reg" tuples. Scan for MTD devices on area's
	182	* described by each "reg" region. This makes it possible (including
	183	* the concat support) to support the Intel P30 48F4400 chips which
	184	* consists internally of 2 non-identical NOR chips on one die.
	185	*/
	186	p = of_get_property(dp, "reg", &count);
	187	if (count % reg_tuple_size != 0) {
	188	dev_err(&dev->dev, "Malformed reg property on %s\n",
61c7a080	189	dev->dev.of_node->full_name);
143070e7	190	err = -EINVAL;
ad4fbc79	191	goto err_flash_remove;
a2c2fe4b	192	}
143070e7	193	count /= reg_tuple_size;
a2c2fe4b	194
d0788ce4 SR	195	map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
d0788ce4 SR	196
c4d5e375	197	err = -ENOMEM;
eb82038f EG	198	info = devm_kzalloc(&dev->dev,
	199	sizeof(struct of_flash) +
	200	sizeof(struct of_flash_list) * count, GFP_KERNEL);
143070e7	201	if (!info)
ad4fbc79	202	goto err_flash_remove;
a2c2fe4b VW	203
	204	dev_set_drvdata(&dev->dev, info);
	205
e026255f	206	mtd_list = kzalloc(sizeof(mtd_list) count, GFP_KERNEL);
ad4fbc79	207	if (!mtd_list)
	208	goto err_flash_remove;
	209
143070e7 SR	210	for (i = 0; i < count; i++) {
	211	err = -ENXIO;
	212	if (of_address_to_resource(dp, i, &res)) {
940fe282 SR	213	/*
	214	* Continue with next register tuple if this
	215	* one is not mappable
	216	*/
	217	continue;
143070e7	218	}
a2c2fe4b	219
f9a5279c	220	dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
143070e7 SR	221
143070e7 SR	222	err = -EBUSY;
2763c508 WS	223	res_size = resource_size(&res);
2763c508 WS	224	info->list[i].res = request_mem_region(res.start, res_size,
143070e7 SR	225	dev_name(&dev->dev));
	226	if (!info->list[i].res)
	227	goto err_out;
	228
	229	err = -ENXIO;
	230	width = of_get_property(dp, "bank-width", NULL);
	231	if (!width) {
	232	dev_err(&dev->dev, "Can't get bank width from device"
	233	" tree\n");
	234	goto err_out;
	235	}
a2c2fe4b	236
d68cbdd4	237	info->list[i].map.name = mtd_name ?: dev_name(&dev->dev);
143070e7	238	info->list[i].map.phys = res.start;
2763c508	239	info->list[i].map.size = res_size;
766f271a	240	info->list[i].map.bankwidth = be32_to_cpup(width);
1648eaaa	241	info->list[i].map.device_node = dp;
143070e7 SR	242
	243	err = -ENOMEM;
	244	info->list[i].map.virt = ioremap(info->list[i].map.phys,
	245	info->list[i].map.size);
	246	if (!info->list[i].map.virt) {
	247	dev_err(&dev->dev, "Failed to ioremap() flash"
	248	" region\n");
	249	goto err_out;
	250	}
a2c2fe4b	251
143070e7	252	simple_map_init(&info->list[i].map);
a2c2fe4b	253
d0788ce4 SR	254	/*
	255	* On some platforms (e.g. MPC5200) a direct 1:1 mapping
	256	* may cause problems with JFFS2 usage, as the local bus (LPB)
	257	* doesn't support unaligned accesses as implemented in the
	258	* JFFS2 code via memcpy(). By setting NO_XIP, the
	259	* flash will not be exposed directly to the MTD users
	260	* (e.g. JFFS2) any more.
	261	*/
	262	if (map_indirect)
	263	info->list[i].map.phys = NO_XIP;
	264
143070e7 SR	265	if (probe_type) {
	266	info->list[i].mtd = do_map_probe(probe_type,
	267	&info->list[i].map);
	268	} else {
	269	info->list[i].mtd = obsolete_probe(dev,
	270	&info->list[i].map);
	271	}
3fc1cf5f JS	272
	273	/* Fall back to mapping region as ROM */
	274	if (!info->list[i].mtd) {
	275	dev_warn(&dev->dev,
	276	"do_map_probe() failed for type %s\n",
	277	probe_type);
	278
	279	info->list[i].mtd = do_map_probe("map_rom",
	280	&info->list[i].map);
	281	}
143070e7	282	mtd_list[i] = info->list[i].mtd;
a2c2fe4b	283
143070e7 SR	284	err = -ENXIO;
	285	if (!info->list[i].mtd) {
	286	dev_err(&dev->dev, "do_map_probe() failed\n");
	287	goto err_out;
	288	} else {
	289	info->list_size++;
	290	}
	291	info->list[i].mtd->owner = THIS_MODULE;
	292	info->list[i].mtd->dev.parent = &dev->dev;
	293	}
2099172d	294
143070e7	295	err = 0;
e58a66d8	296	info->cmtd = NULL;
143070e7 SR	297	if (info->list_size == 1) {
	298	info->cmtd = info->list[0].mtd;
	299	} else if (info->list_size > 1) {
	300	/*
	301	* We detected multiple devices. Concatenate them together.
	302	*/
143070e7 SR	303	info->cmtd = mtd_concat_create(mtd_list, info->list_size,
143070e7 SR	304	dev_name(&dev->dev));
a2c2fe4b	305	}
e58a66d8 AP	306	if (info->cmtd == NULL)
	307	err = -ENXIO;
	308
143070e7 SR	309	if (err)
143070e7 SR	310	goto err_out;
a2c2fe4b	311
5f4ba9f9	312	ppdata.of_node = dp;
9d5da3a9	313	part_probe_types = of_get_probes(dp);
f44dcbd0 DES	314	mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata,
f44dcbd0 DES	315	NULL, 0);
9d5da3a9	316	of_free_probes(part_probe_types);
9a310d21	317
143070e7	318	kfree(mtd_list);
a2c2fe4b	319
a2c2fe4b VW	320	return 0;
	321
	322	err_out:
143070e7	323	kfree(mtd_list);
ad4fbc79	324	err_flash_remove:
c4d5e375	325	of_flash_remove(dev);
143070e7	326
a2c2fe4b	327	return err;
a2c2fe4b VW	328	}
a2c2fe4b VW	329
c4d5e375	330	static struct of_device_id of_flash_match[] = {
2099172d DG	331	{
	332	.compatible = "cfi-flash",
	333	.data = (void *)"cfi_probe",
	334	},
	335	{
	336	/* FIXME: JEDEC chips can't be safely and reliably
	337	* probed, although the mtd code gets it right in
	338	* practice most of the time. We should use the
	339	* vendor and device ids specified by the binding to
	340	* bypass the heuristic probe code, but the mtd layer
	341	* provides, at present, no interface for doing so
	342	* :(. */
	343	.compatible = "jedec-flash",
	344	.data = (void *)"jedec_probe",
	345	},
fc28c39f WS	346	{
	347	.compatible = "mtd-ram",
	348	.data = (void *)"map_ram",
	349	},
e5bffb59 AS	350	{
	351	.compatible = "mtd-rom",
	352	.data = (void *)"map_rom",
	353	},
a2c2fe4b VW	354	{
	355	.type = "rom",
	356	.compatible = "direct-mapped"
	357	},
	358	{ },
	359	};
c4d5e375	360	MODULE_DEVICE_TABLE(of, of_flash_match);
a2c2fe4b	361
1c48a5c9	362	static struct platform_driver of_flash_driver = {
4018294b GL	363	.driver = {
4018294b GL	364	.name = "of-flash",
4018294b GL	365	.of_match_table = of_flash_match,
4018294b GL	366	},
c4d5e375 DG	367	.probe = of_flash_probe,
c4d5e375 DG	368	.remove = of_flash_remove,
a2c2fe4b VW	369	};
a2c2fe4b VW	370
f99640de	371	module_platform_driver(of_flash_driver);
a2c2fe4b VW	372
	373	MODULE_LICENSE("GPL");
	374	MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
c4d5e375	375	MODULE_DESCRIPTION("Device tree based MTD map driver");