[thirdparty/kernel/stable.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/mtd/physmap.h>
#include <linux/pm.h>
#include <linux/gpio.h>
#include <linux/backlight.h>
#include <linux/i2c.h>
#include <linux/io.h>
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
#include <linux/spi/corgi_lcd.h>
#include <linux/mtd/sharpsl.h>
#include <linux/input/matrix_keypad.h>
#include <video/w100fb.h>

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

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

#include <mach/pxa25x.h>
#include <plat/i2c.h>
#include <mach/irda.h>
#include <mach/mmc.h>
#include <mach/udc.h>
#include <mach/pxa2xx_spi.h>
#include <mach/corgi.h>
#include <mach/sharpsl.h>

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

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

static unsigned long corgi_pin_config[] __initdata = {
	/* Static Memory I/O */
	GPIO78_nCS_2,	/* w100fb */
	GPIO80_nCS_4,	/* scoop */

	/* SSP1 */
	GPIO23_SSP1_SCLK,
	GPIO25_SSP1_TXD,
	GPIO26_SSP1_RXD,
	GPIO24_GPIO,	/* CORGI_GPIO_ADS7846_CS - SFRM as chip select */

	/* I2S */
	GPIO28_I2S_BITCLK_OUT,
	GPIO29_I2S_SDATA_IN,
	GPIO30_I2S_SDATA_OUT,
	GPIO31_I2S_SYNC,
	GPIO32_I2S_SYSCLK,

	/* Infra-Red */
	GPIO47_FICP_TXD,
	GPIO46_FICP_RXD,

	/* FFUART */
	GPIO40_FFUART_DTR,
	GPIO41_FFUART_RTS,
	GPIO39_FFUART_TXD,
	GPIO37_FFUART_DSR,
	GPIO34_FFUART_RXD,
	GPIO35_FFUART_CTS,

	/* PC Card */
	GPIO48_nPOE,
	GPIO49_nPWE,
	GPIO50_nPIOR,
	GPIO51_nPIOW,
	GPIO52_nPCE_1,
	GPIO53_nPCE_2,
	GPIO54_nPSKTSEL,
	GPIO55_nPREG,
	GPIO56_nPWAIT,
	GPIO57_nIOIS16,

	/* MMC */
	GPIO6_MMC_CLK,
	GPIO8_MMC_CS0,

	/* GPIO Matrix Keypad */
	GPIO66_GPIO,	/* column 0 */
	GPIO67_GPIO,	/* column 1 */
	GPIO68_GPIO,	/* column 2 */
	GPIO69_GPIO,	/* column 3 */
	GPIO70_GPIO,	/* column 4 */
	GPIO71_GPIO,	/* column 5 */
	GPIO72_GPIO,	/* column 6 */
	GPIO73_GPIO,	/* column 7 */
	GPIO74_GPIO,	/* column 8 */
	GPIO75_GPIO,	/* column 9 */
	GPIO76_GPIO,	/* column 10 */
	GPIO77_GPIO,	/* column 11 */
	GPIO58_GPIO,	/* row 0 */
	GPIO59_GPIO,	/* row 1 */
	GPIO60_GPIO,	/* row 2 */
	GPIO61_GPIO,	/* row 3 */
	GPIO62_GPIO,	/* row 4 */
	GPIO63_GPIO,	/* row 5 */
	GPIO64_GPIO,	/* row 6 */
	GPIO65_GPIO,	/* row 7 */

	/* GPIO */
	GPIO9_GPIO,	/* CORGI_GPIO_nSD_DETECT */
	GPIO7_GPIO,	/* CORGI_GPIO_nSD_WP */
	GPIO21_GPIO,	/* CORGI_GPIO_ADC_TEMP */
	GPIO22_GPIO,	/* CORGI_GPIO_IR_ON */
	GPIO33_GPIO,	/* CORGI_GPIO_SD_PWR */
	GPIO38_GPIO,	/* CORGI_GPIO_CHRG_ON */
	GPIO43_GPIO,	/* CORGI_GPIO_CHRG_UKN */
	GPIO44_GPIO,	/* CORGI_GPIO_HSYNC */

	GPIO0_GPIO | WAKEUP_ON_EDGE_BOTH,	/* CORGI_GPIO_KEY_INT */
	GPIO1_GPIO | WAKEUP_ON_EDGE_RISE,	/* CORGI_GPIO_AC_IN */
};

/*
 * 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,
	.gpio_base	= CORGI_SCOOP_GPIO_BASE,
};

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 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,
};

EXPORT_SYMBOL(corgiscoop_device);

static struct w100_mem_info corgi_fb_mem = {
	.ext_cntl          = 0x00040003,
	.sdram_mode_reg    = 0x00650021,
	.ext_timing_cntl   = 0x10002a4a,
	.io_cntl           = 0x7ff87012,
	.size              = 0x1fffff,
};

static struct w100_gen_regs corgi_fb_regs = {
	.lcd_format    = 0x00000003,
	.lcdd_cntl1    = 0x01CC0000,
	.lcdd_cntl2    = 0x0003FFFF,
	.genlcd_cntl1  = 0x00FFFF0D,
	.genlcd_cntl2  = 0x003F3003,
	.genlcd_cntl3  = 0x000102aa,
};

static struct w100_gpio_regs corgi_fb_gpio = {
	.init_data1   = 0x000000bf,
	.init_data2   = 0x00000000,
	.gpio_dir1    = 0x00000000,
	.gpio_oe1     = 0x03c0feff,
	.gpio_dir2    = 0x00000000,
	.gpio_oe2     = 0x00000000,
};

static struct w100_mode corgi_fb_modes[] = {
{
	.xres            = 480,
	.yres            = 640,
	.left_margin     = 0x56,
	.right_margin    = 0x55,
	.upper_margin    = 0x03,
	.lower_margin    = 0x00,
	.crtc_ss         = 0x82360056,
	.crtc_ls         = 0xA0280000,
	.crtc_gs         = 0x80280028,
	.crtc_vpos_gs    = 0x02830002,
	.crtc_rev        = 0x00400008,
	.crtc_dclk       = 0xA0000000,
	.crtc_gclk       = 0x8015010F,
	.crtc_goe        = 0x80100110,
	.crtc_ps1_active = 0x41060010,
	.pll_freq        = 75,
	.fast_pll_freq   = 100,
	.sysclk_src      = CLK_SRC_PLL,
	.sysclk_divider  = 0,
	.pixclk_src      = CLK_SRC_PLL,
	.pixclk_divider  = 2,
	.pixclk_divider_rotated = 6,
},{
	.xres            = 240,
	.yres            = 320,
	.left_margin     = 0x27,
	.right_margin    = 0x2e,
	.upper_margin    = 0x01,
	.lower_margin    = 0x00,
	.crtc_ss         = 0x81170027,
	.crtc_ls         = 0xA0140000,
	.crtc_gs         = 0xC0140014,
	.crtc_vpos_gs    = 0x00010141,
	.crtc_rev        = 0x00400008,
	.crtc_dclk       = 0xA0000000,
	.crtc_gclk       = 0x8015010F,
	.crtc_goe        = 0x80100110,
	.crtc_ps1_active = 0x41060010,
	.pll_freq        = 0,
	.fast_pll_freq   = 0,
	.sysclk_src      = CLK_SRC_XTAL,
	.sysclk_divider  = 0,
	.pixclk_src      = CLK_SRC_XTAL,
	.pixclk_divider  = 1,
	.pixclk_divider_rotated = 1,
},

};

static struct w100fb_mach_info corgi_fb_info = {
	.init_mode  = INIT_MODE_ROTATED,
	.mem        = &corgi_fb_mem,
	.regs       = &corgi_fb_regs,
	.modelist   = &corgi_fb_modes[0],
	.num_modes  = 2,
	.gpio       = &corgi_fb_gpio,
	.xtal_freq  = 12500000,
	.xtal_dbl   = 0,
};

static struct resource corgi_fb_resources[] = {
	[0] = {
		.start   = 0x08000000,
		.end     = 0x08ffffff,
		.flags   = IORESOURCE_MEM,
	},
};

static struct platform_device corgifb_device = {
	.name           = "w100fb",
	.id             = -1,
	.num_resources	= ARRAY_SIZE(corgi_fb_resources),
	.resource	= corgi_fb_resources,
	.dev            = {
		.platform_data = &corgi_fb_info,
	},

};

/*
 * Corgi Keyboard Device
 */
#define CORGI_KEY_CALENDER	KEY_F1
#define CORGI_KEY_ADDRESS	KEY_F2
#define CORGI_KEY_FN		KEY_F3
#define CORGI_KEY_CANCEL	KEY_F4
#define CORGI_KEY_OFF		KEY_SUSPEND
#define CORGI_KEY_EXOK		KEY_F5
#define CORGI_KEY_EXCANCEL	KEY_F6
#define CORGI_KEY_EXJOGDOWN	KEY_F7
#define CORGI_KEY_EXJOGUP	KEY_F8
#define CORGI_KEY_JAP1		KEY_LEFTCTRL
#define CORGI_KEY_JAP2		KEY_LEFTALT
#define CORGI_KEY_MAIL		KEY_F10
#define CORGI_KEY_OK		KEY_F11
#define CORGI_KEY_MENU		KEY_F12

static const uint32_t corgikbd_keymap[] = {
	KEY(0, 1, KEY_1),
	KEY(0, 2, KEY_3),
	KEY(0, 3, KEY_5),
	KEY(0, 4, KEY_6),
	KEY(0, 5, KEY_7),
	KEY(0, 6, KEY_9),
	KEY(0, 7, KEY_0),
	KEY(0, 8, KEY_BACKSPACE),
	KEY(1, 1, KEY_2),
	KEY(1, 2, KEY_4),
	KEY(1, 3, KEY_R),
	KEY(1, 4, KEY_Y),
	KEY(1, 5, KEY_8),
	KEY(1, 6, KEY_I),
	KEY(1, 7, KEY_O),
	KEY(1, 8, KEY_P),
	KEY(2, 0, KEY_TAB),
	KEY(2, 1, KEY_Q),
	KEY(2, 2, KEY_E),
	KEY(2, 3, KEY_T),
	KEY(2, 4, KEY_G),
	KEY(2, 5, KEY_U),
	KEY(2, 6, KEY_J),
	KEY(2, 7, KEY_K),
	KEY(3, 0, CORGI_KEY_CALENDER),
	KEY(3, 1, KEY_W),
	KEY(3, 2, KEY_S),
	KEY(3, 3, KEY_F),
	KEY(3, 4, KEY_V),
	KEY(3, 5, KEY_H),
	KEY(3, 6, KEY_M),
	KEY(3, 7, KEY_L),
	KEY(3, 9, KEY_RIGHTSHIFT),
	KEY(4, 0, CORGI_KEY_ADDRESS),
	KEY(4, 1, KEY_A),
	KEY(4, 2, KEY_D),
	KEY(4, 3, KEY_C),
	KEY(4, 4, KEY_B),
	KEY(4, 5, KEY_N),
	KEY(4, 6, KEY_DOT),
	KEY(4, 8, KEY_ENTER),
	KEY(4, 10, KEY_LEFTSHIFT),
	KEY(5, 0, CORGI_KEY_MAIL),
	KEY(5, 1, KEY_Z),
	KEY(5, 2, KEY_X),
	KEY(5, 3, KEY_MINUS),
	KEY(5, 4, KEY_SPACE),
	KEY(5, 5, KEY_COMMA),
	KEY(5, 7, KEY_UP),
	KEY(5, 11, CORGI_KEY_FN),
	KEY(6, 0, KEY_SYSRQ),
	KEY(6, 1, CORGI_KEY_JAP1),
	KEY(6, 2, CORGI_KEY_JAP2),
	KEY(6, 3, CORGI_KEY_CANCEL),
	KEY(6, 4, CORGI_KEY_OK),
	KEY(6, 5, CORGI_KEY_MENU),
	KEY(6, 6, KEY_LEFT),
	KEY(6, 7, KEY_DOWN),
	KEY(6, 8, KEY_RIGHT),
	KEY(7, 0, CORGI_KEY_OFF),
	KEY(7, 1, CORGI_KEY_EXOK),
	KEY(7, 2, CORGI_KEY_EXCANCEL),
	KEY(7, 3, CORGI_KEY_EXJOGDOWN),
	KEY(7, 4, CORGI_KEY_EXJOGUP),
};

static struct matrix_keymap_data corgikbd_keymap_data = {
	.keymap		= corgikbd_keymap,
	.keymap_size	= ARRAY_SIZE(corgikbd_keymap),
};

static const int corgikbd_row_gpios[] =
		{ 58, 59, 60, 61, 62, 63, 64, 65 };
static const int corgikbd_col_gpios[] =
		{ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77 };

static struct matrix_keypad_platform_data corgikbd_pdata = {
	.keymap_data		= &corgikbd_keymap_data,
	.row_gpios		= corgikbd_row_gpios,
	.col_gpios		= corgikbd_col_gpios,
	.num_row_gpios		= ARRAY_SIZE(corgikbd_row_gpios),
	.num_col_gpios		= ARRAY_SIZE(corgikbd_col_gpios),
	.col_scan_delay_us	= 10,
	.debounce_ms		= 10,
	.wakeup			= 1,
};

static struct platform_device corgikbd_device = {
	.name		= "matrix-keypad",
	.id		= -1,
	.dev		= {
		.platform_data = &corgikbd_pdata,
	},
};

/*
 * Corgi LEDs
 */
static struct gpio_led corgi_gpio_leds[] = {
	{
		.name			= "corgi:amber:charge",
		.default_trigger	= "sharpsl-charge",
		.gpio			= CORGI_GPIO_LED_ORANGE,
	},
	{
		.name			= "corgi:green:mail",
		.default_trigger	= "nand-disk",
		.gpio			= CORGI_GPIO_LED_GREEN,
	},
};

static struct gpio_led_platform_data corgi_gpio_leds_info = {
	.leds		= corgi_gpio_leds,
	.num_leds	= ARRAY_SIZE(corgi_gpio_leds),
};

static struct platform_device corgiled_device = {
	.name		= "leds-gpio",
	.id		= -1,
	.dev		= {
		.platform_data = &corgi_gpio_leds_info,
	},
};

/*
 * 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 = {
	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,
	.gpio_card_detect	= -1,
	.gpio_card_ro		= CORGI_GPIO_nSD_WP,
	.gpio_power		= CORGI_GPIO_SD_PWR,
};


/*
 * Irda
 */
static struct pxaficp_platform_data corgi_ficp_platform_data = {
	.gpio_pwdown		= CORGI_GPIO_IR_ON,
	.transceiver_cap	= IR_SIRMODE | IR_OFF,
};


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

#if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MASTER)
static struct pxa2xx_spi_master corgi_spi_info = {
	.num_chipselect	= 3,
};

static void corgi_wait_for_hsync(void)
{
	while (gpio_get_value(CORGI_GPIO_HSYNC))
		cpu_relax();

	while (!gpio_get_value(CORGI_GPIO_HSYNC))
		cpu_relax();
}

static struct ads7846_platform_data corgi_ads7846_info = {
	.model			= 7846,
	.vref_delay_usecs	= 100,
	.x_plate_ohms		= 419,
	.y_plate_ohms		= 486,
	.gpio_pendown		= CORGI_GPIO_TP_INT,
	.wait_for_sync		= corgi_wait_for_hsync,
};

static struct pxa2xx_spi_chip corgi_ads7846_chip = {
	.gpio_cs	= CORGI_GPIO_ADS7846_CS,
};

static void corgi_bl_kick_battery(void)
{
	void (*kick_batt)(void);

	kick_batt = symbol_get(sharpsl_battery_kick);
	if (kick_batt) {
		kick_batt();
		symbol_put(sharpsl_battery_kick);
	}
}

static struct corgi_lcd_platform_data corgi_lcdcon_info = {
	.init_mode		= CORGI_LCD_MODE_VGA,
	.max_intensity		= 0x2f,
	.default_intensity	= 0x1f,
	.limit_mask		= 0x0b,
	.gpio_backlight_cont	= CORGI_GPIO_BACKLIGHT_CONT,
	.gpio_backlight_on	= -1,
	.kick_battery		= corgi_bl_kick_battery,
};

static struct pxa2xx_spi_chip corgi_lcdcon_chip = {
	.gpio_cs	= CORGI_GPIO_LCDCON_CS,
};

static struct pxa2xx_spi_chip corgi_max1111_chip = {
	.gpio_cs	= CORGI_GPIO_MAX1111_CS,
};

static struct spi_board_info corgi_spi_devices[] = {
	{
		.modalias	= "ads7846",
		.max_speed_hz	= 1200000,
		.bus_num	= 1,
		.chip_select	= 0,
		.platform_data	= &corgi_ads7846_info,
		.controller_data= &corgi_ads7846_chip,
		.irq		= gpio_to_irq(CORGI_GPIO_TP_INT),
	}, {
		.modalias	= "corgi-lcd",
		.max_speed_hz	= 50000,
		.bus_num	= 1,
		.chip_select	= 1,
		.platform_data	= &corgi_lcdcon_info,
		.controller_data= &corgi_lcdcon_chip,
	}, {
		.modalias	= "max1111",
		.max_speed_hz	= 450000,
		.bus_num	= 1,
		.chip_select	= 2,
		.controller_data= &corgi_max1111_chip,
	},
};

static void __init corgi_init_spi(void)
{
	pxa2xx_set_spi_info(1, &corgi_spi_info);
	spi_register_board_info(ARRAY_AND_SIZE(corgi_spi_devices));
}
#else
static inline void corgi_init_spi(void) {}
#endif

static struct mtd_partition sharpsl_nand_partitions[] = {
	{
		.name = "System Area",
		.offset = 0,
		.size = 7 * 1024 * 1024,
	},
	{
		.name = "Root Filesystem",
		.offset = 7 * 1024 * 1024,
		.size = 25 * 1024 * 1024,
	},
	{
		.name = "Home Filesystem",
		.offset = MTDPART_OFS_APPEND,
		.size = MTDPART_SIZ_FULL,
	},
};

static uint8_t scan_ff_pattern[] = { 0xff, 0xff };

static struct nand_bbt_descr sharpsl_bbt = {
	.options = 0,
	.offs = 4,
	.len = 2,
	.pattern = scan_ff_pattern
};

static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
	.badblock_pattern	= &sharpsl_bbt,
	.partitions		= sharpsl_nand_partitions,
	.nr_partitions		= ARRAY_SIZE(sharpsl_nand_partitions),
};

