[mirror_ubuntu-bionic-kernel.git] / drivers / mtd / maps / ixp2000.c

/*
 * $Id: ixp2000.c,v 1.9 2005/11/07 11:14:27 gleixner Exp $
 *
 * drivers/mtd/maps/ixp2000.c
 *
 * Mapping for the Intel XScale IXP2000 based systems
 *
 * Copyright (C) 2002 Intel Corp.
 * Copyright (C) 2003-2004 MontaVista Software, Inc.
 *
 * Original Author: Naeem M Afzal <naeem.m.afzal@intel.com>
 * Maintainer: Deepak Saxena <dsaxena@plexity.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

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

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

#include <asm/io.h>
#include <asm/hardware.h>
#include <asm/mach/flash.h>

#include <linux/reboot.h>

struct ixp2000_flash_info {
	struct		mtd_info *mtd;
	struct		map_info map;
	struct		mtd_partition *partitions;
	struct		resource *res;
};

static inline unsigned long flash_bank_setup(struct map_info *map, unsigned long ofs)
{
	unsigned long (*set_bank)(unsigned long) =
		(unsigned long(*)(unsigned long))map->map_priv_2;

	return (set_bank ? set_bank(ofs) : ofs);
}

#ifdef __ARMEB__
/*
 * Rev A0 and A1 of IXP2400 silicon have a broken addressing unit which
 * causes the lower address bits to be XORed with 0x11 on 8 bit accesses
 * and XORed with 0x10 on 16 bit accesses. See the spec update, erratum 44.
 */
static int erratum44_workaround = 0;

static inline unsigned long address_fix8_write(unsigned long addr)
{
	if (erratum44_workaround) {
		return (addr ^ 3);
	}
	return addr;
}
#else

#define address_fix8_write(x)	(x)
#endif

static map_word ixp2000_flash_read8(struct map_info *map, unsigned long ofs)
{
	map_word val;

	val.x[0] =  *((u8 *)(map->map_priv_1 + flash_bank_setup(map, ofs)));
	return val;
}

/*
 * We can't use the standard memcpy due to the broken SlowPort
 * address translation on rev A0 and A1 silicon and the fact that
 * we have banked flash.
 */
static void ixp2000_flash_copy_from(struct map_info *map, void *to,
			      unsigned long from, ssize_t len)
{
	from = flash_bank_setup(map, from);
	while(len--)
		*(__u8 *) to++ = *(__u8 *)(map->map_priv_1 + from++);
}

static void ixp2000_flash_write8(struct map_info *map, map_word d, unsigned long ofs)
{
	*(__u8 *) (address_fix8_write(map->map_priv_1 +
				      flash_bank_setup(map, ofs))) = d.x[0];
}

static void ixp2000_flash_copy_to(struct map_info *map, unsigned long to,
			    const void *from, ssize_t len)
{
	to = flash_bank_setup(map, to);
	while(len--) {
		unsigned long tmp = address_fix8_write(map->map_priv_1 + to++);
		*(__u8 *)(tmp) = *(__u8 *)(from++);
	}
}


static int ixp2000_flash_remove(struct platform_device *dev)
{
	struct flash_platform_data *plat = dev->dev.platform_data;
	struct ixp2000_flash_info *info = platform_get_drvdata(dev);

	platform_set_drvdata(dev, NULL);

	if(!info)
		return 0;

	if (info->mtd) {
		del_mtd_partitions(info->mtd);
		map_destroy(info->mtd);
	}
	if (info->map.map_priv_1)
		iounmap((void *) info->map.map_priv_1);

	kfree(info->partitions);

	if (info->res) {
		release_resource(info->res);
		kfree(info->res);
	}

	if (plat->exit)
		plat->exit();

	return 0;
}


