[net-next-2.6.git] / arch / mips / alchemy / devboards / platform.c

/*
 * devoard misc stuff.
 */

#include <linux/init.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/physmap.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/pm.h>

#include <asm/reboot.h>
#include <asm/mach-db1x00/bcsr.h>

static void db1x_power_off(void)
{
	bcsr_write(BCSR_RESETS, 0);
	bcsr_write(BCSR_SYSTEM, BCSR_SYSTEM_PWROFF | BCSR_SYSTEM_RESET);
}

static void db1x_reset(char *c)
{
	bcsr_write(BCSR_RESETS, 0);
	bcsr_write(BCSR_SYSTEM, 0);
}

static int __init db1x_poweroff_setup(void)
{
	if (!pm_power_off)
		pm_power_off = db1x_power_off;
	if (!_machine_halt)
		_machine_halt = db1x_power_off;
	if (!_machine_restart)
		_machine_restart = db1x_reset;

	return 0;
}
late_initcall(db1x_poweroff_setup);

/* register a pcmcia socket */
int __init db1x_register_pcmcia_socket(phys_addr_t pcmcia_attr_start,
				       phys_addr_t pcmcia_attr_end,
				       phys_addr_t pcmcia_mem_start,
				       phys_addr_t pcmcia_mem_end,
				       phys_addr_t pcmcia_io_start,
				       phys_addr_t pcmcia_io_end,
				       int card_irq,
				       int cd_irq,
				       int stschg_irq,
				       int eject_irq,
				       int id)
{
	int cnt, i, ret;
	struct resource *sr;
	struct platform_device *pd;

	cnt = 5;
	if (eject_irq)
		cnt++;
	if (stschg_irq)
		cnt++;

	sr = kzalloc(sizeof(struct resource) * cnt, GFP_KERNEL);
	if (!sr)
		return -ENOMEM;

	pd = platform_device_alloc("db1xxx_pcmcia", id);
	if (!pd) {
		ret = -ENOMEM;
		goto out;
	}

	sr[0].name	= "pcmcia-attr";
	sr[0].flags	= IORESOURCE_MEM;
	sr[0].start	= pcmcia_attr_start;
	sr[0].end	= pcmcia_attr_end;

	sr[1].name	= "pcmcia-mem";
	sr[1].flags	= IORESOURCE_MEM;
	sr[1].start	= pcmcia_mem_start;
	sr[1].end	= pcmcia_mem_end;

	sr[2].name	= "pcmcia-io";
	sr[2].flags	= IORESOURCE_MEM;
	sr[2].start	= pcmcia_io_start;
	sr[2].end	= pcmcia_io_end;

	sr[3].name	= "insert";
	sr[3].flags	= IORESOURCE_IRQ;
	sr[3].start = sr[3].end = cd_irq;

	sr[4].name	= "card";
	sr[4].flags	= IORESOURCE_IRQ;
	sr[4].start = sr[4].end = card_irq;

	i = 5;
	if (stschg_irq) {
		sr[i].name	= "stschg";
		sr[i].flags	= IORESOURCE_IRQ;
		sr[i].start = sr[i].end = stschg_irq;
		i++;
	}
	if (eject_irq) {
		sr[i].name	= "eject";
		sr[i].flags	= IORESOURCE_IRQ;
		sr[i].start = sr[i].end = eject_irq;
	}

	pd->resource = sr;
	pd->num_resources = cnt;

	ret = platform_device_add(pd);
	if (!ret)
		return 0;

	platform_device_put(pd);
out:
	kfree(sr);
	return ret;
}

#define YAMON_SIZE	0x00100000
#define YAMON_ENV_SIZE	0x00040000