static struct resource sharpsl_nand_resources[] = {
	{
		.start	= 0x0C000000,
		.end	= 0x0C000FFF,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device sharpsl_nand_device = {
	.name		= "sharpsl-nand",
	.id		= -1,
	.resource	= sharpsl_nand_resources,
	.num_resources	= ARRAY_SIZE(sharpsl_nand_resources),
	.dev.platform_data	= &sharpsl_nand_platform_data,
};

static struct mtd_partition sharpsl_rom_parts[] = {
	{
		.name	="Boot PROM Filesystem",
		.offset	= 0x00120000,
		.size	= MTDPART_SIZ_FULL,
	},
};

static struct physmap_flash_data sharpsl_rom_data = {
	.width		= 2,
	.nr_parts	= ARRAY_SIZE(sharpsl_rom_parts),
	.parts		= sharpsl_rom_parts,
};

static struct resource sharpsl_rom_resources[] = {
	{
		.start	= 0x00000000,
		.end	= 0x007fffff,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device sharpsl_rom_device = {
	.name	= "physmap-flash",
	.id	= -1,
	.resource = sharpsl_rom_resources,
	.num_resources = ARRAY_SIZE(sharpsl_rom_resources),
	.dev.platform_data = &sharpsl_rom_data,
};

static struct platform_device *devices[] __initdata = {
	&corgiscoop_device,
	&corgifb_device,
	&corgikbd_device,
	&corgiled_device,
	&sharpsl_nand_device,
	&sharpsl_rom_device,
};

static struct i2c_board_info __initdata corgi_i2c_devices[] = {
	{ I2C_BOARD_INFO("wm8731", 0x1b) },
};

static void corgi_poweroff(void)
{
	if (!machine_is_corgi())
		/* Green LED off tells the bootloader to halt */
		gpio_set_value(CORGI_GPIO_LED_GREEN, 0);

	arm_machine_restart('h', NULL);
}

static void corgi_restart(char mode, const char *cmd)
{
	if (!machine_is_corgi())
		/* Green LED on tells the bootloader to reboot */
		gpio_set_value(CORGI_GPIO_LED_GREEN, 1);

	arm_machine_restart('h', cmd);
}

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

	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
	PCFR |= PCFR_OPDE;