static int ixp2000_flash_probe(struct platform_device *dev)
{
	static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
	struct ixp2000_flash_data *ixp_data = dev->dev.platform_data;
	struct flash_platform_data *plat;
	struct ixp2000_flash_info *info;
	unsigned long window_size;
	int err = -1;

	if (!ixp_data)
		return -ENODEV;

	plat = ixp_data->platform_data;
	if (!plat)
		return -ENODEV;

	window_size = dev->resource->end - dev->resource->start + 1;
	dev_info(&dev->dev, "Probe of IXP2000 flash(%d banks x %dMiB)\n",
		 ixp_data->nr_banks, ((u32)window_size >> 20));

	if (plat->width != 1) {
		dev_err(&dev->dev, "IXP2000 MTD map only supports 8-bit mode, asking for %d\n",
			plat->width * 8);
		return -EIO;
	}

	info = kmalloc(sizeof(struct ixp2000_flash_info), GFP_KERNEL);
	if(!info) {
		err = -ENOMEM;
		goto Error;
	}
	memzero(info, sizeof(struct ixp2000_flash_info));

	platform_set_drvdata(dev, info);

	/*
	 * Tell the MTD layer we're not 1:1 mapped so that it does
	 * not attempt to do a direct access on us.
	 */
	info->map.phys = NO_XIP;

	info->map.size = ixp_data->nr_banks * window_size;
	info->map.bankwidth = 1;

	/*
 	 * map_priv_2 is used to store a ptr to to the bank_setup routine
 	 */
	info->map.map_priv_2 = (unsigned long) ixp_data->bank_setup;

	info->map.name = dev->dev.bus_id;
	info->map.read = ixp2000_flash_read8;
	info->map.write = ixp2000_flash_write8;
	info->map.copy_from = ixp2000_flash_copy_from;
	info->map.copy_to = ixp2000_flash_copy_to;

	info->res = request_mem_region(dev->resource->start,
			dev->resource->end - dev->resource->start + 1,
			dev->dev.bus_id);
	if (!info->res) {
		dev_err(&dev->dev, "Could not reserve memory region\n");
		err = -ENOMEM;
		goto Error;
	}

	info->map.map_priv_1 = (unsigned long) ioremap(dev->resource->start,
			    	dev->resource->end - dev->resource->start + 1);
	if (!info->map.map_priv_1) {
		dev_err(&dev->dev, "Failed to ioremap flash region\n");
		err = -EIO;
		goto Error;
	}

#if defined(__ARMEB__)
	/*
	 * Enable erratum 44 workaround for NPUs with broken slowport
	 */

	erratum44_workaround = ixp2000_has_broken_slowport();
	dev_info(&dev->dev, "Erratum 44 workaround %s\n",
	       erratum44_workaround ? "enabled" : "disabled");
#endif

	info->mtd = do_map_probe(plat->map_name, &info->map);
	if (!info->mtd) {
		dev_err(&dev->dev, "map_probe failed\n");
		err = -ENXIO;
		goto Error;
	}
	info->mtd->owner = THIS_MODULE;

	err = parse_mtd_partitions(info->mtd, probes, &info->partitions, 0);
	if (err > 0) {
		err = add_mtd_partitions(info->mtd, info->partitions, err);
		if(err)
			dev_err(&dev->dev, "Could not parse partitions\n");
	}

	if (err)
		goto Error;

	return 0;

Error:
	ixp2000_flash_remove(dev);
	return err;
}

static struct platform_driver ixp2000_flash_driver = {
	.probe		= ixp2000_flash_probe,
	.remove		= ixp2000_flash_remove,
	.driver		= {
		.name	= "IXP2000-Flash",
	},
};

static int __init ixp2000_flash_init(void)
{
	return platform_driver_register(&ixp2000_flash_driver);
}

static void __exit ixp2000_flash_exit(void)
{
	platform_driver_unregister(&ixp2000_flash_driver);
}

