[deliverable/linux.git] / arch / arm / mach-pxa / corgi.c

/*
 * Support for Sharp SL-C7xx PDAs
 * Models: SL-C700 (Corgi), SL-C750 (Shepherd), SL-C760 (Husky)
 *
 * Copyright (c) 2004-2005 Richard Purdie
 *
 * Based on Sharp's 2.4 kernel patches/lubbock.c
 *
 * 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/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/major.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/mmc/host.h>
#include <linux/pm.h>

#include <asm/setup.h>
#include <asm/memory.h>
#include <asm/mach-types.h>
#include <asm/hardware.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/system.h>

#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/irq.h>

#include <asm/arch/pxa-regs.h>
#include <asm/arch/irda.h>
#include <asm/arch/mmc.h>
#include <asm/arch/udc.h>
#include <asm/arch/corgi.h>
#include <asm/arch/sharpsl.h>

#include <asm/mach/sharpsl_param.h>
#include <asm/hardware/scoop.h>

#include "generic.h"
#include "sharpsl.h"


/*
 * Corgi SCOOP Device
 */
static struct resource corgi_scoop_resources[] = {
	[0] = {
		.start		= 0x10800000,
		.end		= 0x10800fff,
		.flags		= IORESOURCE_MEM,
	},
};

static struct scoop_config corgi_scoop_setup = {
	.io_dir 	= CORGI_SCOOP_IO_DIR,
	.io_out		= CORGI_SCOOP_IO_OUT,
};

struct platform_device corgiscoop_device = {
	.name		= "sharp-scoop",
	.id		= -1,
	.dev		= {
 		.platform_data	= &corgi_scoop_setup,
	},
	.num_resources	= ARRAY_SIZE(corgi_scoop_resources),
	.resource	= corgi_scoop_resources,
};

static void corgi_pcmcia_init(void)
{
	/* Setup default state of GPIO outputs
	   before we enable them as outputs. */
	GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |
		GPIO_bit(GPIO49_nPWE) | GPIO_bit(GPIO50_nPIOR) |
		GPIO_bit(GPIO51_nPIOW) | GPIO_bit(GPIO52_nPCE_1) |
		GPIO_bit(GPIO53_nPCE_2);

	pxa_gpio_mode(GPIO48_nPOE_MD);
	pxa_gpio_mode(GPIO49_nPWE_MD);
	pxa_gpio_mode(GPIO50_nPIOR_MD);
	pxa_gpio_mode(GPIO51_nPIOW_MD);
	pxa_gpio_mode(GPIO55_nPREG_MD);
	pxa_gpio_mode(GPIO56_nPWAIT_MD);
	pxa_gpio_mode(GPIO57_nIOIS16_MD);
	pxa_gpio_mode(GPIO52_nPCE_1_MD);
	pxa_gpio_mode(GPIO53_nPCE_2_MD);
	pxa_gpio_mode(GPIO54_pSKTSEL_MD);
}

static struct scoop_pcmcia_dev corgi_pcmcia_scoop[] = {
{
	.dev        = &corgiscoop_device.dev,
	.irq        = CORGI_IRQ_GPIO_CF_IRQ,
	.cd_irq     = CORGI_IRQ_GPIO_CF_CD,
	.cd_irq_str = "PCMCIA0 CD",
},
};

static struct scoop_pcmcia_config corgi_pcmcia_config = {
	.devs         = &corgi_pcmcia_scoop[0],
	.num_devs     = 1,
	.pcmcia_init  = corgi_pcmcia_init,
};

EXPORT_SYMBOL(corgiscoop_device);


/*
 * Corgi SSP Device
 *
 * Set the parent as the scoop device because a lot of SSP devices
 * also use scoop functions and this makes the power up/down order
 * work correctly.
 */
struct platform_device corgissp_device = {
	.name		= "corgi-ssp",
	.dev		= {
 		.parent = &corgiscoop_device.dev,
	},
	.id		= -1,
};

struct corgissp_machinfo corgi_ssp_machinfo = {
	.port		= 1,
	.cs_lcdcon	= CORGI_GPIO_LCDCON_CS,
	.cs_ads7846	= CORGI_GPIO_ADS7846_CS,
	.cs_max1111	= CORGI_GPIO_MAX1111_CS,
	.clk_lcdcon	= 76,
	.clk_ads7846	= 2,
	.clk_max1111	= 8,
};


