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

/* fortunet.c memory map
 *
 */

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

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

#include <asm/io.h>

#define MAX_NUM_REGIONS		4
#define MAX_NUM_PARTITIONS	8

#define DEF_WINDOW_ADDR_PHY	0x00000000
#define DEF_WINDOW_SIZE		0x00800000		// 8 Mega Bytes

#define MTD_FORTUNET_PK		"MTD FortuNet: "

#define MAX_NAME_SIZE		128

struct map_region
{
	int			window_addr_physical;
	int			altbankwidth;
	struct map_info		map_info;
	struct mtd_info		*mymtd;
	struct mtd_partition	parts[MAX_NUM_PARTITIONS];
	char			map_name[MAX_NAME_SIZE];
	char			parts_name[MAX_NUM_PARTITIONS][MAX_NAME_SIZE];
};

static struct map_region	map_regions[MAX_NUM_REGIONS];
static int			map_regions_set[MAX_NUM_REGIONS] = {0,0,0,0};
static int			map_regions_parts[MAX_NUM_REGIONS] = {0,0,0,0};


struct map_info default_map = {
	.size = DEF_WINDOW_SIZE,
	.bankwidth = 4,
};

static char * __init get_string_option(char *dest,int dest_size,char *sor)
{
	if(!dest_size)
		return sor;
	dest_size--;
	while(*sor)
	{
		if(*sor==',')
		{
			sor++;
			break;
		}
		else if(*sor=='\"')
		{
			sor++;
			while(*sor)
			{
				if(*sor=='\"')
				{
					sor++;
					break;
				}
				*dest = *sor;
				dest++;
				sor++;
				dest_size--;
				if(!dest_size)
				{
					*dest = 0;
					return sor;
				}
			}
		}
		else
		{
			*dest = *sor;
			dest++;
			sor++;
			dest_size--;
			if(!dest_size)
			{
				*dest = 0;
				return sor;
			}
		}
	}
	*dest = 0;
	return sor;
}

static int __init MTD_New_Region(char *line)
{
	char	string[MAX_NAME_SIZE];
	int	params[6];
	get_options (get_string_option(string,sizeof(string),line),6,params);
	if(params[0]<1)
	{
		printk(MTD_FORTUNET_PK "Bad parameters for MTD Region "
			" name,region-number[,base,size,bankwidth,altbankwidth]\n");
		return 1;
	}
	if((params[1]<0)||(params[1]>=MAX_NUM_REGIONS))
	{
		printk(MTD_FORTUNET_PK "Bad region index of %d only have 0..%u regions\n",
			params[1],MAX_NUM_REGIONS-1);
		return 1;
	}
	memset(&map_regions[params[1]],0,sizeof(map_regions[params[1]]));
	memcpy(&map_regions[params[1]].map_info,
		&default_map,sizeof(map_regions[params[1]].map_info));
        map_regions_set[params[1]] = 1;
        map_regions[params[1]].window_addr_physical = DEF_WINDOW_ADDR_PHY;
        map_regions[params[1]].altbankwidth = 2;
        map_regions[params[1]].mymtd = NULL;
	map_regions[params[1]].map_info.name = map_regions[params[1]].map_name;
	strcpy(map_regions[params[1]].map_info.name,string);
	if(params[0]>1)
	{
		map_regions[params[1]].window_addr_physical = params[2];
	}
	if(params[0]>2)
	{
		map_regions[params[1]].map_info.size = params[3];
	}
	if(params[0]>3)
	{
		map_regions[params[1]].map_info.bankwidth = params[4];
	}
	if(params[0]>4)
	{
		map_regions[params[1]].altbankwidth = params[5];
	}
	return 1;
}