int __init db1x_register_norflash(unsigned long size, int width,
				  int swapped)
{
	struct physmap_flash_data *pfd;
	struct platform_device *pd;
	struct mtd_partition *parts;
	struct resource *res;
	int ret, i;

	if (size < (8 * 1024 * 1024))
		return -EINVAL;

	ret = -ENOMEM;
	parts = kzalloc(sizeof(struct mtd_partition) * 5, GFP_KERNEL);
	if (!parts)
		goto out;

	res = kzalloc(sizeof(struct resource), GFP_KERNEL);
	if (!res)
		goto out1;

	pfd = kzalloc(sizeof(struct physmap_flash_data), GFP_KERNEL);
	if (!pfd)
		goto out2;

	pd = platform_device_alloc("physmap-flash", 0);
	if (!pd)
		goto out3;

	/* NOR flash ends at 0x20000000, regardless of size */
	res->start = 0x20000000 - size;
	res->end = 0x20000000 - 1;
	res->flags = IORESOURCE_MEM;

	/* partition setup.  Most Develboards have a switch which allows
	 * to swap the physical locations of the 2 NOR flash banks.
	 */
	i = 0;
	if (!swapped) {
		/* first NOR chip */
		parts[i].offset = 0;
		parts[i].name = "User FS";
		parts[i].size = size / 2;
		i++;
	}

	parts[i].offset = MTDPART_OFS_APPEND;
	parts[i].name = "User FS 2";
	parts[i].size = (size / 2) - (0x20000000 - 0x1fc00000);
	i++;

	parts[i].offset = MTDPART_OFS_APPEND;
	parts[i].name = "YAMON";
	parts[i].size = YAMON_SIZE;
	parts[i].mask_flags = MTD_WRITEABLE;
	i++;

	parts[i].offset = MTDPART_OFS_APPEND;
	parts[i].name = "raw kernel";
	parts[i].size = 0x00400000 - YAMON_SIZE - YAMON_ENV_SIZE;
	i++;

	parts[i].offset = MTDPART_OFS_APPEND;
	parts[i].name = "YAMON Env";
	parts[i].size = YAMON_ENV_SIZE;
	parts[i].mask_flags = MTD_WRITEABLE;
	i++;

	if (swapped) {
		parts[i].offset = MTDPART_OFS_APPEND;
		parts[i].name = "User FS";
		parts[i].size = size / 2;
		i++;
	}

	pfd->width = width;
	pfd->parts = parts;
	pfd->nr_parts = 5;

	pd->dev.platform_data = pfd;
	pd->resource = res;
	pd->num_resources = 1;

	ret = platform_device_add(pd);
	if (!ret)
		return ret;

	platform_device_put(pd);
out3:
	kfree(pfd);
out2:
	kfree(res);
out1:
	kfree(parts);
out:
	return ret;
}
Commit	Line	Data
27dd65ac ML	1	/*
	2	* devoard misc stuff.
	3	*/
	4
	5	#include <linux/init.h>
206aa6cd ML	6	#include <linux/mtd/mtd.h>
	7	#include <linux/mtd/map.h>
	8	#include <linux/mtd/physmap.h>
27dd65ac ML	9	#include <linux/slab.h>
27dd65ac ML	10	#include <linux/platform_device.h>
32fd6901 ML	11	#include <linux/pm.h>
	12
	13	#include <asm/reboot.h>
	14	#include <asm/mach-db1x00/bcsr.h>
	15
	16	static void db1x_power_off(void)
	17	{
	18	bcsr_write(BCSR_RESETS, 0);
	19	bcsr_write(BCSR_SYSTEM, BCSR_SYSTEM_PWROFF \| BCSR_SYSTEM_RESET);
	20	}
	21
	22	static void db1x_reset(char *c)
	23	{
	24	bcsr_write(BCSR_RESETS, 0);
	25	bcsr_write(BCSR_SYSTEM, 0);
	26	}
	27
	28	static int __init db1x_poweroff_setup(void)
	29	{
	30	if (!pm_power_off)
	31	pm_power_off = db1x_power_off;
	32	if (!_machine_halt)
	33	_machine_halt = db1x_power_off;
	34	if (!_machine_restart)
	35	_machine_restart = db1x_reset;
	36
	37	return 0;
	38	}
	39	late_initcall(db1x_poweroff_setup);
27dd65ac ML	40
27dd65ac ML	41	/* register a pcmcia socket */
11b897cf ML	42	int __init db1x_register_pcmcia_socket(phys_addr_t pcmcia_attr_start,
	43	phys_addr_t pcmcia_attr_end,
	44	phys_addr_t pcmcia_mem_start,
	45	phys_addr_t pcmcia_mem_end,
	46	phys_addr_t pcmcia_io_start,
	47	phys_addr_t pcmcia_io_end,
27dd65ac ML	48	int card_irq,
	49	int cd_irq,
	50	int stschg_irq,
	51	int eject_irq,
	52	int id)
	53	{
	54	int cnt, i, ret;
	55	struct resource *sr;
	56	struct platform_device *pd;
	57
	58	cnt = 5;
	59	if (eject_irq)
	60	cnt++;
	61	if (stschg_irq)
	62	cnt++;
	63
	64	sr = kzalloc(sizeof(struct resource) * cnt, GFP_KERNEL);
	65	if (!sr)
	66	return -ENOMEM;
	67
	68	pd = platform_device_alloc("db1xxx_pcmcia", id);
	69	if (!pd) {
	70	ret = -ENOMEM;
	71	goto out;
	72	}
	73
11b897cf	74	sr[0].name = "pcmcia-attr";
27dd65ac	75	sr[0].flags = IORESOURCE_MEM;
11b897cf ML	76	sr[0].start = pcmcia_attr_start;
11b897cf ML	77	sr[0].end = pcmcia_attr_end;
27dd65ac	78
11b897cf	79	sr[1].name = "pcmcia-mem";
27dd65ac	80	sr[1].flags = IORESOURCE_MEM;
11b897cf ML	81	sr[1].start = pcmcia_mem_start;
11b897cf ML	82	sr[1].end = pcmcia_mem_end;
27dd65ac	83
11b897cf	84	sr[2].name = "pcmcia-io";
27dd65ac	85	sr[2].flags = IORESOURCE_MEM;
11b897cf ML	86	sr[2].start = pcmcia_io_start;
11b897cf ML	87	sr[2].end = pcmcia_io_end;
27dd65ac ML	88
	89	sr[3].name = "insert";
	90	sr[3].flags = IORESOURCE_IRQ;
	91	sr[3].start = sr[3].end = cd_irq;
	92
	93	sr[4].name = "card";
	94	sr[4].flags = IORESOURCE_IRQ;
	95	sr[4].start = sr[4].end = card_irq;
	96
	97	i = 5;
	98	if (stschg_irq) {
11b897cf	99	sr[i].name = "stschg";
27dd65ac	100	sr[i].flags = IORESOURCE_IRQ;
11b897cf	101	sr[i].start = sr[i].end = stschg_irq;
27dd65ac ML	102	i++;
	103	}
	104	if (eject_irq) {
	105	sr[i].name = "eject";
	106	sr[i].flags = IORESOURCE_IRQ;
	107	sr[i].start = sr[i].end = eject_irq;
	108	}
	109
	110	pd->resource = sr;
	111	pd->num_resources = cnt;
	112
	113	ret = platform_device_add(pd);
	114	if (!ret)
	115	return 0;
	116
	117	platform_device_put(pd);
	118	out:
	119	kfree(sr);
	120	return ret;
	121	}