module_init(ixp2000_flash_init);
module_exit(ixp2000_flash_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net>");
Commit	Line	Data
1da177e4	1	/*
69f34c98	2	* $Id: ixp2000.c,v 1.9 2005/11/07 11:14:27 gleixner Exp $
1da177e4 LT	3	*
	4	* drivers/mtd/maps/ixp2000.c
	5	*
	6	* Mapping for the Intel XScale IXP2000 based systems
	7	*
	8	* Copyright (C) 2002 Intel Corp.
	9	* Copyright (C) 2003-2004 MontaVista Software, Inc.
	10	*
	11	* Original Author: Naeem M Afzal <naeem.m.afzal@intel.com>
	12	* Maintainer: Deepak Saxena <dsaxena@plexity.net>
	13	*
	14	* This program is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License version 2 as
	16	* published by the Free Software Foundation.
69f34c98	17	*
1da177e4 LT	18	*/
	19
	20	#include <linux/module.h>
	21	#include <linux/types.h>
	22	#include <linux/init.h>
	23	#include <linux/kernel.h>
	24	#include <linux/string.h>
4e57b681 TS	25	#include <linux/slab.h>
	26	#include <linux/ioport.h>
	27	#include <linux/device.h>
4fd5f826	28	#include <linux/platform_device.h>
4e57b681	29
1da177e4 LT	30	#include <linux/mtd/mtd.h>
	31	#include <linux/mtd/map.h>
	32	#include <linux/mtd/partitions.h>
1da177e4 LT	33
	34	#include <asm/io.h>
	35	#include <asm/hardware.h>
1da177e4 LT	36	#include <asm/mach/flash.h>
	37
	38	#include <linux/reboot.h>
	39
	40	struct ixp2000_flash_info {
	41	struct mtd_info *mtd;
	42	struct map_info map;
	43	struct mtd_partition *partitions;
	44	struct resource *res;
1da177e4 LT	45	};
	46
	47	static inline unsigned long flash_bank_setup(struct map_info *map, unsigned long ofs)
69f34c98 TG	48	{
69f34c98 TG	49	unsigned long (*set_bank)(unsigned long) =
1da177e4 LT	50	(unsigned long(*)(unsigned long))map->map_priv_2;
	51
	52	return (set_bank ? set_bank(ofs) : ofs);
	53	}
	54
	55	#ifdef __ARMEB__
	56	/*
69f34c98 TG	57	* Rev A0 and A1 of IXP2400 silicon have a broken addressing unit which
69f34c98 TG	58	* causes the lower address bits to be XORed with 0x11 on 8 bit accesses
1da177e4 LT	59	* and XORed with 0x10 on 16 bit accesses. See the spec update, erratum 44.
	60	*/
	61	static int erratum44_workaround = 0;
	62
	63	static inline unsigned long address_fix8_write(unsigned long addr)
	64	{
	65	if (erratum44_workaround) {
	66	return (addr ^ 3);
	67	}
	68	return addr;
	69	}
	70	#else
	71
	72	#define address_fix8_write(x) (x)
	73	#endif
	74
	75	static map_word ixp2000_flash_read8(struct map_info *map, unsigned long ofs)
	76	{
	77	map_word val;
	78
	79	val.x[0] = ((u8 )(map->map_priv_1 + flash_bank_setup(map, ofs)));
	80	return val;
	81	}
	82
	83	/*
	84	* We can't use the standard memcpy due to the broken SlowPort
	85	* address translation on rev A0 and A1 silicon and the fact that
	86	* we have banked flash.
	87	*/
	88	static void ixp2000_flash_copy_from(struct map_info map, void to,
	89	unsigned long from, ssize_t len)
	90	{
	91	from = flash_bank_setup(map, from);
69f34c98	92	while(len--)
1da177e4 LT	93	(__u8 ) to++ = (__u8 )(map->map_priv_1 + from++);
	94	}
	95
	96	static void ixp2000_flash_write8(struct map_info *map, map_word d, unsigned long ofs)
	97	{
	98	(__u8 ) (address_fix8_write(map->map_priv_1 +
	99	flash_bank_setup(map, ofs))) = d.x[0];
	100	}
	101
	102	static void ixp2000_flash_copy_to(struct map_info *map, unsigned long to,
	103	const void *from, ssize_t len)
	104	{
	105	to = flash_bank_setup(map, to);
	106	while(len--) {
	107	unsigned long tmp = address_fix8_write(map->map_priv_1 + to++);
	108	(__u8 )(tmp) = (__u8 )(from++);
	109	}
	110	}
	111
	112
3ae5eaec	113	static int ixp2000_flash_remove(struct platform_device *dev)
1da177e4	114	{
1da177e4	115	struct flash_platform_data *plat = dev->dev.platform_data;
3ae5eaec	116	struct ixp2000_flash_info *info = platform_get_drvdata(dev);
1da177e4	117
3ae5eaec	118	platform_set_drvdata(dev, NULL);
1da177e4 LT	119
	120	if(!info)
	121	return 0;
	122
	123	if (info->mtd) {
	124	del_mtd_partitions(info->mtd);
	125	map_destroy(info->mtd);
	126	}
	127	if (info->map.map_priv_1)
	128	iounmap((void *) info->map.map_priv_1);
	129
fa671646	130	kfree(info->partitions);
1da177e4 LT	131
	132	if (info->res) {
	133	release_resource(info->res);
	134	kfree(info->res);
	135	}
	136
	137	if (plat->exit)
	138	plat->exit();
	139
	140	return 0;
	141	}
	142
	143
3ae5eaec	144	static int ixp2000_flash_probe(struct platform_device *dev)
1da177e4 LT	145	{
1da177e4 LT	146	static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
1da177e4	147	struct ixp2000_flash_data *ixp_data = dev->dev.platform_data;
69f34c98	148	struct flash_platform_data *plat;
1da177e4 LT	149	struct ixp2000_flash_info *info;
	150	unsigned long window_size;
	151	int err = -1;
69f34c98	152
1da177e4 LT	153	if (!ixp_data)
	154	return -ENODEV;
	155
	156	plat = ixp_data->platform_data;
	157	if (!plat)
	158	return -ENODEV;
	159
	160	window_size = dev->resource->end - dev->resource->start + 1;
7d78c887 RK	161	dev_info(&dev->dev, "Probe of IXP2000 flash(%d banks x %dMiB)\n",
7d78c887 RK	162	ixp_data->nr_banks, ((u32)window_size >> 20));
1da177e4 LT	163
1da177e4 LT	164	if (plat->width != 1) {
7d78c887 RK	165	dev_err(&dev->dev, "IXP2000 MTD map only supports 8-bit mode, asking for %d\n",
7d78c887 RK	166	plat->width * 8);
1da177e4 LT	167	return -EIO;
	168	}
	169
	170	info = kmalloc(sizeof(struct ixp2000_flash_info), GFP_KERNEL);
	171	if(!info) {
	172	err = -ENOMEM;
	173	goto Error;
69f34c98	174	}
1da177e4 LT	175	memzero(info, sizeof(struct ixp2000_flash_info));
1da177e4 LT	176
3ae5eaec	177	platform_set_drvdata(dev, info);
1da177e4 LT	178
	179	/*
	180	* Tell the MTD layer we're not 1:1 mapped so that it does
	181	* not attempt to do a direct access on us.
	182	*/
	183	info->map.phys = NO_XIP;
69f34c98	184
1da177e4 LT	185	info->map.size = ixp_data->nr_banks * window_size;
	186	info->map.bankwidth = 1;
	187
	188	/*
	189	* map_priv_2 is used to store a ptr to to the bank_setup routine
	190	*/
ea17629f	191	info->map.map_priv_2 = (unsigned long) ixp_data->bank_setup;
1da177e4 LT	192
	193	info->map.name = dev->dev.bus_id;
	194	info->map.read = ixp2000_flash_read8;
	195	info->map.write = ixp2000_flash_write8;
	196	info->map.copy_from = ixp2000_flash_copy_from;
	197	info->map.copy_to = ixp2000_flash_copy_to;
	198
69f34c98 TG	199	info->res = request_mem_region(dev->resource->start,
69f34c98 TG	200	dev->resource->end - dev->resource->start + 1,
1da177e4 LT	201	dev->dev.bus_id);
1da177e4 LT	202	if (!info->res) {
7d78c887	203	dev_err(&dev->dev, "Could not reserve memory region\n");
1da177e4 LT	204	err = -ENOMEM;
	205	goto Error;
	206	}
	207
69f34c98	208	info->map.map_priv_1 = (unsigned long) ioremap(dev->resource->start,
1da177e4 LT	209	dev->resource->end - dev->resource->start + 1);
1da177e4 LT	210	if (!info->map.map_priv_1) {
7d78c887	211	dev_err(&dev->dev, "Failed to ioremap flash region\n");
1da177e4 LT	212	err = -EIO;
	213	goto Error;
	214	}
	215
1da177e4 LT	216	#if defined(__ARMEB__)
	217	/*
	218	* Enable erratum 44 workaround for NPUs with broken slowport
	219	*/
	220
	221	erratum44_workaround = ixp2000_has_broken_slowport();
7d78c887	222	dev_info(&dev->dev, "Erratum 44 workaround %s\n",
1da177e4 LT	223	erratum44_workaround ? "enabled" : "disabled");
	224	#endif
	225
	226	info->mtd = do_map_probe(plat->map_name, &info->map);
	227	if (!info->mtd) {
7d78c887	228	dev_err(&dev->dev, "map_probe failed\n");
1da177e4 LT	229	err = -ENXIO;
	230	goto Error;
	231	}
	232	info->mtd->owner = THIS_MODULE;
	233
	234	err = parse_mtd_partitions(info->mtd, probes, &info->partitions, 0);
	235	if (err > 0) {
	236	err = add_mtd_partitions(info->mtd, info->partitions, err);
	237	if(err)
7d78c887	238	dev_err(&dev->dev, "Could not parse partitions\n");
1da177e4 LT	239	}
	240
	241	if (err)
	242	goto Error;
	243
	244	return 0;
	245
	246	Error:
3ae5eaec	247	ixp2000_flash_remove(dev);
1da177e4 LT	248	return err;
	249	}
	250
3ae5eaec	251	static struct platform_driver ixp2000_flash_driver = {
7d78c887 RK	252	.probe = ixp2000_flash_probe,
7d78c887 RK	253	.remove = ixp2000_flash_remove,
3ae5eaec RK	254	.driver = {
	255	.name = "IXP2000-Flash",
	256	},
1da177e4 LT	257	};
	258
	259	static int __init ixp2000_flash_init(void)
	260	{
3ae5eaec	261	return platform_driver_register(&ixp2000_flash_driver);
1da177e4 LT	262	}
	263
	264	static void __exit ixp2000_flash_exit(void)
	265	{
3ae5eaec	266	platform_driver_unregister(&ixp2000_flash_driver);
1da177e4 LT	267	}
	268
	269	module_init(ixp2000_flash_init);
	270	module_exit(ixp2000_flash_exit);
	271	MODULE_LICENSE("GPL");
	272	MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net>");
	273