/*
 * Corgi Backlight Device
 */
static struct corgibl_machinfo corgi_bl_machinfo = {
	.max_intensity = 0x2f,
	.default_intensity = 0x1f,
	.limit_mask = 0x0b,
	.set_bl_intensity = corgi_bl_set_intensity,
};

static struct platform_device corgibl_device = {
	.name		= "corgi-bl",
	.dev		= {
 		.parent = &corgifb_device.dev,
		.platform_data	= &corgi_bl_machinfo,
	},
	.id		= -1,
};


/*
 * Corgi Keyboard Device
 */
static struct platform_device corgikbd_device = {
	.name		= "corgi-keyboard",
	.id		= -1,
};


/*
 * Corgi LEDs
 */
static struct platform_device corgiled_device = {
	.name		= "corgi-led",
	.id		= -1,
};

/*
 * Corgi Touch Screen Device
 */
static struct resource corgits_resources[] = {
	[0] = {
		.start		= CORGI_IRQ_GPIO_TP_INT,
		.end		= CORGI_IRQ_GPIO_TP_INT,
		.flags		= IORESOURCE_IRQ,
	},
};

static struct corgits_machinfo  corgi_ts_machinfo = {
	.get_hsync_len   = corgi_get_hsync_len,
	.put_hsync       = corgi_put_hsync,
	.wait_hsync      = corgi_wait_hsync,
};

static struct platform_device corgits_device = {
	.name		= "corgi-ts",
	.dev		= {
 		.parent = &corgissp_device.dev,
		.platform_data	= &corgi_ts_machinfo,
	},
	.id		= -1,
	.num_resources	= ARRAY_SIZE(corgits_resources),
	.resource	= corgits_resources,
};


/*
 * MMC/SD Device
 *
 * The card detect interrupt isn't debounced so we delay it by 250ms
 * to give the card a chance to fully insert/eject.
 */
static struct pxamci_platform_data corgi_mci_platform_data;

static int corgi_mci_init(struct device *dev, irq_handler_t corgi_detect_int, void *data)
{
	int err;

	/* setup GPIO for PXA25x MMC controller	*/
	pxa_gpio_mode(GPIO6_MMCCLK_MD);
	pxa_gpio_mode(GPIO8_MMCCS0_MD);
	pxa_gpio_mode(CORGI_GPIO_nSD_DETECT | GPIO_IN);
	pxa_gpio_mode(CORGI_GPIO_SD_PWR | GPIO_OUT);

	corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);

	err = request_irq(CORGI_IRQ_GPIO_nSD_DETECT, corgi_detect_int,
			  IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
			  "MMC card detect", data);
	if (err) {
		printk(KERN_ERR "corgi_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
		return -1;
	}

	return 0;
}

static void corgi_mci_setpower(struct device *dev, unsigned int vdd)
{
	struct pxamci_platform_data* p_d = dev->platform_data;

	if (( 1 << vdd) & p_d->ocr_mask)
		GPSR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
	else
		GPCR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
}

static int corgi_mci_get_ro(struct device *dev)
{
	return GPLR(CORGI_GPIO_nSD_WP) & GPIO_bit(CORGI_GPIO_nSD_WP);
}

static void corgi_mci_exit(struct device *dev, void *data)
{
	free_irq(CORGI_IRQ_GPIO_nSD_DETECT, data);
}

static struct pxamci_platform_data corgi_mci_platform_data = {
	.ocr_mask	= MMC_VDD_32_33|MMC_VDD_33_34,
	.init 		= corgi_mci_init,
	.get_ro		= corgi_mci_get_ro,
	.setpower 	= corgi_mci_setpower,
	.exit		= corgi_mci_exit,
};


/*
 * Irda
 */
static void corgi_irda_transceiver_mode(struct device *dev, int mode)
{
	if (mode & IR_OFF)
		GPSR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
	else
		GPCR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
}