	pxa2xx_mfp_config(ARRAY_AND_SIZE(corgi_pin_config));

	pxa_set_ffuart_info(NULL);
	pxa_set_btuart_info(NULL);
	pxa_set_stuart_info(NULL);

	corgi_init_spi();

 	pxa_set_udc_info(&udc_info);
	corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);
	pxa_set_mci_info(&corgi_mci_platform_data);
	pxa_set_ficp_info(&corgi_ficp_platform_data);
	pxa_set_i2c_info(NULL);
	i2c_register_board_info(0, ARRAY_AND_SIZE(corgi_i2c_devices));

	platform_scoop_config = &corgi_pcmcia_config;

	if (machine_is_husky())
		sharpsl_nand_partitions[1].size = 53 * 1024 * 1024;

	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>
4a9295cc	22	#include <linux/mtd/physmap.h>
74617fb6	23	#include <linux/pm.h>
9d708752	24	#include <linux/gpio.h>
c3f8f650	25	#include <linux/backlight.h>
8776b268	26	#include <linux/i2c.h>
fced80c7	27	#include <linux/io.h>
edb403fb EM	28	#include <linux/spi/spi.h>
	29	#include <linux/spi/ads7846.h>
	30	#include <linux/spi/corgi_lcd.h>
6af7a8eb	31	#include <linux/mtd/sharpsl.h>
a90c4fb8	32	#include <linux/input/matrix_keypad.h>
ca4d6cfc	33	#include <video/w100fb.h>
1da177e4 LT	34
	35	#include <asm/setup.h>
	36	#include <asm/memory.h>
	37	#include <asm/mach-types.h>
a09e64fb	38	#include <mach/hardware.h>
1da177e4	39	#include <asm/irq.h>
74617fb6	40	#include <asm/system.h>
1da177e4 LT	41
	42	#include <asm/mach/arch.h>
	43	#include <asm/mach/map.h>
	44	#include <asm/mach/irq.h>
	45
51c62982	46	#include <mach/pxa25x.h>
f0a83701	47	#include <plat/i2c.h>
a09e64fb RK	48	#include <mach/irda.h>
	49	#include <mach/mmc.h>
	50	#include <mach/udc.h>
edb403fb	51	#include <mach/pxa2xx_spi.h>
a09e64fb RK	52	#include <mach/corgi.h>
a09e64fb RK	53	#include <mach/sharpsl.h>
1da177e4 LT	54
	55	#include <asm/mach/sharpsl_param.h>
	56	#include <asm/hardware/scoop.h>
1da177e4 LT	57
1da177e4 LT	58	#include "generic.h"
46c41e62	59	#include "devices.h"
50a5de44	60	#include "sharpsl.h"
1da177e4	61
9ae808d8 EM	62	static unsigned long corgi_pin_config[] __initdata = {
	63	/* Static Memory I/O */
	64	GPIO78_nCS_2, /* w100fb */
	65	GPIO80_nCS_4, /* scoop */
	66
	67	/* SSP1 */
	68	GPIO23_SSP1_SCLK,
	69	GPIO25_SSP1_TXD,
	70	GPIO26_SSP1_RXD,
	71	GPIO24_GPIO, /* CORGI_GPIO_ADS7846_CS - SFRM as chip select */
	72
	73	/* I2S */
	74	GPIO28_I2S_BITCLK_OUT,
	75	GPIO29_I2S_SDATA_IN,
	76	GPIO30_I2S_SDATA_OUT,
	77	GPIO31_I2S_SYNC,
	78	GPIO32_I2S_SYSCLK,
	79
	80	/* Infra-Red */
	81	GPIO47_FICP_TXD,
	82	GPIO46_FICP_RXD,
	83
	84	/* FFUART */
	85	GPIO40_FFUART_DTR,
	86	GPIO41_FFUART_RTS,
	87	GPIO39_FFUART_TXD,
	88	GPIO37_FFUART_DSR,
	89	GPIO34_FFUART_RXD,
	90	GPIO35_FFUART_CTS,
	91
	92	/* PC Card */
	93	GPIO48_nPOE,
	94	GPIO49_nPWE,
	95	GPIO50_nPIOR,
	96	GPIO51_nPIOW,
	97	GPIO52_nPCE_1,
	98	GPIO53_nPCE_2,
	99	GPIO54_nPSKTSEL,
	100	GPIO55_nPREG,
	101	GPIO56_nPWAIT,
	102	GPIO57_nIOIS16,
	103
	104	/* MMC */
	105	GPIO6_MMC_CLK,
	106	GPIO8_MMC_CS0,
	107
a90c4fb8 EM	108	/* GPIO Matrix Keypad */
	109	GPIO66_GPIO, /* column 0 */
	110	GPIO67_GPIO, /* column 1 */
	111	GPIO68_GPIO, /* column 2 */
	112	GPIO69_GPIO, /* column 3 */
	113	GPIO70_GPIO, /* column 4 */
	114	GPIO71_GPIO, /* column 5 */
	115	GPIO72_GPIO, /* column 6 */
	116	GPIO73_GPIO, /* column 7 */
	117	GPIO74_GPIO, /* column 8 */
	118	GPIO75_GPIO, /* column 9 */
	119	GPIO76_GPIO, /* column 10 */
	120	GPIO77_GPIO, /* column 11 */
	121	GPIO58_GPIO, /* row 0 */
	122	GPIO59_GPIO, /* row 1 */
	123	GPIO60_GPIO, /* row 2 */
	124	GPIO61_GPIO, /* row 3 */
	125	GPIO62_GPIO, /* row 4 */
	126	GPIO63_GPIO, /* row 5 */
	127	GPIO64_GPIO, /* row 6 */
	128	GPIO65_GPIO, /* row 7 */
	129
9ae808d8 EM	130	/* GPIO */
	131	GPIO9_GPIO, /* CORGI_GPIO_nSD_DETECT */
	132	GPIO7_GPIO, /* CORGI_GPIO_nSD_WP */
e63f591a	133	GPIO21_GPIO, /* CORGI_GPIO_ADC_TEMP */
9ae808d8	134	GPIO22_GPIO, /* CORGI_GPIO_IR_ON */
e63f591a EM	135	GPIO33_GPIO, /* CORGI_GPIO_SD_PWR */
	136	GPIO38_GPIO, /* CORGI_GPIO_CHRG_ON */
	137	GPIO43_GPIO, /* CORGI_GPIO_CHRG_UKN */
9ae808d8 EM	138	GPIO44_GPIO, /* CORGI_GPIO_HSYNC */
9ae808d8 EM	139
e63f591a EM	140	GPIO0_GPIO \| WAKEUP_ON_EDGE_BOTH, /* CORGI_GPIO_KEY_INT */
e63f591a EM	141	GPIO1_GPIO \| WAKEUP_ON_EDGE_RISE, /* CORGI_GPIO_AC_IN */
9ae808d8	142	};
1da177e4 LT	143
	144	/*
	145	* Corgi SCOOP Device
	146	*/
	147	static struct resource corgi_scoop_resources[] = {
	148	[0] = {
	149	.start = 0x10800000,
	150	.end = 0x10800fff,
	151	.flags = IORESOURCE_MEM,
	152	},
	153	};
	154
	155	static struct scoop_config corgi_scoop_setup = {
	156	.io_dir = CORGI_SCOOP_IO_DIR,
	157	.io_out = CORGI_SCOOP_IO_OUT,
6168cda9	158	.gpio_base = CORGI_SCOOP_GPIO_BASE,
1da177e4 LT	159	};
1da177e4 LT	160
a63ae442 RP	161	struct platform_device corgiscoop_device = {
	162	.name = "sharp-scoop",
	163	.id = -1,
	164	.dev = {
	165	.platform_data = &corgi_scoop_setup,
	166	},
	167	.num_resources = ARRAY_SIZE(corgi_scoop_resources),
	168	.resource = corgi_scoop_resources,
	169	};
	170
0ce7625f RP	171	static struct scoop_pcmcia_dev corgi_pcmcia_scoop[] = {
	172	{
	173	.dev = &corgiscoop_device.dev,
	174	.irq = CORGI_IRQ_GPIO_CF_IRQ,
	175	.cd_irq = CORGI_IRQ_GPIO_CF_CD,
	176	.cd_irq_str = "PCMCIA0 CD",
	177	},
	178	};
	179
a63ae442 RP	180	static struct scoop_pcmcia_config corgi_pcmcia_config = {
	181	.devs = &corgi_pcmcia_scoop[0],
	182	.num_devs = 1,
1da177e4 LT	183	};
1da177e4 LT	184
a63ae442 RP	185	EXPORT_SYMBOL(corgiscoop_device);
a63ae442 RP	186
ca4d6cfc RP	187	static struct w100_mem_info corgi_fb_mem = {
	188	.ext_cntl = 0x00040003,
	189	.sdram_mode_reg = 0x00650021,
	190	.ext_timing_cntl = 0x10002a4a,
	191	.io_cntl = 0x7ff87012,
	192	.size = 0x1fffff,
	193	};
	194
	195	static struct w100_gen_regs corgi_fb_regs = {
	196	.lcd_format = 0x00000003,
	197	.lcdd_cntl1 = 0x01CC0000,
	198	.lcdd_cntl2 = 0x0003FFFF,
	199	.genlcd_cntl1 = 0x00FFFF0D,
	200	.genlcd_cntl2 = 0x003F3003,
	201	.genlcd_cntl3 = 0x000102aa,
	202	};
	203
	204	static struct w100_gpio_regs corgi_fb_gpio = {
	205	.init_data1 = 0x000000bf,
	206	.init_data2 = 0x00000000,
	207	.gpio_dir1 = 0x00000000,
	208	.gpio_oe1 = 0x03c0feff,
	209	.gpio_dir2 = 0x00000000,
	210	.gpio_oe2 = 0x00000000,
	211	};
	212
	213	static struct w100_mode corgi_fb_modes[] = {
	214	{
	215	.xres = 480,
	216	.yres = 640,
	217	.left_margin = 0x56,
	218	.right_margin = 0x55,
	219	.upper_margin = 0x03,
	220	.lower_margin = 0x00,
	221	.crtc_ss = 0x82360056,
	222	.crtc_ls = 0xA0280000,
	223	.crtc_gs = 0x80280028,
	224	.crtc_vpos_gs = 0x02830002,
	225	.crtc_rev = 0x00400008,
	226	.crtc_dclk = 0xA0000000,
	227	.crtc_gclk = 0x8015010F,
	228	.crtc_goe = 0x80100110,
	229	.crtc_ps1_active = 0x41060010,
	230	.pll_freq = 75,
	231	.fast_pll_freq = 100,
	232	.sysclk_src = CLK_SRC_PLL,
	233	.sysclk_divider = 0,
	234	.pixclk_src = CLK_SRC_PLL,
	235	.pixclk_divider = 2,
	236	.pixclk_divider_rotated = 6,
	237	},{
	238	.xres = 240,
	239	.yres = 320,
	240	.left_margin = 0x27,
	241	.right_margin = 0x2e,
	242	.upper_margin = 0x01,
	243	.lower_margin = 0x00,
	244	.crtc_ss = 0x81170027,
	245	.crtc_ls = 0xA0140000,
	246	.crtc_gs = 0xC0140014,
	247	.crtc_vpos_gs = 0x00010141,
	248	.crtc_rev = 0x00400008,
	249	.crtc_dclk = 0xA0000000,
	250	.crtc_gclk = 0x8015010F,
251	.crtc_goe = 0x80100110,
252	.crtc_ps1_active = 0x41060010,
253	.pll_freq = 0,
254	.fast_pll_freq = 0,
255	.sysclk_src = CLK_SRC_XTAL,
256	.sysclk_divider = 0,
257	.pixclk_src = CLK_SRC_XTAL,
258	.pixclk_divider = 1,
259	.pixclk_divider_rotated = 1,
260	},
261
262	};
263
264	static struct w100fb_mach_info corgi_fb_info = {
ca4d6cfc RP	265	.init_mode = INIT_MODE_ROTATED,
	266	.mem = &corgi_fb_mem,
	267	.regs = &corgi_fb_regs,
	268	.modelist = &corgi_fb_modes[0],
	269	.num_modes = 2,
	270	.gpio = &corgi_fb_gpio,
	271	.xtal_freq = 12500000,
	272	.xtal_dbl = 0,
	273	};
	274
	275	static struct resource corgi_fb_resources[] = {
	276	[0] = {
	277	.start = 0x08000000,
	278	.end = 0x08ffffff,
	279	.flags = IORESOURCE_MEM,
	280	},
	281	};
	282
	283	static struct platform_device corgifb_device = {
	284	.name = "w100fb",
	285	.id = -1,
	286	.num_resources = ARRAY_SIZE(corgi_fb_resources),
	287	.resource = corgi_fb_resources,
	288	.dev = {
	289	.platform_data = &corgi_fb_info,
ca4d6cfc RP	290	},
	291
	292	};
	293
f7ceff34 RP	294	/*
	295	* Corgi Keyboard Device
	296	*/
a90c4fb8 EM	297	#define CORGI_KEY_CALENDER KEY_F1
	298	#define CORGI_KEY_ADDRESS KEY_F2
	299	#define CORGI_KEY_FN KEY_F3
	300	#define CORGI_KEY_CANCEL KEY_F4
	301	#define CORGI_KEY_OFF KEY_SUSPEND
	302	#define CORGI_KEY_EXOK KEY_F5
	303	#define CORGI_KEY_EXCANCEL KEY_F6
	304	#define CORGI_KEY_EXJOGDOWN KEY_F7
	305	#define CORGI_KEY_EXJOGUP KEY_F8
	306	#define CORGI_KEY_JAP1 KEY_LEFTCTRL
	307	#define CORGI_KEY_JAP2 KEY_LEFTALT
	308	#define CORGI_KEY_MAIL KEY_F10
	309	#define CORGI_KEY_OK KEY_F11
	310	#define CORGI_KEY_MENU KEY_F12
	311
	312	static const uint32_t corgikbd_keymap[] = {
	313	KEY(0, 1, KEY_1),
	314	KEY(0, 2, KEY_3),
	315	KEY(0, 3, KEY_5),
	316	KEY(0, 4, KEY_6),
	317	KEY(0, 5, KEY_7),
	318	KEY(0, 6, KEY_9),
	319	KEY(0, 7, KEY_0),
	320	KEY(0, 8, KEY_BACKSPACE),
	321	KEY(1, 1, KEY_2),
	322	KEY(1, 2, KEY_4),
	323	KEY(1, 3, KEY_R),
	324	KEY(1, 4, KEY_Y),
	325	KEY(1, 5, KEY_8),
	326	KEY(1, 6, KEY_I),
	327	KEY(1, 7, KEY_O),
	328	KEY(1, 8, KEY_P),
	329	KEY(2, 0, KEY_TAB),
	330	KEY(2, 1, KEY_Q),
	331	KEY(2, 2, KEY_E),
	332	KEY(2, 3, KEY_T),
	333	KEY(2, 4, KEY_G),
	334	KEY(2, 5, KEY_U),
	335	KEY(2, 6, KEY_J),
	336	KEY(2, 7, KEY_K),
	337	KEY(3, 0, CORGI_KEY_CALENDER),
	338	KEY(3, 1, KEY_W),
	339	KEY(3, 2, KEY_S),
	340	KEY(3, 3, KEY_F),
	341	KEY(3, 4, KEY_V),
	342	KEY(3, 5, KEY_H),
	343	KEY(3, 6, KEY_M),
	344	KEY(3, 7, KEY_L),
	345	KEY(3, 9, KEY_RIGHTSHIFT),
	346	KEY(4, 0, CORGI_KEY_ADDRESS),
	347	KEY(4, 1, KEY_A),
	348	KEY(4, 2, KEY_D),
	349	KEY(4, 3, KEY_C),
	350	KEY(4, 4, KEY_B),
	351	KEY(4, 5, KEY_N),
	352	KEY(4, 6, KEY_DOT),
	353	KEY(4, 8, KEY_ENTER),
	354	KEY(4, 10, KEY_LEFTSHIFT),
	355	KEY(5, 0, CORGI_KEY_MAIL),
	356	KEY(5, 1, KEY_Z),
	357	KEY(5, 2, KEY_X),
	358	KEY(5, 3, KEY_MINUS),
	359	KEY(5, 4, KEY_SPACE),
	360	KEY(5, 5, KEY_COMMA),
361	KEY(5, 7, KEY_UP),
362	KEY(5, 11, CORGI_KEY_FN),
363	KEY(6, 0, KEY_SYSRQ),
364	KEY(6, 1, CORGI_KEY_JAP1),
365	KEY(6, 2, CORGI_KEY_JAP2),
366	KEY(6, 3, CORGI_KEY_CANCEL),
367	KEY(6, 4, CORGI_KEY_OK),
368	KEY(6, 5, CORGI_KEY_MENU),
369	KEY(6, 6, KEY_LEFT),
370	KEY(6, 7, KEY_DOWN),
371	KEY(6, 8, KEY_RIGHT),
372	KEY(7, 0, CORGI_KEY_OFF),
373	KEY(7, 1, CORGI_KEY_EXOK),
374	KEY(7, 2, CORGI_KEY_EXCANCEL),
375	KEY(7, 3, CORGI_KEY_EXJOGDOWN),
376	KEY(7, 4, CORGI_KEY_EXJOGUP),
377	};
378
379	static struct matrix_keymap_data corgikbd_keymap_data = {
380	.keymap = corgikbd_keymap,
381	.keymap_size = ARRAY_SIZE(corgikbd_keymap),
382	};
383
384	static const int corgikbd_row_gpios[] =
385	{ 58, 59, 60, 61, 62, 63, 64, 65 };
386	static const int corgikbd_col_gpios[] =
387	{ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77 };
388
389	static struct matrix_keypad_platform_data corgikbd_pdata = {
390	.keymap_data = &corgikbd_keymap_data,
391	.row_gpios = corgikbd_row_gpios,
392	.col_gpios = corgikbd_col_gpios,
393	.num_row_gpios = ARRAY_SIZE(corgikbd_row_gpios),
394	.num_col_gpios = ARRAY_SIZE(corgikbd_col_gpios),
395	.col_scan_delay_us = 10,
396	.debounce_ms = 10,
397	.wakeup = 1,
398	};
399
f7ceff34	400	static struct platform_device corgikbd_device = {
a90c4fb8	401	.name = "matrix-keypad",
f7ceff34	402	.id = -1,
a90c4fb8 EM	403	.dev = {
	404	.platform_data = &corgikbd_pdata,
	405	},
f7ceff34 RP	406	};
f7ceff34 RP	407
3179108d RP	408	/*
	409	* Corgi LEDs
	410	*/
60cf711d EM	411	static struct gpio_led corgi_gpio_leds[] = {
	412	{
	413	.name = "corgi:amber:charge",
	414	.default_trigger = "sharpsl-charge",
	415	.gpio = CORGI_GPIO_LED_ORANGE,
	416	},
	417	{
	418	.name = "corgi:green:mail",
	419	.default_trigger = "nand-disk",
	420	.gpio = CORGI_GPIO_LED_GREEN,
513b6e1a RP	421	},
	422	};
	423
60cf711d EM	424	static struct gpio_led_platform_data corgi_gpio_leds_info = {
	425	.leds = corgi_gpio_leds,
	426	.num_leds = ARRAY_SIZE(corgi_gpio_leds),
513b6e1a RP	427	};
513b6e1a RP	428
3179108d	429	static struct platform_device corgiled_device = {
60cf711d	430	.name = "leds-gpio",
3179108d	431	.id = -1,
f7ceff34	432	.dev = {
60cf711d	433	.platform_data = &corgi_gpio_leds_info,
f7ceff34	434	},
f7ceff34 RP	435	};
f7ceff34 RP	436
1da177e4 LT	437	/*
	438	* MMC/SD Device
	439	*
aa6c2e79	440	* The card detect interrupt isn't debounced so we delay it by 250ms
1da177e4 LT	441	* to give the card a chance to fully insert/eject.
1da177e4 LT	442	*/
1da177e4	443	static struct pxamci_platform_data corgi_mci_platform_data = {
7a648256 RJ	444	.ocr_mask = MMC_VDD_32_33\|MMC_VDD_33_34,
	445	.gpio_card_detect = -1,
	446	.gpio_card_ro = CORGI_GPIO_nSD_WP,
	447	.gpio_power = CORGI_GPIO_SD_PWR,
1da177e4 LT	448	};
	449
	450
ca1140b5 RP	451	/*
	452	* Irda
	453	*/
ca1140b5	454	static struct pxaficp_platform_data corgi_ficp_platform_data = {
c4bd0172	455	.gpio_pwdown = CORGI_GPIO_IR_ON,
9d708752	456	.transceiver_cap = IR_SIRMODE \| IR_OFF,
ca1140b5 RP	457	};
ca1140b5 RP	458
f7ceff34	459
1da177e4 LT	460	/*
	461	* USB Device Controller
	462	*/
1da177e4	463	static struct pxa2xx_udc_mach_info udc_info __initdata = {
0375fc03	464	.gpio_vbus = -1,
1da177e4	465	/* no connect GPIO; corgi can't tell connection status */
b2bbb20b	466	.gpio_pullup = CORGI_GPIO_USB_PULLUP,
1da177e4 LT	467	};
1da177e4 LT	468
edb403fb EM	469	#if defined(CONFIG_SPI_PXA2XX) \|\| defined(CONFIG_SPI_PXA2XX_MASTER)
	470	static struct pxa2xx_spi_master corgi_spi_info = {
	471	.num_chipselect = 3,
	472	};
	473
3e36c0de EM	474	static void corgi_wait_for_hsync(void)
	475	{
	476	while (gpio_get_value(CORGI_GPIO_HSYNC))
	477	cpu_relax();
	478
	479	while (!gpio_get_value(CORGI_GPIO_HSYNC))
	480	cpu_relax();
	481	}
	482
edb403fb EM	483	static struct ads7846_platform_data corgi_ads7846_info = {
	484	.model = 7846,
	485	.vref_delay_usecs = 100,
	486	.x_plate_ohms = 419,
	487	.y_plate_ohms = 486,
	488	.gpio_pendown = CORGI_GPIO_TP_INT,
3e36c0de	489	.wait_for_sync = corgi_wait_for_hsync,
edb403fb EM	490	};
edb403fb EM	491
edb403fb	492	static struct pxa2xx_spi_chip corgi_ads7846_chip = {
46580c03	493	.gpio_cs = CORGI_GPIO_ADS7846_CS,
edb403fb EM	494	};
edb403fb EM	495
edb403fb EM	496	static void corgi_bl_kick_battery(void)
	497	{
	498	void (*kick_batt)(void);
	499
	500	kick_batt = symbol_get(sharpsl_battery_kick);
	501	if (kick_batt) {
	502	kick_batt();
	503	symbol_put(sharpsl_battery_kick);
	504	}
	505	}
	506
	507	static struct corgi_lcd_platform_data corgi_lcdcon_info = {
	508	.init_mode = CORGI_LCD_MODE_VGA,
	509	.max_intensity = 0x2f,
	510	.default_intensity = 0x1f,
	511	.limit_mask = 0x0b,
ff7a4c71 EM	512	.gpio_backlight_cont = CORGI_GPIO_BACKLIGHT_CONT,
ff7a4c71 EM	513	.gpio_backlight_on = -1,
edb403fb EM	514	.kick_battery = corgi_bl_kick_battery,
	515	};
	516
edb403fb	517	static struct pxa2xx_spi_chip corgi_lcdcon_chip = {
46580c03	518	.gpio_cs = CORGI_GPIO_LCDCON_CS,
edb403fb EM	519	};
edb403fb EM	520
edb403fb	521	static struct pxa2xx_spi_chip corgi_max1111_chip = {
46580c03	522	.gpio_cs = CORGI_GPIO_MAX1111_CS,
edb403fb EM	523	};
	524
	525	static struct spi_board_info corgi_spi_devices[] = {
	526	{
	527	.modalias = "ads7846",
	528	.max_speed_hz = 1200000,
	529	.bus_num = 1,
	530	.chip_select = 0,
	531	.platform_data = &corgi_ads7846_info,
	532	.controller_data= &corgi_ads7846_chip,
	533	.irq = gpio_to_irq(CORGI_GPIO_TP_INT),
	534	}, {
	535	.modalias = "corgi-lcd",
	536	.max_speed_hz = 50000,
	537	.bus_num = 1,
	538	.chip_select = 1,
	539	.platform_data = &corgi_lcdcon_info,
	540	.controller_data= &corgi_lcdcon_chip,
	541	}, {
	542	.modalias = "max1111",
	543	.max_speed_hz = 450000,
	544	.bus_num = 1,
	545	.chip_select = 2,
	546	.controller_data= &corgi_max1111_chip,
	547	},
	548	};
	549
	550	static void __init corgi_init_spi(void)
	551	{
edb403fb EM	552	pxa2xx_set_spi_info(1, &corgi_spi_info);
edb403fb EM	553	spi_register_board_info(ARRAY_AND_SIZE(corgi_spi_devices));
edb403fb EM	554	}
	555	#else
	556	static inline void corgi_init_spi(void) {}
	557	#endif
1da177e4	558
6af7a8eb DB	559	static struct mtd_partition sharpsl_nand_partitions[] = {
	560	{
	561	.name = "System Area",
	562	.offset = 0,
	563	.size = 7 * 1024 * 1024,
	564	},
	565	{
	566	.name = "Root Filesystem",
	567	.offset = 7 * 1024 * 1024,
	568	.size = 25 * 1024 * 1024,
	569	},
	570	{
	571	.name = "Home Filesystem",
	572	.offset = MTDPART_OFS_APPEND,
	573	.size = MTDPART_SIZ_FULL,
	574	},
	575	};
	576
	577	static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
	578
	579	static struct nand_bbt_descr sharpsl_bbt = {
	580	.options = 0,
	581	.offs = 4,
	582	.len = 2,
	583	.pattern = scan_ff_pattern
	584	};
	585
	586	static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
	587	.badblock_pattern = &sharpsl_bbt,
	588	.partitions = sharpsl_nand_partitions,
	589	.nr_partitions = ARRAY_SIZE(sharpsl_nand_partitions),
	590	};
	591
	592	static struct resource sharpsl_nand_resources[] = {
	593	{
	594	.start = 0x0C000000,
	595	.end = 0x0C000FFF,
	596	.flags = IORESOURCE_MEM,
	597	},
	598	};
	599
	600	static struct platform_device sharpsl_nand_device = {
	601	.name = "sharpsl-nand",
	602	.id = -1,
	603	.resource = sharpsl_nand_resources,
	604	.num_resources = ARRAY_SIZE(sharpsl_nand_resources),
	605	.dev.platform_data = &sharpsl_nand_platform_data,
	606	};
	607
4a9295cc DB	608	static struct mtd_partition sharpsl_rom_parts[] = {
	609	{
	610	.name ="Boot PROM Filesystem",
	611	.offset = 0x00120000,
	612	.size = MTDPART_SIZ_FULL,
	613	},
	614	};
	615
	616	static struct physmap_flash_data sharpsl_rom_data = {
	617	.width = 2,
	618	.nr_parts = ARRAY_SIZE(sharpsl_rom_parts),
	619	.parts = sharpsl_rom_parts,
	620	};
	621
	622	static struct resource sharpsl_rom_resources[] = {
	623	{
	624	.start = 0x00000000,
	625	.end = 0x007fffff,
	626	.flags = IORESOURCE_MEM,
	627	},
	628	};
	629
	630	static struct platform_device sharpsl_rom_device = {
	631	.name = "physmap-flash",
	632	.id = -1,
	633	.resource = sharpsl_rom_resources,
	634	.num_resources = ARRAY_SIZE(sharpsl_rom_resources),
	635	.dev.platform_data = &sharpsl_rom_data,
	636	};
	637
1da177e4 LT	638	static struct platform_device *devices[] __initdata = {
1da177e4 LT	639	&corgiscoop_device,
1da177e4	640	&corgifb_device,
f7ceff34	641	&corgikbd_device,
3179108d	642	&corgiled_device,
6af7a8eb	643	&sharpsl_nand_device,
4a9295cc	644	&sharpsl_rom_device,
1da177e4 LT	645	};
1da177e4 LT	646
8776b268 MB	647	static struct i2c_board_info __initdata corgi_i2c_devices[] = {
	648	{ I2C_BOARD_INFO("wm8731", 0x1b) },
	649	};
	650
74617fb6 RP	651	static void corgi_poweroff(void)
74617fb6 RP	652	{
74617fb6 RP	653	if (!machine_is_corgi())
74617fb6 RP	654	/* Green LED off tells the bootloader to halt */
6168cda9 EM	655	gpio_set_value(CORGI_GPIO_LED_GREEN, 0);
6168cda9 EM	656
be093beb	657	arm_machine_restart('h', NULL);
74617fb6 RP	658	}
74617fb6 RP	659
be093beb	660	static void corgi_restart(char mode, const char *cmd)
74617fb6	661	{
74617fb6 RP	662	if (!machine_is_corgi())
74617fb6 RP	663	/* Green LED on tells the bootloader to reboot */
6168cda9 EM	664	gpio_set_value(CORGI_GPIO_LED_GREEN, 1);
6168cda9 EM	665
be093beb	666	arm_machine_restart('h', cmd);
74617fb6 RP	667	}
74617fb6 RP	668
1da177e4 LT	669	static void __init corgi_init(void)
1da177e4 LT	670	{
74617fb6 RP	671	pm_power_off = corgi_poweroff;
	672	arm_pm_restart = corgi_restart;
	673
fdce05bb RP	674	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
	675	PCFR \|= PCFR_OPDE;
	676
9ae808d8	677	pxa2xx_mfp_config(ARRAY_AND_SIZE(corgi_pin_config));
50a5de44	678
cc155c6f RK	679	pxa_set_ffuart_info(NULL);
	680	pxa_set_btuart_info(NULL);
	681	pxa_set_stuart_info(NULL);
	682
edb403fb	683	corgi_init_spi();
ca1140b5	684
1da177e4	685	pxa_set_udc_info(&udc_info);
7a648256	686	corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);
1da177e4	687	pxa_set_mci_info(&corgi_mci_platform_data);
ca1140b5	688	pxa_set_ficp_info(&corgi_ficp_platform_data);
f8787fdc	689	pxa_set_i2c_info(NULL);
8776b268	690	i2c_register_board_info(0, ARRAY_AND_SIZE(corgi_i2c_devices));
1da177e4	691
a63ae442	692	platform_scoop_config = &corgi_pcmcia_config;
0ce7625f	693
6af7a8eb DB	694	if (machine_is_husky())
	695	sharpsl_nand_partitions[1].size = 53 * 1024 * 1024;
	696
1da177e4 LT	697	platform_add_devices(devices, ARRAY_SIZE(devices));
	698	}
	699
	700	static void __init fixup_corgi(struct machine_desc *desc,
	701	struct tag tags, char cmdline, struct meminfo mi)
	702	{
	703	sharpsl_save_param();
	704	mi->nr_banks=1;
	705	mi->bank[0].start = 0xa0000000;
	706	mi->bank[0].node = 0;
	707	if (machine_is_corgi())
	708	mi->bank[0].size = (3210241024);
	709	else
	710	mi->bank[0].size = (6410241024);
	711	}
	712
1da177e4 LT	713	#ifdef CONFIG_MACH_CORGI
1da177e4 LT	714	MACHINE_START(CORGI, "SHARP Corgi")
e9dea0c6	715	.phys_io = 0x40000000,
68070bde	716	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
e9dea0c6	717	.fixup = fixup_corgi,
fdce05bb	718	.map_io = pxa_map_io,
cd49104d	719	.init_irq = pxa25x_init_irq,
e9dea0c6 RK	720	.init_machine = corgi_init,
e9dea0c6 RK	721	.timer = &pxa_timer,
1da177e4 LT	722	MACHINE_END
	723	#endif
	724
	725	#ifdef CONFIG_MACH_SHEPHERD
	726	MACHINE_START(SHEPHERD, "SHARP Shepherd")
e9dea0c6	727	.phys_io = 0x40000000,
68070bde	728	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
e9dea0c6	729	.fixup = fixup_corgi,
fdce05bb	730	.map_io = pxa_map_io,
cd49104d	731	.init_irq = pxa25x_init_irq,
e9dea0c6 RK	732	.init_machine = corgi_init,
e9dea0c6 RK	733	.timer = &pxa_timer,
1da177e4 LT	734	MACHINE_END
	735	#endif
	736
	737	#ifdef CONFIG_MACH_HUSKY
	738	MACHINE_START(HUSKY, "SHARP Husky")
e9dea0c6	739	.phys_io = 0x40000000,
68070bde	740	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
e9dea0c6	741	.fixup = fixup_corgi,
fdce05bb	742	.map_io = pxa_map_io,
cd49104d	743	.init_irq = pxa25x_init_irq,
e9dea0c6 RK	744	.init_machine = corgi_init,
e9dea0c6 RK	745	.timer = &pxa_timer,
1da177e4 LT	746	MACHINE_END
	747	#endif
	748