[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 != info->list[0].mtd) {
		mtd_device_unregister(info->cmtd);
		mtd_concat_destroy(info->cmtd);
	}

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