static struct pxaficp_platform_data corgi_ficp_platform_data = {
	.transceiver_cap  = IR_SIRMODE | IR_OFF,
	.transceiver_mode = corgi_irda_transceiver_mode,
};


/*
 * USB Device Controller
 */
static struct pxa2xx_udc_mach_info udc_info __initdata = {
	/* no connect GPIO; corgi can't tell connection status */
	.gpio_pullup		= CORGI_GPIO_USB_PULLUP,
};


static struct platform_device *devices[] __initdata = {
	&corgiscoop_device,
	&corgissp_device,
	&corgifb_device,
	&corgikbd_device,
	&corgibl_device,
	&corgits_device,
	&corgiled_device,
};

static void corgi_poweroff(void)
{
	RCSR = RCSR_HWR | RCSR_WDR | RCSR_SMR | RCSR_GPR;

	if (!machine_is_corgi())
		/* Green LED off tells the bootloader to halt */
		reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
	arm_machine_restart('h');
}

static void corgi_restart(char mode)
{
	RCSR = RCSR_HWR | RCSR_WDR | RCSR_SMR | RCSR_GPR;

	if (!machine_is_corgi())
		/* Green LED on tells the bootloader to reboot */
		set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
	arm_machine_restart('h');
}

static void __init corgi_init(void)
{
	pm_power_off = corgi_poweroff;
	arm_pm_restart = corgi_restart;

	/* setup sleep mode values */
	PWER  = 0x00000002;
	PFER  = 0x00000000;
	PRER  = 0x00000002;
	PGSR0 = 0x0158C000;
	PGSR1 = 0x00FF0080;
	PGSR2 = 0x0001C004;
	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
	PCFR |= PCFR_OPDE;

	corgi_ssp_set_machinfo(&corgi_ssp_machinfo);

	pxa_gpio_mode(CORGI_GPIO_IR_ON | GPIO_OUT);
	pxa_gpio_mode(CORGI_GPIO_HSYNC | GPIO_IN);

 	pxa_set_udc_info(&udc_info);
	pxa_set_mci_info(&corgi_mci_platform_data);
	pxa_set_ficp_info(&corgi_ficp_platform_data);

	platform_scoop_config = &corgi_pcmcia_config;

	platform_add_devices(devices, ARRAY_SIZE(devices));
}

static void __init fixup_corgi(struct machine_desc *desc,
		struct tag *tags, char **cmdline, struct meminfo *mi)
{
	sharpsl_save_param();
	mi->nr_banks=1;
	mi->bank[0].start = 0xa0000000;
	mi->bank[0].node = 0;
	if (machine_is_corgi())
		mi->bank[0].size = (32*1024*1024);
	else
		mi->bank[0].size = (64*1024*1024);
}

#ifdef CONFIG_MACH_CORGI
MACHINE_START(CORGI, "SHARP Corgi")
	.phys_io	= 0x40000000,
	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
	.fixup		= fixup_corgi,
	.map_io		= pxa_map_io,
	.init_irq	= pxa25x_init_irq,
	.init_machine	= corgi_init,
	.timer		= &pxa_timer,
MACHINE_END
#endif

#ifdef CONFIG_MACH_SHEPHERD
MACHINE_START(SHEPHERD, "SHARP Shepherd")
	.phys_io	= 0x40000000,
	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
	.fixup		= fixup_corgi,
	.map_io		= pxa_map_io,
	.init_irq	= pxa25x_init_irq,
	.init_machine	= corgi_init,
	.timer		= &pxa_timer,
MACHINE_END
#endif

#ifdef CONFIG_MACH_HUSKY
MACHINE_START(HUSKY, "SHARP Husky")
	.phys_io	= 0x40000000,
	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
	.fixup		= fixup_corgi,
	.map_io		= pxa_map_io,
	.init_irq	= pxa25x_init_irq,
	.init_machine	= corgi_init,
	.timer		= &pxa_timer,
MACHINE_END
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Support for Sharp SL-C7xx PDAs
	3	* Models: SL-C700 (Corgi), SL-C750 (Shepherd), SL-C760 (Husky)
	4	*
	5	* Copyright (c) 2004-2005 Richard Purdie
	6	*
	7	* Based on Sharp's 2.4 kernel patches/lubbock.c
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
d052d1be	17	#include <linux/platform_device.h>
1da177e4 LT	18	#include <linux/major.h>
	19	#include <linux/fs.h>
	20	#include <linux/interrupt.h>
	21	#include <linux/mmc/host.h>