static int __init MTD_New_Partition(char *line)
{
	char	string[MAX_NAME_SIZE];
	int	params[4];
	get_options (get_string_option(string,sizeof(string),line),4,params);
	if(params[0]<3)
	{
		printk(MTD_FORTUNET_PK "Bad parameters for MTD Partition "
			" name,region-number,size,offset\n");
		return 1;
	}
	if((params[1]<0)||(params[1]>=MAX_NUM_REGIONS))
	{
		printk(MTD_FORTUNET_PK "Bad region index of %d only have 0..%u regions\n",
			params[1],MAX_NUM_REGIONS-1);
		return 1;
	}
	if(map_regions_parts[params[1]]>=MAX_NUM_PARTITIONS)
	{
		printk(MTD_FORTUNET_PK "Out of space for partition in this region\n");
		return 1;
	}
	map_regions[params[1]].parts[map_regions_parts[params[1]]].name =
		map_regions[params[1]].	parts_name[map_regions_parts[params[1]]];
	strcpy(map_regions[params[1]].parts[map_regions_parts[params[1]]].name,string);
	map_regions[params[1]].parts[map_regions_parts[params[1]]].size =
		params[2];
	map_regions[params[1]].parts[map_regions_parts[params[1]]].offset =
		params[3];
	map_regions[params[1]].parts[map_regions_parts[params[1]]].mask_flags = 0;
	map_regions_parts[params[1]]++;
	return 1;
}

__setup("MTD_Region=", MTD_New_Region);
__setup("MTD_Partition=", MTD_New_Partition);

/* Backwards-spelling-compatibility */
__setup("MTD_Partion=", MTD_New_Partition);

static int __init init_fortunet(void)
{
	int	ix,iy;
	for(iy=ix=0;ix<MAX_NUM_REGIONS;ix++)
	{
		if(map_regions_parts[ix]&&(!map_regions_set[ix]))
		{
			printk(MTD_FORTUNET_PK "Region %d is not setup (Setting to default)\n",
				ix);
			memset(&map_regions[ix],0,sizeof(map_regions[ix]));
			memcpy(&map_regions[ix].map_info,&default_map,
				sizeof(map_regions[ix].map_info));
			map_regions_set[ix] = 1;
			map_regions[ix].window_addr_physical = DEF_WINDOW_ADDR_PHY;
			map_regions[ix].altbankwidth = 2;
			map_regions[ix].mymtd = NULL;
			map_regions[ix].map_info.name = map_regions[ix].map_name;
			strcpy(map_regions[ix].map_info.name,"FORTUNET");
		}
		if(map_regions_set[ix])
		{
			iy++;
			printk(KERN_NOTICE MTD_FORTUNET_PK "%s flash device at physically "
				" address %x size %x\n",
				map_regions[ix].map_info.name,
				map_regions[ix].window_addr_physical,
				map_regions[ix].map_info.size);

			map_regions[ix].map_info.phys =	map_regions[ix].window_addr_physical,

			map_regions[ix].map_info.virt =
				ioremap_nocache(
				map_regions[ix].window_addr_physical,
				map_regions[ix].map_info.size);
			if(!map_regions[ix].map_info.virt)
			{
				int j = 0;
				printk(MTD_FORTUNET_PK "%s flash failed to ioremap!\n",
					map_regions[ix].map_info.name);
				for (j = 0 ; j < ix; j++)
					iounmap(map_regions[j].map_info.virt);
				return -ENXIO;
			}
			simple_map_init(&map_regions[ix].map_info);

			printk(KERN_NOTICE MTD_FORTUNET_PK "%s flash is virtually at: %x\n",
				map_regions[ix].map_info.name,
				map_regions[ix].map_info.virt);
			map_regions[ix].mymtd = do_map_probe("cfi_probe",
				&map_regions[ix].map_info);
			if((!map_regions[ix].mymtd)&&(
				map_regions[ix].altbankwidth!=map_regions[ix].map_info.bankwidth))
			{
				printk(KERN_NOTICE MTD_FORTUNET_PK "Trying alternate bankwidth "
					"for %s flash.\n",
					map_regions[ix].map_info.name);
				map_regions[ix].map_info.bankwidth =
					map_regions[ix].altbankwidth;
				map_regions[ix].mymtd = do_map_probe("cfi_probe",
					&map_regions[ix].map_info);
			}
			map_regions[ix].mymtd->owner = THIS_MODULE;
			add_mtd_partitions(map_regions[ix].mymtd,
				map_regions[ix].parts,map_regions_parts[ix]);
		}
	}
	if(iy)
		return 0;
	return -ENXIO;
}

