[linux-block.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 */
	GPIO33_GPIO,	/* CORGI_GPIO_SD_PWR */
	GPIO22_GPIO,	/* CORGI_GPIO_IR_ON */
	GPIO44_GPIO,	/* CORGI_GPIO_HSYNC */

	GPIO1_GPIO | WAKEUP_ON_EDGE_RISE,
};

/*
 * 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 = {
	/* 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));

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