74617fb6	22	#include <linux/pm.h>
1da177e4 LT	23
	24	#include <asm/setup.h>
	25	#include <asm/memory.h>
	26	#include <asm/mach-types.h>
	27	#include <asm/hardware.h>
	28	#include <asm/irq.h>
	29	#include <asm/io.h>
74617fb6	30	#include <asm/system.h>
1da177e4 LT	31
	32	#include <asm/mach/arch.h>
	33	#include <asm/mach/map.h>
	34	#include <asm/mach/irq.h>
	35
	36	#include <asm/arch/pxa-regs.h>
ca1140b5	37	#include <asm/arch/irda.h>
1da177e4 LT	38	#include <asm/arch/mmc.h>
	39	#include <asm/arch/udc.h>
	40	#include <asm/arch/corgi.h>
1036260e	41	#include <asm/arch/sharpsl.h>
1da177e4 LT	42
	43	#include <asm/mach/sharpsl_param.h>
	44	#include <asm/hardware/scoop.h>
1da177e4 LT	45
1da177e4 LT	46	#include "generic.h"
50a5de44	47	#include "sharpsl.h"
1da177e4 LT	48
	49
	50	/*
	51	* Corgi SCOOP Device
	52	*/
	53	static struct resource corgi_scoop_resources[] = {
	54	[0] = {
	55	.start = 0x10800000,
	56	.end = 0x10800fff,
	57	.flags = IORESOURCE_MEM,
	58	},
	59	};
	60
	61	static struct scoop_config corgi_scoop_setup = {
	62	.io_dir = CORGI_SCOOP_IO_DIR,
	63	.io_out = CORGI_SCOOP_IO_OUT,
	64	};
	65
a63ae442 RP	66	struct platform_device corgiscoop_device = {
	67	.name = "sharp-scoop",
	68	.id = -1,
	69	.dev = {
	70	.platform_data = &corgi_scoop_setup,
	71	},
	72	.num_resources = ARRAY_SIZE(corgi_scoop_resources),
	73	.resource = corgi_scoop_resources,
	74	};
	75
	76	static void corgi_pcmcia_init(void)
	77	{
	78	/* Setup default state of GPIO outputs
	79	before we enable them as outputs. */
	80	GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) \|
	81	GPIO_bit(GPIO49_nPWE) \| GPIO_bit(GPIO50_nPIOR) \|
	82	GPIO_bit(GPIO51_nPIOW) \| GPIO_bit(GPIO52_nPCE_1) \|
	83	GPIO_bit(GPIO53_nPCE_2);
	84
	85	pxa_gpio_mode(GPIO48_nPOE_MD);
	86	pxa_gpio_mode(GPIO49_nPWE_MD);
	87	pxa_gpio_mode(GPIO50_nPIOR_MD);
	88	pxa_gpio_mode(GPIO51_nPIOW_MD);
	89	pxa_gpio_mode(GPIO55_nPREG_MD);
	90	pxa_gpio_mode(GPIO56_nPWAIT_MD);
	91	pxa_gpio_mode(GPIO57_nIOIS16_MD);
	92	pxa_gpio_mode(GPIO52_nPCE_1_MD);
	93	pxa_gpio_mode(GPIO53_nPCE_2_MD);
	94	pxa_gpio_mode(GPIO54_pSKTSEL_MD);
	95	}
	96
0ce7625f RP	97	static struct scoop_pcmcia_dev corgi_pcmcia_scoop[] = {
	98	{
	99	.dev = &corgiscoop_device.dev,
	100	.irq = CORGI_IRQ_GPIO_CF_IRQ,
	101	.cd_irq = CORGI_IRQ_GPIO_CF_CD,
	102	.cd_irq_str = "PCMCIA0 CD",
	103	},
	104	};
	105