206aa6cd ML	122
	123	#define YAMON_SIZE 0x00100000
	124	#define YAMON_ENV_SIZE 0x00040000
	125
	126	int __init db1x_register_norflash(unsigned long size, int width,
	127	int swapped)
	128	{
	129	struct physmap_flash_data *pfd;
	130	struct platform_device *pd;
	131	struct mtd_partition *parts;
	132	struct resource *res;
	133	int ret, i;
	134
	135	if (size < (8 * 1024 * 1024))
	136	return -EINVAL;
	137
	138	ret = -ENOMEM;
	139	parts = kzalloc(sizeof(struct mtd_partition) * 5, GFP_KERNEL);
	140	if (!parts)
	141	goto out;
	142
	143	res = kzalloc(sizeof(struct resource), GFP_KERNEL);
	144	if (!res)
	145	goto out1;
	146
	147	pfd = kzalloc(sizeof(struct physmap_flash_data), GFP_KERNEL);
	148	if (!pfd)
	149	goto out2;
	150
	151	pd = platform_device_alloc("physmap-flash", 0);
	152	if (!pd)
	153	goto out3;
	154
	155	/* NOR flash ends at 0x20000000, regardless of size */
	156	res->start = 0x20000000 - size;
	157	res->end = 0x20000000 - 1;
	158	res->flags = IORESOURCE_MEM;
	159
	160	/* partition setup. Most Develboards have a switch which allows
	161	* to swap the physical locations of the 2 NOR flash banks.
	162	*/
	163	i = 0;
	164	if (!swapped) {
	165	/* first NOR chip */
	166	parts[i].offset = 0;
	167	parts[i].name = "User FS";
	168	parts[i].size = size / 2;
	169	i++;
	170	}
	171
	172	parts[i].offset = MTDPART_OFS_APPEND;
	173	parts[i].name = "User FS 2";
	174	parts[i].size = (size / 2) - (0x20000000 - 0x1fc00000);
	175	i++;
	176
	177	parts[i].offset = MTDPART_OFS_APPEND;
	178	parts[i].name = "YAMON";
	179	parts[i].size = YAMON_SIZE;
	180	parts[i].mask_flags = MTD_WRITEABLE;
	181	i++;
	182
	183	parts[i].offset = MTDPART_OFS_APPEND;
	184	parts[i].name = "raw kernel";
	185	parts[i].size = 0x00400000 - YAMON_SIZE - YAMON_ENV_SIZE;
186	i++;
187
188	parts[i].offset = MTDPART_OFS_APPEND;
189	parts[i].name = "YAMON Env";
190	parts[i].size = YAMON_ENV_SIZE;
191	parts[i].mask_flags = MTD_WRITEABLE;
192	i++;
193
194	if (swapped) {
195	parts[i].offset = MTDPART_OFS_APPEND;
196	parts[i].name = "User FS";
197	parts[i].size = size / 2;
198	i++;
199	}
200
201	pfd->width = width;
202	pfd->parts = parts;
203	pfd->nr_parts = 5;
204
205	pd->dev.platform_data = pfd;
206	pd->resource = res;
207	pd->num_resources = 1;
208
209	ret = platform_device_add(pd);
210	if (!ret)
211	return ret;
212
213	platform_device_put(pd);
214	out3:
215	kfree(pfd);
216	out2:
217	kfree(res);
218	out1:
219	kfree(parts);
220	out:
221	return ret;
222	}