static void __exit cleanup_fortunet(void)
{
	int	ix;
	for(ix=0;ix<MAX_NUM_REGIONS;ix++)
	{
		if(map_regions_set[ix])
		{
			if( map_regions[ix].mymtd )
			{
				del_mtd_partitions( map_regions[ix].mymtd );
				map_destroy( map_regions[ix].mymtd );
			}
			iounmap((void *)map_regions[ix].map_info.virt);
		}
	}
}

module_init(init_fortunet);
module_exit(cleanup_fortunet);

MODULE_AUTHOR("FortuNet, Inc.");
MODULE_DESCRIPTION("MTD map driver for FortuNet boards");
Commit	Line	Data
1da177e4 LT	1	/* fortunet.c memory map
1da177e4 LT	2	*
1da177e4 LT	3	*/
	4
	5	#include <linux/module.h>
	6	#include <linux/types.h>
	7	#include <linux/kernel.h>
	8	#include <linux/init.h>
4e57b681 TS	9	#include <linux/string.h>
4e57b681 TS	10
1da177e4 LT	11	#include <linux/mtd/mtd.h>
	12	#include <linux/mtd/map.h>
	13	#include <linux/mtd/partitions.h>
	14
4e57b681 TS	15	#include <asm/io.h>
4e57b681 TS	16
1da177e4 LT	17	#define MAX_NUM_REGIONS 4
	18	#define MAX_NUM_PARTITIONS 8
	19
	20	#define DEF_WINDOW_ADDR_PHY 0x00000000
	21	#define DEF_WINDOW_SIZE 0x00800000 // 8 Mega Bytes
	22
	23	#define MTD_FORTUNET_PK "MTD FortuNet: "
	24
	25	#define MAX_NAME_SIZE 128
	26
	27	struct map_region
	28	{
	29	int window_addr_physical;
	30	int altbankwidth;
	31	struct map_info map_info;
	32	struct mtd_info *mymtd;
	33	struct mtd_partition parts[MAX_NUM_PARTITIONS];
	34	char map_name[MAX_NAME_SIZE];
	35	char parts_name[MAX_NUM_PARTITIONS][MAX_NAME_SIZE];
	36	};
	37
	38	static struct map_region map_regions[MAX_NUM_REGIONS];
	39	static int map_regions_set[MAX_NUM_REGIONS] = {0,0,0,0};
	40	static int map_regions_parts[MAX_NUM_REGIONS] = {0,0,0,0};
	41
	42
	43
	44	struct map_info default_map = {
	45	.size = DEF_WINDOW_SIZE,
	46	.bankwidth = 4,
	47	};
	48
	49	static char * __init get_string_option(char dest,int dest_size,char sor)
	50	{
	51	if(!dest_size)
	52	return sor;
	53	dest_size--;
	54	while(*sor)
	55	{
	56	if(*sor==',')
	57	{
	58	sor++;
	59	break;
	60	}
	61	else if(*sor=='\"')
	62	{
	63	sor++;
	64	while(*sor)
	65	{
	66	if(*sor=='\"')
	67	{
	68	sor++;
	69	break;
	70	}
	71	dest = sor;
	72	dest++;
	73	sor++;
	74	dest_size--;
	75	if(!dest_size)
	76	{
	77	*dest = 0;
	78	return sor;
	79	}
	80	}
81	}
82	else
83	{
84	dest = sor;
85	dest++;
86	sor++;
87	dest_size--;
88	if(!dest_size)
89	{
90	*dest = 0;
91	return sor;
92	}
93	}
94	}
95	*dest = 0;
96	return sor;
97	}
98
99	static int __init MTD_New_Region(char *line)
100	{
101	char string[MAX_NAME_SIZE];
102	int params[6];
103	get_options (get_string_option(string,sizeof(string),line),6,params);
104	if(params[0]<1)
105	{
106	printk(MTD_FORTUNET_PK "Bad parameters for MTD Region "
107	" name,region-number[,base,size,bankwidth,altbankwidth]\n");
108	return 1;
109	}
110	if((params[1]<0)\|\|(params[1]>=MAX_NUM_REGIONS))
111	{
112	printk(MTD_FORTUNET_PK "Bad region index of %d only have 0..%u regions\n",
113	params[1],MAX_NUM_REGIONS-1);
114	return 1;
115	}
116	memset(&map_regions[params[1]],0,sizeof(map_regions[params[1]]));
117	memcpy(&map_regions[params[1]].map_info,
118	&default_map,sizeof(map_regions[params[1]].map_info));
119	map_regions_set[params[1]] = 1;
120	map_regions[params[1]].window_addr_physical = DEF_WINDOW_ADDR_PHY;
121	map_regions[params[1]].altbankwidth = 2;
122	map_regions[params[1]].mymtd = NULL;
123	map_regions[params[1]].map_info.name = map_regions[params[1]].map_name;
124	strcpy(map_regions[params[1]].map_info.name,string);
125	if(params[0]>1)
126	{
127	map_regions[params[1]].window_addr_physical = params[2];
128	}
129	if(params[0]>2)
130	{
131	map_regions[params[1]].map_info.size = params[3];
132	}
133	if(params[0]>3)
134	{
135	map_regions[params[1]].map_info.bankwidth = params[4];
136	}
137	if(params[0]>4)
138	{
139	map_regions[params[1]].altbankwidth = params[5];
140	}
141	return 1;
142	}
143
144	static int __init MTD_New_Partition(char *line)
145	{
146	char string[MAX_NAME_SIZE];
147	int params[4];
148	get_options (get_string_option(string,sizeof(string),line),4,params);
149	if(params[0]<3)
150	{
151	printk(MTD_FORTUNET_PK "Bad parameters for MTD Partition "
152	" name,region-number,size,offset\n");
153	return 1;
154	}
155	if((params[1]<0)\|\|(params[1]>=MAX_NUM_REGIONS))
156	{
157	printk(MTD_FORTUNET_PK "Bad region index of %d only have 0..%u regions\n",
158	params[1],MAX_NUM_REGIONS-1);
159	return 1;
160	}
161	if(map_regions_parts[params[1]]>=MAX_NUM_PARTITIONS)
162	{
163	printk(MTD_FORTUNET_PK "Out of space for partition in this region\n");
164	return 1;
165	}
166	map_regions[params[1]].parts[map_regions_parts[params[1]]].name =
167	map_regions[params[1]]. parts_name[map_regions_parts[params[1]]];
168	strcpy(map_regions[params[1]].parts[map_regions_parts[params[1]]].name,string);
169	map_regions[params[1]].parts[map_regions_parts[params[1]]].size =
170	params[2];
171	map_regions[params[1]].parts[map_regions_parts[params[1]]].offset =
172	params[3];
173	map_regions[params[1]].parts[map_regions_parts[params[1]]].mask_flags = 0;
174	map_regions_parts[params[1]]++;
175	return 1;
176	}
177
178	__setup("MTD_Region=", MTD_New_Region);
179	__setup("MTD_Partition=", MTD_New_Partition);
180
181	/* Backwards-spelling-compatibility */
182	__setup("MTD_Partion=", MTD_New_Partition);
183
e63b3f94	184	static int __init init_fortunet(void)
1da177e4 LT	185	{
	186	int ix,iy;
	187	for(iy=ix=0;ix<MAX_NUM_REGIONS;ix++)
	188	{
	189	if(map_regions_parts[ix]&&(!map_regions_set[ix]))
	190	{
	191	printk(MTD_FORTUNET_PK "Region %d is not setup (Setting to default)\n",
	192	ix);
	193	memset(&map_regions[ix],0,sizeof(map_regions[ix]));
	194	memcpy(&map_regions[ix].map_info,&default_map,
	195	sizeof(map_regions[ix].map_info));
	196	map_regions_set[ix] = 1;
	197	map_regions[ix].window_addr_physical = DEF_WINDOW_ADDR_PHY;
	198	map_regions[ix].altbankwidth = 2;
	199	map_regions[ix].mymtd = NULL;
	200	map_regions[ix].map_info.name = map_regions[ix].map_name;
	201	strcpy(map_regions[ix].map_info.name,"FORTUNET");
	202	}
	203	if(map_regions_set[ix])
	204	{
	205	iy++;
	206	printk(KERN_NOTICE MTD_FORTUNET_PK "%s flash device at physically "
	207	" address %x size %x\n",
	208	map_regions[ix].map_info.name,
	209	map_regions[ix].window_addr_physical,
	210	map_regions[ix].map_info.size);
	211
	212	map_regions[ix].map_info.phys = map_regions[ix].window_addr_physical,
	213
69f34c98	214	map_regions[ix].map_info.virt =
1da177e4 LT	215	ioremap_nocache(
	216	map_regions[ix].window_addr_physical,
	217	map_regions[ix].map_info.size);
	218	if(!map_regions[ix].map_info.virt)
	219	{
25f0c659	220	int j = 0;
1da177e4 LT	221	printk(MTD_FORTUNET_PK "%s flash failed to ioremap!\n",
1da177e4 LT	222	map_regions[ix].map_info.name);
25f0c659 AL	223	for (j = 0 ; j < ix; j++)
25f0c659 AL	224	iounmap(map_regions[j].map_info.virt);
1da177e4 LT	225	return -ENXIO;
	226	}
	227	simple_map_init(&map_regions[ix].map_info);
	228
	229	printk(KERN_NOTICE MTD_FORTUNET_PK "%s flash is virtually at: %x\n",
	230	map_regions[ix].map_info.name,
	231	map_regions[ix].map_info.virt);
	232	map_regions[ix].mymtd = do_map_probe("cfi_probe",
	233	&map_regions[ix].map_info);
	234	if((!map_regions[ix].mymtd)&&(
	235	map_regions[ix].altbankwidth!=map_regions[ix].map_info.bankwidth))
	236	{
	237	printk(KERN_NOTICE MTD_FORTUNET_PK "Trying alternate bankwidth "
	238	"for %s flash.\n",
	239	map_regions[ix].map_info.name);
	240	map_regions[ix].map_info.bankwidth =
	241	map_regions[ix].altbankwidth;
	242	map_regions[ix].mymtd = do_map_probe("cfi_probe",
	243	&map_regions[ix].map_info);
	244	}
	245	map_regions[ix].mymtd->owner = THIS_MODULE;
	246	add_mtd_partitions(map_regions[ix].mymtd,
	247	map_regions[ix].parts,map_regions_parts[ix]);
	248	}
	249	}
	250	if(iy)
	251	return 0;
	252	return -ENXIO;
	253	}
	254
	255	static void __exit cleanup_fortunet(void)
	256	{
	257	int ix;
	258	for(ix=0;ix<MAX_NUM_REGIONS;ix++)
	259	{
	260	if(map_regions_set[ix])
	261	{
	262	if( map_regions[ix].mymtd )
	263	{
	264	del_mtd_partitions( map_regions[ix].mymtd );
	265	map_destroy( map_regions[ix].mymtd );
	266	}
	267	iounmap((void *)map_regions[ix].map_info.virt);
	268	}
	269	}
	270	}
	271
	272	module_init(init_fortunet);
	273	module_exit(cleanup_fortunet);
	274
	275	MODULE_AUTHOR("FortuNet, Inc.");
	276	MODULE_DESCRIPTION("MTD map driver for FortuNet boards");