a63ae442 RP	106	static struct scoop_pcmcia_config corgi_pcmcia_config = {
	107	.devs = &corgi_pcmcia_scoop[0],
	108	.num_devs = 1,
	109	.pcmcia_init = corgi_pcmcia_init,
1da177e4 LT	110	};
1da177e4 LT	111
a63ae442 RP	112	EXPORT_SYMBOL(corgiscoop_device);
a63ae442 RP	113
1da177e4 LT	114
	115	/*
	116	* Corgi SSP Device
	117	*
	118	* Set the parent as the scoop device because a lot of SSP devices
	119	* also use scoop functions and this makes the power up/down order
	120	* work correctly.
	121	*/
41b1bce8	122	struct platform_device corgissp_device = {
1da177e4 LT	123	.name = "corgi-ssp",
	124	.dev = {
	125	.parent = &corgiscoop_device.dev,
	126	},
	127	.id = -1,
	128	};
	129
50a5de44 RP	130	struct corgissp_machinfo corgi_ssp_machinfo = {
	131	.port = 1,
	132	.cs_lcdcon = CORGI_GPIO_LCDCON_CS,
	133	.cs_ads7846 = CORGI_GPIO_ADS7846_CS,
	134	.cs_max1111 = CORGI_GPIO_MAX1111_CS,
	135	.clk_lcdcon = 76,
	136	.clk_ads7846 = 2,
	137	.clk_max1111 = 8,
	138	};
	139
1da177e4	140
1da177e4 LT	141	/*
	142	* Corgi Backlight Device
	143	*/
1351e6e0 RP	144	static struct corgibl_machinfo corgi_bl_machinfo = {
1351e6e0 RP	145	.max_intensity = 0x2f,
2c0f5fb0 RP	146	.default_intensity = 0x1f,
2c0f5fb0 RP	147	.limit_mask = 0x0b,
1351e6e0 RP	148	.set_bl_intensity = corgi_bl_set_intensity,
	149	};
	150
1da177e4 LT	151	static struct platform_device corgibl_device = {
	152	.name = "corgi-bl",
	153	.dev = {
	154	.parent = &corgifb_device.dev,
1351e6e0	155	.platform_data = &corgi_bl_machinfo,
1da177e4 LT	156	},
	157	.id = -1,
	158	};
	159
	160
f7ceff34 RP	161	/*
	162	* Corgi Keyboard Device
	163	*/
	164	static struct platform_device corgikbd_device = {
	165	.name = "corgi-keyboard",
	166	.id = -1,
	167	};
	168
	169
3179108d RP	170	/*
	171	* Corgi LEDs
	172	*/
	173	static struct platform_device corgiled_device = {
	174	.name = "corgi-led",
	175	.id = -1,
	176	};
	177
f7ceff34 RP	178	/*
	179	* Corgi Touch Screen Device
	180	*/
513b6e1a RP	181	static struct resource corgits_resources[] = {
	182	[0] = {
	183	.start = CORGI_IRQ_GPIO_TP_INT,
	184	.end = CORGI_IRQ_GPIO_TP_INT,
	185	.flags = IORESOURCE_IRQ,
	186	},
	187	};
	188
	189	static struct corgits_machinfo corgi_ts_machinfo = {
	190	.get_hsync_len = corgi_get_hsync_len,
	191	.put_hsync = corgi_put_hsync,
	192	.wait_hsync = corgi_wait_hsync,
	193	};
	194
f7ceff34 RP	195	static struct platform_device corgits_device = {
	196	.name = "corgi-ts",
	197	.dev = {
	198	.parent = &corgissp_device.dev,
513b6e1a	199	.platform_data = &corgi_ts_machinfo,
f7ceff34 RP	200	},
f7ceff34 RP	201	.id = -1,
513b6e1a RP	202	.num_resources = ARRAY_SIZE(corgits_resources),
513b6e1a RP	203	.resource = corgits_resources,
f7ceff34 RP	204	};
	205
	206
1da177e4 LT	207	/*
	208	* MMC/SD Device
	209	*
aa6c2e79	210	* The card detect interrupt isn't debounced so we delay it by 250ms
1da177e4 LT	211	* to give the card a chance to fully insert/eject.
1da177e4 LT	212	*/
aa6c2e79	213	static struct pxamci_platform_data corgi_mci_platform_data;
1da177e4	214
40220c1a	215	static int corgi_mci_init(struct device dev, irq_handler_t corgi_detect_int, void data)
1da177e4 LT	216	{
	217	int err;
	218
	219	/* setup GPIO for PXA25x MMC controller */
	220	pxa_gpio_mode(GPIO6_MMCCLK_MD);
	221	pxa_gpio_mode(GPIO8_MMCCS0_MD);
	222	pxa_gpio_mode(CORGI_GPIO_nSD_DETECT \| GPIO_IN);
	223	pxa_gpio_mode(CORGI_GPIO_SD_PWR \| GPIO_OUT);
	224
aa6c2e79	225	corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);
1da177e4	226
9ded96f2	227	err = request_irq(CORGI_IRQ_GPIO_nSD_DETECT, corgi_detect_int,
52e405ea	228	IRQF_DISABLED \| IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
9ded96f2	229	"MMC card detect", data);
1da177e4 LT	230	if (err) {
	231	printk(KERN_ERR "corgi_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
	232	return -1;
	233	}
	234
1da177e4 LT	235	return 0;
	236	}
	237
	238	static void corgi_mci_setpower(struct device *dev, unsigned int vdd)
	239	{
	240	struct pxamci_platform_data* p_d = dev->platform_data;
	241
fdce05bb	242	if (( 1 << vdd) & p_d->ocr_mask)
1da177e4	243	GPSR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
fdce05bb	244	else
1da177e4	245	GPCR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
1da177e4 LT	246	}
1da177e4 LT	247
3870ee8c RP	248	static int corgi_mci_get_ro(struct device *dev)
	249	{
	250	return GPLR(CORGI_GPIO_nSD_WP) & GPIO_bit(CORGI_GPIO_nSD_WP);
	251	}
	252
1da177e4 LT	253	static void corgi_mci_exit(struct device dev, void data)
	254	{
	255	free_irq(CORGI_IRQ_GPIO_nSD_DETECT, data);
1da177e4 LT	256	}
	257
	258	static struct pxamci_platform_data corgi_mci_platform_data = {
	259	.ocr_mask = MMC_VDD_32_33\|MMC_VDD_33_34,
	260	.init = corgi_mci_init,
3870ee8c	261	.get_ro = corgi_mci_get_ro,
1da177e4 LT	262	.setpower = corgi_mci_setpower,
	263	.exit = corgi_mci_exit,
	264	};
	265
	266
ca1140b5 RP	267	/*
	268	* Irda
	269	*/
	270	static void corgi_irda_transceiver_mode(struct device *dev, int mode)
	271	{
	272	if (mode & IR_OFF)
	273	GPSR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
	274	else
	275	GPCR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
	276	}
	277
	278	static struct pxaficp_platform_data corgi_ficp_platform_data = {
	279	.transceiver_cap = IR_SIRMODE \| IR_OFF,
	280	.transceiver_mode = corgi_irda_transceiver_mode,
	281	};
	282
f7ceff34	283
1da177e4 LT	284	/*
	285	* USB Device Controller
	286	*/
1da177e4 LT	287	static struct pxa2xx_udc_mach_info udc_info __initdata = {
1da177e4 LT	288	/* no connect GPIO; corgi can't tell connection status */
b2bbb20b	289	.gpio_pullup = CORGI_GPIO_USB_PULLUP,
1da177e4 LT	290	};
	291
	292
	293	static struct platform_device *devices[] __initdata = {
	294	&corgiscoop_device,
	295	&corgissp_device,
	296	&corgifb_device,
f7ceff34	297	&corgikbd_device,
1da177e4	298	&corgibl_device,
f7ceff34	299	&corgits_device,
3179108d	300	&corgiled_device,
1da177e4 LT	301	};
1da177e4 LT	302
74617fb6 RP	303	static void corgi_poweroff(void)
	304	{
	305	RCSR = RCSR_HWR \| RCSR_WDR \| RCSR_SMR \| RCSR_GPR;
	306
	307	if (!machine_is_corgi())
	308	/* Green LED off tells the bootloader to halt */
	309	reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
	310	arm_machine_restart('h');
	311	}
	312
	313	static void corgi_restart(char mode)
	314	{
	315	RCSR = RCSR_HWR \| RCSR_WDR \| RCSR_SMR \| RCSR_GPR;
	316
	317	if (!machine_is_corgi())
	318	/* Green LED on tells the bootloader to reboot */
	319	set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
	320	arm_machine_restart('h');
	321	}
	322
1da177e4 LT	323	static void __init corgi_init(void)
1da177e4 LT	324	{
74617fb6 RP	325	pm_power_off = corgi_poweroff;
	326	arm_pm_restart = corgi_restart;
	327
fdce05bb RP	328	/* setup sleep mode values */
	329	PWER = 0x00000002;
	330	PFER = 0x00000000;
	331	PRER = 0x00000002;
	332	PGSR0 = 0x0158C000;
	333	PGSR1 = 0x00FF0080;
	334	PGSR2 = 0x0001C004;
	335	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
	336	PCFR \|= PCFR_OPDE;
	337
50a5de44 RP	338	corgi_ssp_set_machinfo(&corgi_ssp_machinfo);
50a5de44 RP	339
ca1140b5	340	pxa_gpio_mode(CORGI_GPIO_IR_ON \| GPIO_OUT);
513b6e1a	341	pxa_gpio_mode(CORGI_GPIO_HSYNC \| GPIO_IN);
ca1140b5	342
1da177e4 LT	343	pxa_set_udc_info(&udc_info);
1da177e4 LT	344	pxa_set_mci_info(&corgi_mci_platform_data);
ca1140b5	345	pxa_set_ficp_info(&corgi_ficp_platform_data);
1da177e4	346
a63ae442	347	platform_scoop_config = &corgi_pcmcia_config;
0ce7625f	348
1da177e4 LT	349	platform_add_devices(devices, ARRAY_SIZE(devices));
	350	}
	351
	352	static void __init fixup_corgi(struct machine_desc *desc,
	353	struct tag tags, char cmdline, struct meminfo mi)
	354	{
	355	sharpsl_save_param();
	356	mi->nr_banks=1;
	357	mi->bank[0].start = 0xa0000000;
	358	mi->bank[0].node = 0;
	359	if (machine_is_corgi())
	360	mi->bank[0].size = (3210241024);
	361	else
	362	mi->bank[0].size = (6410241024);
	363	}
	364
1da177e4 LT	365	#ifdef CONFIG_MACH_CORGI
1da177e4 LT	366	MACHINE_START(CORGI, "SHARP Corgi")
e9dea0c6	367	.phys_io = 0x40000000,
68070bde	368	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
e9dea0c6	369	.fixup = fixup_corgi,
fdce05bb	370	.map_io = pxa_map_io,
cd49104d	371	.init_irq = pxa25x_init_irq,
e9dea0c6 RK	372	.init_machine = corgi_init,
e9dea0c6 RK	373	.timer = &pxa_timer,
1da177e4 LT	374	MACHINE_END
	375	#endif
	376
	377	#ifdef CONFIG_MACH_SHEPHERD
	378	MACHINE_START(SHEPHERD, "SHARP Shepherd")
e9dea0c6	379	.phys_io = 0x40000000,
68070bde	380	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
e9dea0c6	381	.fixup = fixup_corgi,
fdce05bb	382	.map_io = pxa_map_io,
cd49104d	383	.init_irq = pxa25x_init_irq,
e9dea0c6 RK	384	.init_machine = corgi_init,
e9dea0c6 RK	385	.timer = &pxa_timer,
1da177e4 LT	386	MACHINE_END
	387	#endif
	388
	389	#ifdef CONFIG_MACH_HUSKY
	390	MACHINE_START(HUSKY, "SHARP Husky")
e9dea0c6	391	.phys_io = 0x40000000,
68070bde	392	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
e9dea0c6	393	.fixup = fixup_corgi,
fdce05bb	394	.map_io = pxa_map_io,
cd49104d	395	.init_irq = pxa25x_init_irq,
e9dea0c6 RK	396	.init_machine = corgi_init,
e9dea0c6 RK	397	.timer = &pxa_timer,
1da177e4 LT	398	MACHINE_END
	399	#endif
	400