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

/*
 * Support for HTC Magician PDA phones:
 * i-mate JAM, O2 Xda mini, Orange SPV M500, Qtek s100, Qtek s110
 * and T-Mobile MDA Compact.
 *
 * Copyright (c) 2006-2007 Philipp Zabel
 *
 * Based on hx4700.c, spitz.c and others.
 *
 * 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/delay.h>
#include <linux/gpio_keys.h>
#include <linux/input.h>
#include <linux/mfd/htc-egpio.h>
#include <linux/mfd/htc-pasic3.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/physmap.h>
#include <linux/pda_power.h>
#include <linux/pwm_backlight.h>

#include <asm/gpio.h>
#include <asm/hardware.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/arch/magician.h>
#include <asm/arch/mfp-pxa27x.h>
#include <asm/arch/pxa-regs.h>
#include <asm/arch/pxa2xx-regs.h>
#include <asm/arch/pxafb.h>
#include <asm/arch/i2c.h>
#include <asm/arch/mmc.h>
#include <asm/arch/irda.h>
#include <asm/arch/ohci.h>

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

static unsigned long magician_pin_config[] = {

	/* SDRAM and Static Memory I/O Signals */
	GPIO20_nSDCS_2,
	GPIO21_nSDCS_3,
	GPIO15_nCS_1,
	GPIO78_nCS_2,   /* PASIC3 */
	GPIO79_nCS_3,   /* EGPIO CPLD */
	GPIO80_nCS_4,
	GPIO33_nCS_5,

	/* I2C */
	GPIO117_I2C_SCL,
	GPIO118_I2C_SDA,

	/* PWM 0 */
	GPIO16_PWM0_OUT,

	/* I2S */
	GPIO28_I2S_BITCLK_OUT,
	GPIO29_I2S_SDATA_IN,
	GPIO31_I2S_SYNC,
	GPIO113_I2S_SYSCLK,

	/* SSP 2 */
	GPIO19_SSP2_SCLK,
	GPIO14_SSP2_SFRM,
	GPIO89_SSP2_TXD,
	GPIO88_SSP2_RXD,

	/* MMC */
	GPIO32_MMC_CLK,
	GPIO92_MMC_DAT_0,
	GPIO109_MMC_DAT_1,
	GPIO110_MMC_DAT_2,
	GPIO111_MMC_DAT_3,
	GPIO112_MMC_CMD,

	/* LCD */
	GPIO58_LCD_LDD_0,
	GPIO59_LCD_LDD_1,
	GPIO60_LCD_LDD_2,
	GPIO61_LCD_LDD_3,
	GPIO62_LCD_LDD_4,
	GPIO63_LCD_LDD_5,
	GPIO64_LCD_LDD_6,
	GPIO65_LCD_LDD_7,
	GPIO66_LCD_LDD_8,
	GPIO67_LCD_LDD_9,
	GPIO68_LCD_LDD_10,
	GPIO69_LCD_LDD_11,
	GPIO70_LCD_LDD_12,
	GPIO71_LCD_LDD_13,
	GPIO72_LCD_LDD_14,
	GPIO73_LCD_LDD_15,
	GPIO74_LCD_FCLK,
	GPIO75_LCD_LCLK,
	GPIO76_LCD_PCLK,
	GPIO77_LCD_BIAS,

	/* QCI */
	GPIO12_CIF_DD_7,
	GPIO17_CIF_DD_6,
	GPIO50_CIF_DD_3,
	GPIO51_CIF_DD_2,
	GPIO52_CIF_DD_4,
	GPIO53_CIF_MCLK,
	GPIO54_CIF_PCLK,
	GPIO55_CIF_DD_1,
	GPIO81_CIF_DD_0,
	GPIO82_CIF_DD_5,
	GPIO84_CIF_FV,
	GPIO85_CIF_LV,

	/* Magician specific input GPIOs */
	GPIO9_GPIO,	/* unknown */
	GPIO10_GPIO,	/* GSM_IRQ */
	GPIO13_GPIO,	/* CPLD_IRQ */
	GPIO107_GPIO,	/* DS1WM_IRQ */
	GPIO108_GPIO,	/* GSM_READY */
	GPIO115_GPIO,	/* nPEN_IRQ */
};

/*
 * IRDA
 */

static void magician_irda_transceiver_mode(struct device *dev, int mode)
{
	gpio_set_value(GPIO83_MAGICIAN_nIR_EN, mode & IR_OFF);
}

static struct pxaficp_platform_data magician_ficp_info = {
	.transceiver_cap  = IR_SIRMODE | IR_OFF,
	.transceiver_mode = magician_irda_transceiver_mode,
};

/*
 * GPIO Keys
 */

static struct gpio_keys_button magician_button_table[] = {
	{KEY_POWER,      GPIO0_MAGICIAN_KEY_POWER,      0, "Power button"},
	{KEY_ESC,        GPIO37_MAGICIAN_KEY_HANGUP,    0, "Hangup button"},
	{KEY_F10,        GPIO38_MAGICIAN_KEY_CONTACTS,  0, "Contacts button"},
	{KEY_CALENDAR,   GPIO90_MAGICIAN_KEY_CALENDAR,  0, "Calendar button"},
	{KEY_CAMERA,     GPIO91_MAGICIAN_KEY_CAMERA,    0, "Camera button"},
	{KEY_UP,         GPIO93_MAGICIAN_KEY_UP,        0, "Up button"},
	{KEY_DOWN,       GPIO94_MAGICIAN_KEY_DOWN,      0, "Down button"},
	{KEY_LEFT,       GPIO95_MAGICIAN_KEY_LEFT,      0, "Left button"},
	{KEY_RIGHT,      GPIO96_MAGICIAN_KEY_RIGHT,     0, "Right button"},
	{KEY_KPENTER,    GPIO97_MAGICIAN_KEY_ENTER,     0, "Action button"},
	{KEY_RECORD,     GPIO98_MAGICIAN_KEY_RECORD,    0, "Record button"},
	{KEY_VOLUMEUP,   GPIO100_MAGICIAN_KEY_VOL_UP,   0, "Volume up"},
	{KEY_VOLUMEDOWN, GPIO101_MAGICIAN_KEY_VOL_DOWN, 0, "Volume down"},
	{KEY_PHONE,      GPIO102_MAGICIAN_KEY_PHONE,    0, "Phone button"},
	{KEY_PLAY,       GPIO99_MAGICIAN_HEADPHONE_IN,  0, "Headset button"},
};

static struct gpio_keys_platform_data gpio_keys_data = {
	.buttons  = magician_button_table,
	.nbuttons = ARRAY_SIZE(magician_button_table),
};

static struct platform_device gpio_keys = {
	.name = "gpio-keys",
	.dev  = {
		.platform_data = &gpio_keys_data,
	},
	.id   = -1,
};


/*
 * EGPIO (Xilinx CPLD)
 *
 * 7 32-bit aligned 8-bit registers: 3x output, 1x irq, 3x input
 */

static struct resource egpio_resources[] = {
	[0] = {
		.start = PXA_CS3_PHYS,
		.end   = PXA_CS3_PHYS + 0x20,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = gpio_to_irq(GPIO13_MAGICIAN_CPLD_IRQ),
		.end   = gpio_to_irq(GPIO13_MAGICIAN_CPLD_IRQ),
		.flags = IORESOURCE_IRQ,
	},
};

static struct htc_egpio_chip egpio_chips[] = {
	[0] = {
		.reg_start = 0,
		.gpio_base = MAGICIAN_EGPIO(0, 0),
		.num_gpios = 24,
		.direction = HTC_EGPIO_OUTPUT,
		.initial_values = 0x40, /* EGPIO_MAGICIAN_GSM_RESET */
	},
	[1] = {
		.reg_start = 4,
		.gpio_base = MAGICIAN_EGPIO(4, 0),
		.num_gpios = 24,
		.direction = HTC_EGPIO_INPUT,
	},
};

static struct htc_egpio_platform_data egpio_info = {
	.reg_width    = 8,
	.bus_width    = 32,
	.irq_base     = IRQ_BOARD_START,
	.num_irqs     = 4,
	.ack_register = 3,
	.chip         = egpio_chips,
	.num_chips    = ARRAY_SIZE(egpio_chips),
};

static struct platform_device egpio = {
	.name          = "htc-egpio",
	.id            = -1,
	.resource      = egpio_resources,
	.num_resources = ARRAY_SIZE(egpio_resources),
	.dev = {
		.platform_data = &egpio_info,
	},
};

/*
 * LCD - Toppoly TD028STEB1 or Samsung LTP280QV
 */

static struct pxafb_mode_info toppoly_modes[] = {
	{
		.pixclock     = 96153,
		.bpp          = 16,
		.xres         = 240,
		.yres         = 320,
		.hsync_len    = 11,
		.vsync_len    = 3,
		.left_margin  = 19,
		.upper_margin = 2,
		.right_margin = 10,
		.lower_margin = 2,
		.sync         = 0,
	},
};

static struct pxafb_mode_info samsung_modes[] = {
	{
		.pixclock     = 96153,
		.bpp          = 16,
		.xres         = 240,
		.yres         = 320,
		.hsync_len    = 8,
		.vsync_len    = 4,
		.left_margin  = 9,
		.upper_margin = 4,
		.right_margin = 9,
		.lower_margin = 4,
		.sync         = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
	},
};

static void toppoly_lcd_power(int on, struct fb_var_screeninfo *si)
{
	pr_debug("Toppoly LCD power\n");

	if (on) {
		pr_debug("on\n");
		gpio_set_value(EGPIO_MAGICIAN_TOPPOLY_POWER, 1);
		gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 1);
		udelay(2000);
		gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 1);
		udelay(2000);
		/* FIXME: enable LCDC here */
		udelay(2000);
		gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 1);
		udelay(2000);
		gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 1);
	} else {
		pr_debug("off\n");
		msleep(15);
		gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 0);
		udelay(500);
		gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 0);
		udelay(1000);
		gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 0);
		gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 0);
	}
}

static void samsung_lcd_power(int on, struct fb_var_screeninfo *si)
{
	pr_debug("Samsung LCD power\n");

	if (on) {
		pr_debug("on\n");
		if (system_rev < 3)
			gpio_set_value(GPIO75_MAGICIAN_SAMSUNG_POWER, 1);
		else
			gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 1);
		mdelay(10);
		gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 1);
		mdelay(10);
		gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 1);
		mdelay(30);
		gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 1);
		mdelay(10);
	} else {
		pr_debug("off\n");
		mdelay(10);
		gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 0);
		mdelay(30);
		gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 0);
		mdelay(10);
		gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 0);
		mdelay(10);
		if (system_rev < 3)
			gpio_set_value(GPIO75_MAGICIAN_SAMSUNG_POWER, 0);
		else
			gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 0);
	}
}

static struct pxafb_mach_info toppoly_info = {
	.modes           = toppoly_modes,
	.num_modes       = 1,
	.fixed_modes     = 1,
	.lccr0           = LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
	.lccr3           = LCCR3_PixRsEdg,
	.pxafb_lcd_power = toppoly_lcd_power,
};

static struct pxafb_mach_info samsung_info = {
	.modes           = samsung_modes,
	.num_modes       = 1,
	.fixed_modes     = 1,
	.lccr0           = LCCR0_LDDALT | LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
	.lccr3           = LCCR3_PixFlEdg,
	.pxafb_lcd_power = samsung_lcd_power,
};

/*
 * Backlight
 */

static int magician_backlight_init(struct device *dev)
{
	int ret;

	ret = gpio_request(EGPIO_MAGICIAN_BL_POWER, "BL_POWER");
	if (ret)
		goto err;
	ret = gpio_request(EGPIO_MAGICIAN_BL_POWER2, "BL_POWER2");
	if (ret)
		goto err2;
	return 0;

err2:
	gpio_free(EGPIO_MAGICIAN_BL_POWER);
err:
	return ret;
}

static int magician_backlight_notify(int brightness)
{
	gpio_set_value(EGPIO_MAGICIAN_BL_POWER, brightness);
	if (brightness >= 200) {
		gpio_set_value(EGPIO_MAGICIAN_BL_POWER2, 1);
		return brightness - 72;
	} else {
		gpio_set_value(EGPIO_MAGICIAN_BL_POWER2, 0);
		return brightness;
	}
}

static void magician_backlight_exit(struct device *dev)
{
	gpio_free(EGPIO_MAGICIAN_BL_POWER);
	gpio_free(EGPIO_MAGICIAN_BL_POWER2);
}

static struct platform_pwm_backlight_data backlight_data = {
	.pwm_id         = 0,
	.max_brightness = 272,
	.dft_brightness = 100,
	.pwm_period_ns  = 30923,
	.init           = magician_backlight_init,
	.notify         = magician_backlight_notify,
	.exit           = magician_backlight_exit,
};

static struct platform_device backlight = {
	.name = "pwm-backlight",
	.dev  = {
		.parent        = &pxa27x_device_pwm0.dev,
		.platform_data = &backlight_data,
	},
};

/*
 * LEDs
 */

struct gpio_led gpio_leds[] = {
	{
		.name = "magician::vibra",
		.default_trigger = "none",
		.gpio = GPIO22_MAGICIAN_VIBRA_EN,
	},
	{
		.name = "magician::phone_bl",
		.default_trigger = "none",
		.gpio = GPIO103_MAGICIAN_LED_KP,
	},
};

static struct gpio_led_platform_data gpio_led_info = {
	.leds = gpio_leds,
	.num_leds = ARRAY_SIZE(gpio_leds),
};

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

static struct pasic3_led pasic3_leds[] = {
	{
		.led = {
			.name            = "magician:red",
			.default_trigger = "ds2760-battery.0-charging",
		},
		.hw_num = 0,
		.bit2   = PASIC3_BIT2_LED0,
		.mask   = PASIC3_MASK_LED0,
	},
	{
		.led = {
			.name            = "magician:green",
			.default_trigger = "ds2760-battery.0-charging-or-full",
		},
		.hw_num = 1,
		.bit2   = PASIC3_BIT2_LED1,
		.mask   = PASIC3_MASK_LED1,
	},
	{
		.led = {
			.name            = "magician:blue",
			.default_trigger = "bluetooth",
		},
		.hw_num = 2,
		.bit2   = PASIC3_BIT2_LED2,
		.mask   = PASIC3_MASK_LED2,
	},
};

static struct platform_device pasic3;

static struct pasic3_leds_machinfo pasic3_leds_info = {
	.num_leds   = ARRAY_SIZE(pasic3_leds),
	.power_gpio = EGPIO_MAGICIAN_LED_POWER,
	.leds       = pasic3_leds,
};

/*
 * PASIC3 with DS1WM
 */

static struct resource pasic3_resources[] = {
	[0] = {
		.start  = PXA_CS2_PHYS,
		.end	= PXA_CS2_PHYS + 0x1b,
		.flags  = IORESOURCE_MEM,
	},
	/* No IRQ handler in the PASIC3, DS1WM needs an external IRQ */
	[1] = {
		.start  = gpio_to_irq(GPIO107_MAGICIAN_DS1WM_IRQ),
		.end    = gpio_to_irq(GPIO107_MAGICIAN_DS1WM_IRQ),
		.flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
	}
};

static struct pasic3_platform_data pasic3_platform_data = {
	.bus_shift  = 2,
	.led_pdata  = &pasic3_leds_info,
	.clock_rate = 4000000,
};

static struct platform_device pasic3 = {
	.name		= "pasic3",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(pasic3_resources),
	.resource	= pasic3_resources,
	.dev = {
		.platform_data = &pasic3_platform_data,
	},
};

/*
 * External power
 */

static int magician_is_ac_online(void)
{
	return gpio_get_value(EGPIO_MAGICIAN_CABLE_STATE_AC);
}

static int magician_is_usb_online(void)
{
	return gpio_get_value(EGPIO_MAGICIAN_CABLE_STATE_USB);
}

static void magician_set_charge(int flags)
{
	gpio_set_value(GPIO30_MAGICIAN_nCHARGE_EN, !flags);
	gpio_set_value(EGPIO_MAGICIAN_CHARGE_EN, flags);
}

static char *magician_supplicants[] = {
	"ds2760-battery.0", "backup-battery"
};

static struct pda_power_pdata power_supply_info = {
	.is_ac_online    = magician_is_ac_online,
	.is_usb_online   = magician_is_usb_online,
	.set_charge      = magician_set_charge,
	.supplied_to     = magician_supplicants,
	.num_supplicants = ARRAY_SIZE(magician_supplicants),
};

static struct resource power_supply_resources[] = {
	[0] = {
		.name  = "ac",
		.flags = IORESOURCE_IRQ,
		.start = IRQ_MAGICIAN_AC,
		.end   = IRQ_MAGICIAN_AC,
	},
	[1] = {
		.name  = "usb",
		.flags = IORESOURCE_IRQ,
		.start = IRQ_MAGICIAN_AC,
		.end   = IRQ_MAGICIAN_AC,
	},
};

static struct platform_device power_supply = {
	.name = "pda-power",
	.id   = -1,
	.dev  = {
		.platform_data = &power_supply_info,
	},
	.resource      = power_supply_resources,
	.num_resources = ARRAY_SIZE(power_supply_resources),
};


/*
 * MMC/SD
 */

static int magician_mci_init(struct device *dev,
				irq_handler_t detect_irq, void *data)
{
	int err;

	err = request_irq(IRQ_MAGICIAN_SD, detect_irq,
				IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
				"MMC card detect", data);
	if (err)
		goto err_request_irq;
	err = gpio_request(EGPIO_MAGICIAN_SD_POWER, "SD_POWER");
	if (err)
		goto err_request_power;
	err = gpio_request(EGPIO_MAGICIAN_nSD_READONLY, "nSD_READONLY");
	if (err)
		goto err_request_readonly;

	return 0;

err_request_readonly:
	gpio_free(EGPIO_MAGICIAN_SD_POWER);
err_request_power:
	free_irq(IRQ_MAGICIAN_SD, data);
err_request_irq:
	return err;
}

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

	gpio_set_value(EGPIO_MAGICIAN_SD_POWER, (1 << vdd) & pdata->ocr_mask);
}

static int magician_mci_get_ro(struct device *dev)
{
	return (!gpio_get_value(EGPIO_MAGICIAN_nSD_READONLY));
}

static void magician_mci_exit(struct device *dev, void *data)
{
	gpio_free(EGPIO_MAGICIAN_nSD_READONLY);
	gpio_free(EGPIO_MAGICIAN_SD_POWER);
	free_irq(IRQ_MAGICIAN_SD, data);
}

static struct pxamci_platform_data magician_mci_info = {
	.ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34,
	.init     = magician_mci_init,
	.get_ro   = magician_mci_get_ro,
	.setpower = magician_mci_setpower,
	.exit     = magician_mci_exit,
};


/*
 * USB OHCI
 */

static int magician_ohci_init(struct device *dev)
{
	UHCHR = (UHCHR | UHCHR_SSEP2 | UHCHR_PCPL | UHCHR_CGR) &
	    ~(UHCHR_SSEP1 | UHCHR_SSEP3 | UHCHR_SSE);

	return 0;
}

static struct pxaohci_platform_data magician_ohci_info = {
	.port_mode    = PMM_PERPORT_MODE,
	.init         = magician_ohci_init,
	.power_budget = 0,
};


/*
 * StrataFlash
 */

static void magician_set_vpp(struct map_info *map, int vpp)
{
	gpio_set_value(EGPIO_MAGICIAN_FLASH_VPP, vpp);
}

#define PXA_CS_SIZE		0x04000000

static struct resource strataflash_resource = {
	.start = PXA_CS0_PHYS,
	.end   = PXA_CS0_PHYS + PXA_CS_SIZE - 1,
	.flags = IORESOURCE_MEM,
};

static struct physmap_flash_data strataflash_data = {
	.width = 4,
	.set_vpp = magician_set_vpp,
};

static struct platform_device strataflash = {
	.name          = "physmap-flash",
	.id            = -1,
	.resource      = &strataflash_resource,
	.num_resources = 1,
	.dev = {
		.platform_data = &strataflash_data,
	},
};

/*
 * Platform devices
 */

static struct platform_device *devices[] __initdata = {
	&gpio_keys,
	&egpio,
	&backlight,
	&pasic3,
	&power_supply,
	&strataflash,
	&leds_gpio,
};

static void __init magician_init(void)
{
	void __iomem *cpld;
	int lcd_select;
	int err;

	gpio_request(GPIO13_MAGICIAN_CPLD_IRQ, "CPLD_IRQ");
	gpio_request(GPIO107_MAGICIAN_DS1WM_IRQ, "DS1WM_IRQ");

	pxa2xx_mfp_config(ARRAY_AND_SIZE(magician_pin_config));

	platform_add_devices(devices, ARRAY_SIZE(devices));

	err = gpio_request(GPIO83_MAGICIAN_nIR_EN, "nIR_EN");
	if (!err) {
		gpio_direction_output(GPIO83_MAGICIAN_nIR_EN, 1);
		pxa_set_ficp_info(&magician_ficp_info);
	}
	pxa_set_i2c_info(NULL);
	pxa_set_mci_info(&magician_mci_info);
	pxa_set_ohci_info(&magician_ohci_info);

	/* Check LCD type we have */
	cpld = ioremap_nocache(PXA_CS3_PHYS, 0x1000);
	if (cpld) {
		u8 board_id = __raw_readb(cpld+0x14);
		iounmap(cpld);
		system_rev = board_id & 0x7;
		lcd_select = board_id & 0x8;
		pr_info("LCD type: %s\n", lcd_select ? "Samsung" : "Toppoly");
		if (lcd_select && (system_rev < 3)) {
			gpio_request(GPIO75_MAGICIAN_SAMSUNG_POWER, "SAMSUNG_POWER");
			gpio_direction_output(GPIO75_MAGICIAN_SAMSUNG_POWER, 0);
		}
		gpio_request(GPIO104_MAGICIAN_LCD_POWER_1, "LCD_POWER_1");
		gpio_request(GPIO105_MAGICIAN_LCD_POWER_2, "LCD_POWER_2");
		gpio_request(GPIO106_MAGICIAN_LCD_POWER_3, "LCD_POWER_3");
		gpio_direction_output(GPIO104_MAGICIAN_LCD_POWER_1, 0);
		gpio_direction_output(GPIO105_MAGICIAN_LCD_POWER_2, 0);
		gpio_direction_output(GPIO106_MAGICIAN_LCD_POWER_3, 0);
		set_pxa_fb_info(lcd_select ? &samsung_info : &toppoly_info);
	} else
		pr_err("LCD detection: CPLD mapping failed\n");
}


MACHINE_START(MAGICIAN, "HTC Magician")
	.phys_io = 0x40000000,
	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
	.boot_params = 0xa0000100,
	.map_io = pxa_map_io,
	.init_irq = pxa27x_init_irq,
	.init_machine = magician_init,
	.timer = &pxa_timer,
MACHINE_END
Commit	Line	Data
e5c271ec PZ	1	/*
	2	* Support for HTC Magician PDA phones:
	3	* i-mate JAM, O2 Xda mini, Orange SPV M500, Qtek s100, Qtek s110
	4	* and T-Mobile MDA Compact.
	5	*
	6	* Copyright (c) 2006-2007 Philipp Zabel
	7	*
	8	* Based on hx4700.c, spitz.c and others.
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/init.h>
	18	#include <linux/platform_device.h>
e07ff8d8	19	#include <linux/delay.h>
e5c271ec PZ	20	#include <linux/gpio_keys.h>
e5c271ec PZ	21	#include <linux/input.h>
70e357f8	22	#include <linux/mfd/htc-egpio.h>
81447b2e	23	#include <linux/mfd/htc-pasic3.h>
e5c271ec PZ	24	#include <linux/mtd/mtd.h>
	25	#include <linux/mtd/map.h>
	26	#include <linux/mtd/physmap.h>
350d115d	27	#include <linux/pda_power.h>
85847a36	28	#include <linux/pwm_backlight.h>
e5c271ec PZ	29
	30	#include <asm/gpio.h>
	31	#include <asm/hardware.h>
	32	#include <asm/mach-types.h>
	33	#include <asm/mach/arch.h>
	34	#include <asm/arch/magician.h>
b168281c	35	#include <asm/arch/mfp-pxa27x.h>
e5c271ec	36	#include <asm/arch/pxa-regs.h>
0b0a9df6	37	#include <asm/arch/pxa2xx-regs.h>
e5c271ec	38	#include <asm/arch/pxafb.h>
e6816f34	39	#include <asm/arch/i2c.h>
bdb0c16a	40	#include <asm/arch/mmc.h>
e5c271ec PZ	41	#include <asm/arch/irda.h>
	42	#include <asm/arch/ohci.h>
	43
85847a36	44	#include "devices.h"
e5c271ec PZ	45	#include "generic.h"
e5c271ec PZ	46
b168281c PZ	47	static unsigned long magician_pin_config[] = {
	48
	49	/* SDRAM and Static Memory I/O Signals */
	50	GPIO20_nSDCS_2,
	51	GPIO21_nSDCS_3,
	52	GPIO15_nCS_1,
	53	GPIO78_nCS_2, /* PASIC3 */
	54	GPIO79_nCS_3, /* EGPIO CPLD */
	55	GPIO80_nCS_4,
	56	GPIO33_nCS_5,
	57
	58	/* I2C */
	59	GPIO117_I2C_SCL,
	60	GPIO118_I2C_SDA,
	61
	62	/* PWM 0 */
	63	GPIO16_PWM0_OUT,
	64
	65	/* I2S */
	66	GPIO28_I2S_BITCLK_OUT,
	67	GPIO29_I2S_SDATA_IN,
	68	GPIO31_I2S_SYNC,
	69	GPIO113_I2S_SYSCLK,
	70
	71	/* SSP 2 */
	72	GPIO19_SSP2_SCLK,
	73	GPIO14_SSP2_SFRM,
	74	GPIO89_SSP2_TXD,
	75	GPIO88_SSP2_RXD,
	76
	77	/* MMC */
	78	GPIO32_MMC_CLK,
	79	GPIO92_MMC_DAT_0,
	80	GPIO109_MMC_DAT_1,
	81	GPIO110_MMC_DAT_2,
	82	GPIO111_MMC_DAT_3,
	83	GPIO112_MMC_CMD,
	84
	85	/* LCD */
	86	GPIO58_LCD_LDD_0,
	87	GPIO59_LCD_LDD_1,
	88	GPIO60_LCD_LDD_2,
	89	GPIO61_LCD_LDD_3,
	90	GPIO62_LCD_LDD_4,
	91	GPIO63_LCD_LDD_5,
	92	GPIO64_LCD_LDD_6,
	93	GPIO65_LCD_LDD_7,
	94	GPIO66_LCD_LDD_8,
	95	GPIO67_LCD_LDD_9,
	96	GPIO68_LCD_LDD_10,
	97	GPIO69_LCD_LDD_11,
	98	GPIO70_LCD_LDD_12,
	99	GPIO71_LCD_LDD_13,
	100	GPIO72_LCD_LDD_14,
	101	GPIO73_LCD_LDD_15,
	102	GPIO74_LCD_FCLK,
	103	GPIO75_LCD_LCLK,
	104	GPIO76_LCD_PCLK,
	105	GPIO77_LCD_BIAS,
	106
	107	/* QCI */
	108	GPIO12_CIF_DD_7,
	109	GPIO17_CIF_DD_6,
	110	GPIO50_CIF_DD_3,
111	GPIO51_CIF_DD_2,
112	GPIO52_CIF_DD_4,
113	GPIO53_CIF_MCLK,
114	GPIO54_CIF_PCLK,
115	GPIO55_CIF_DD_1,
116	GPIO81_CIF_DD_0,
117	GPIO82_CIF_DD_5,
118	GPIO84_CIF_FV,
119	GPIO85_CIF_LV,
2f131958 PZ	120
	121	/* Magician specific input GPIOs */
	122	GPIO9_GPIO, /* unknown */
	123	GPIO10_GPIO, /* GSM_IRQ */
	124	GPIO13_GPIO, /* CPLD_IRQ */
	125	GPIO107_GPIO, /* DS1WM_IRQ */
	126	GPIO108_GPIO, /* GSM_READY */
	127	GPIO115_GPIO, /* nPEN_IRQ */
b168281c PZ	128	};
b168281c PZ	129
e5c271ec PZ	130	/*
	131	* IRDA
	132	*/
	133
	134	static void magician_irda_transceiver_mode(struct device *dev, int mode)
	135	{
	136	gpio_set_value(GPIO83_MAGICIAN_nIR_EN, mode & IR_OFF);
	137	}
	138
	139	static struct pxaficp_platform_data magician_ficp_info = {
	140	.transceiver_cap = IR_SIRMODE \| IR_OFF,
	141	.transceiver_mode = magician_irda_transceiver_mode,
	142	};
	143
	144	/*
	145	* GPIO Keys
	146	*/
	147
	148	static struct gpio_keys_button magician_button_table[] = {
	149	{KEY_POWER, GPIO0_MAGICIAN_KEY_POWER, 0, "Power button"},
	150	{KEY_ESC, GPIO37_MAGICIAN_KEY_HANGUP, 0, "Hangup button"},
	151	{KEY_F10, GPIO38_MAGICIAN_KEY_CONTACTS, 0, "Contacts button"},
	152	{KEY_CALENDAR, GPIO90_MAGICIAN_KEY_CALENDAR, 0, "Calendar button"},
	153	{KEY_CAMERA, GPIO91_MAGICIAN_KEY_CAMERA, 0, "Camera button"},
	154	{KEY_UP, GPIO93_MAGICIAN_KEY_UP, 0, "Up button"},
	155	{KEY_DOWN, GPIO94_MAGICIAN_KEY_DOWN, 0, "Down button"},
	156	{KEY_LEFT, GPIO95_MAGICIAN_KEY_LEFT, 0, "Left button"},
	157	{KEY_RIGHT, GPIO96_MAGICIAN_KEY_RIGHT, 0, "Right button"},
	158	{KEY_KPENTER, GPIO97_MAGICIAN_KEY_ENTER, 0, "Action button"},
	159	{KEY_RECORD, GPIO98_MAGICIAN_KEY_RECORD, 0, "Record button"},
	160	{KEY_VOLUMEUP, GPIO100_MAGICIAN_KEY_VOL_UP, 0, "Volume up"},
	161	{KEY_VOLUMEDOWN, GPIO101_MAGICIAN_KEY_VOL_DOWN, 0, "Volume down"},
	162	{KEY_PHONE, GPIO102_MAGICIAN_KEY_PHONE, 0, "Phone button"},
	163	{KEY_PLAY, GPIO99_MAGICIAN_HEADPHONE_IN, 0, "Headset button"},
	164	};
	165
	166	static struct gpio_keys_platform_data gpio_keys_data = {
	167	.buttons = magician_button_table,
	168	.nbuttons = ARRAY_SIZE(magician_button_table),
	169	};
	170
	171	static struct platform_device gpio_keys = {
	172	.name = "gpio-keys",
	173	.dev = {
	174	.platform_data = &gpio_keys_data,
	175	},
	176	.id = -1,
	177	};
	178
70e357f8 PZ	179
	180	/*
	181	* EGPIO (Xilinx CPLD)
	182	*
	183	* 7 32-bit aligned 8-bit registers: 3x output, 1x irq, 3x input
	184	*/
	185
	186	static struct resource egpio_resources[] = {
	187	[0] = {
	188	.start = PXA_CS3_PHYS,
	189	.end = PXA_CS3_PHYS + 0x20,
	190	.flags = IORESOURCE_MEM,
	191	},
	192	[1] = {
	193	.start = gpio_to_irq(GPIO13_MAGICIAN_CPLD_IRQ),
	194	.end = gpio_to_irq(GPIO13_MAGICIAN_CPLD_IRQ),
	195	.flags = IORESOURCE_IRQ,
	196	},
	197	};
	198
	199	static struct htc_egpio_chip egpio_chips[] = {
	200	[0] = {
	201	.reg_start = 0,
	202	.gpio_base = MAGICIAN_EGPIO(0, 0),
	203	.num_gpios = 24,
	204	.direction = HTC_EGPIO_OUTPUT,
	205	.initial_values = 0x40, /* EGPIO_MAGICIAN_GSM_RESET */
	206	},
	207	[1] = {
	208	.reg_start = 4,
	209	.gpio_base = MAGICIAN_EGPIO(4, 0),
	210	.num_gpios = 24,
	211	.direction = HTC_EGPIO_INPUT,
	212	},
	213	};
	214
	215	static struct htc_egpio_platform_data egpio_info = {
	216	.reg_width = 8,
	217	.bus_width = 32,
	218	.irq_base = IRQ_BOARD_START,
	219	.num_irqs = 4,
	220	.ack_register = 3,
	221	.chip = egpio_chips,
	222	.num_chips = ARRAY_SIZE(egpio_chips),
	223	};
	224
	225	static struct platform_device egpio = {
	226	.name = "htc-egpio",
	227	.id = -1,
	228	.resource = egpio_resources,
	229	.num_resources = ARRAY_SIZE(egpio_resources),
	230	.dev = {
	231	.platform_data = &egpio_info,
	232	},
	233	};
	234
e5c271ec	235	/*
e07ff8d8	236	* LCD - Toppoly TD028STEB1 or Samsung LTP280QV
e5c271ec PZ	237	*/
	238
	239	static struct pxafb_mode_info toppoly_modes[] = {
	240	{
	241	.pixclock = 96153,
	242	.bpp = 16,
	243	.xres = 240,
	244	.yres = 320,
	245	.hsync_len = 11,
	246	.vsync_len = 3,
	247	.left_margin = 19,
	248	.upper_margin = 2,
	249	.right_margin = 10,
	250	.lower_margin = 2,
	251	.sync = 0,
	252	},
	253	};
	254
e07ff8d8 PZ	255	static struct pxafb_mode_info samsung_modes[] = {
	256	{
	257	.pixclock = 96153,
	258	.bpp = 16,
	259	.xres = 240,
	260	.yres = 320,
	261	.hsync_len = 8,
	262	.vsync_len = 4,
	263	.left_margin = 9,
	264	.upper_margin = 4,
	265	.right_margin = 9,
	266	.lower_margin = 4,
	267	.sync = FB_SYNC_HOR_HIGH_ACT \| FB_SYNC_VERT_HIGH_ACT,
	268	},
	269	};
	270
	271	static void toppoly_lcd_power(int on, struct fb_var_screeninfo *si)
	272	{
	273	pr_debug("Toppoly LCD power\n");
	274
	275	if (on) {
	276	pr_debug("on\n");
	277	gpio_set_value(EGPIO_MAGICIAN_TOPPOLY_POWER, 1);
	278	gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 1);
	279	udelay(2000);
	280	gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 1);
	281	udelay(2000);
	282	/* FIXME: enable LCDC here */
	283	udelay(2000);
	284	gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 1);
	285	udelay(2000);
	286	gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 1);
	287	} else {
	288	pr_debug("off\n");
	289	msleep(15);
	290	gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 0);
	291	udelay(500);
	292	gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 0);
	293	udelay(1000);
	294	gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 0);
	295	gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 0);
	296	}
	297	}
	298
	299	static void samsung_lcd_power(int on, struct fb_var_screeninfo *si)
	300	{
	301	pr_debug("Samsung LCD power\n");
	302
	303	if (on) {
	304	pr_debug("on\n");
	305	if (system_rev < 3)
	306	gpio_set_value(GPIO75_MAGICIAN_SAMSUNG_POWER, 1);
	307	else
	308	gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 1);
	309	mdelay(10);
	310	gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 1);
	311	mdelay(10);
	312	gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 1);
	313	mdelay(30);
	314	gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 1);
	315	mdelay(10);
	316	} else {
	317	pr_debug("off\n");
	318	mdelay(10);
319	gpio_set_value(GPIO105_MAGICIAN_LCD_POWER_2, 0);
320	mdelay(30);
321	gpio_set_value(GPIO104_MAGICIAN_LCD_POWER_1, 0);
322	mdelay(10);
323	gpio_set_value(GPIO106_MAGICIAN_LCD_POWER_3, 0);
324	mdelay(10);
325	if (system_rev < 3)
326	gpio_set_value(GPIO75_MAGICIAN_SAMSUNG_POWER, 0);
327	else
328	gpio_set_value(EGPIO_MAGICIAN_LCD_POWER, 0);
329	}
330	}
331
e5c271ec	332	static struct pxafb_mach_info toppoly_info = {
e07ff8d8 PZ	333	.modes = toppoly_modes,
	334	.num_modes = 1,
	335	.fixed_modes = 1,
	336	.lccr0 = LCCR0_Color \| LCCR0_Sngl \| LCCR0_Act,
	337	.lccr3 = LCCR3_PixRsEdg,
	338	.pxafb_lcd_power = toppoly_lcd_power,
	339	};
	340
	341	static struct pxafb_mach_info samsung_info = {
	342	.modes = samsung_modes,
	343	.num_modes = 1,
	344	.fixed_modes = 1,
	345	.lccr0 = LCCR0_LDDALT \| LCCR0_Color \| LCCR0_Sngl \| LCCR0_Act,
	346	.lccr3 = LCCR3_PixFlEdg,
	347	.pxafb_lcd_power = samsung_lcd_power,
e5c271ec PZ	348	};
	349
	350	/*
	351	* Backlight
	352	*/
	353
85847a36	354	static int magician_backlight_init(struct device *dev)
e5c271ec	355	{
85847a36 PZ	356	int ret;
	357
	358	ret = gpio_request(EGPIO_MAGICIAN_BL_POWER, "BL_POWER");
	359	if (ret)
	360	goto err;
	361	ret = gpio_request(EGPIO_MAGICIAN_BL_POWER2, "BL_POWER2");
	362	if (ret)
	363	goto err2;
	364	return 0;
	365
	366	err2:
	367	gpio_free(EGPIO_MAGICIAN_BL_POWER);
	368	err:
	369	return ret;
	370	}
	371
	372	static int magician_backlight_notify(int brightness)
	373	{
	374	gpio_set_value(EGPIO_MAGICIAN_BL_POWER, brightness);
	375	if (brightness >= 200) {
	376	gpio_set_value(EGPIO_MAGICIAN_BL_POWER2, 1);
	377	return brightness - 72;
e5c271ec	378	} else {
85847a36 PZ	379	gpio_set_value(EGPIO_MAGICIAN_BL_POWER2, 0);
85847a36 PZ	380	return brightness;
e5c271ec PZ	381	}
	382	}
	383
85847a36 PZ	384	static void magician_backlight_exit(struct device *dev)
	385	{
	386	gpio_free(EGPIO_MAGICIAN_BL_POWER);
	387	gpio_free(EGPIO_MAGICIAN_BL_POWER2);
	388	}
	389
	390	static struct platform_pwm_backlight_data backlight_data = {
	391	.pwm_id = 0,
	392	.max_brightness = 272,
	393	.dft_brightness = 100,
	394	.pwm_period_ns = 30923,
	395	.init = magician_backlight_init,
	396	.notify = magician_backlight_notify,
	397	.exit = magician_backlight_exit,
e5c271ec PZ	398	};
	399
	400	static struct platform_device backlight = {
85847a36	401	.name = "pwm-backlight",
e5c271ec	402	.dev = {
85847a36 PZ	403	.parent = &pxa27x_device_pwm0.dev,
85847a36 PZ	404	.platform_data = &backlight_data,
e5c271ec	405	},
e5c271ec PZ	406	};
e5c271ec PZ	407
81447b2e PZ	408	/*
	409	* LEDs
	410	*/
	411
	412	struct gpio_led gpio_leds[] = {
	413	{
	414	.name = "magician::vibra",
	415	.default_trigger = "none",
	416	.gpio = GPIO22_MAGICIAN_VIBRA_EN,
	417	},
	418	{
	419	.name = "magician::phone_bl",
	420	.default_trigger = "none",
	421	.gpio = GPIO103_MAGICIAN_LED_KP,
	422	},
	423	};
	424
	425	static struct gpio_led_platform_data gpio_led_info = {
	426	.leds = gpio_leds,
	427	.num_leds = ARRAY_SIZE(gpio_leds),
	428	};
	429
	430	static struct platform_device leds_gpio = {
	431	.name = "leds-gpio",
	432	.id = -1,
	433	.dev = {
	434	.platform_data = &gpio_led_info,
	435	},
	436	};
	437
	438	static struct pasic3_led pasic3_leds[] = {
	439	{
	440	.led = {
	441	.name = "magician:red",
	442	.default_trigger = "ds2760-battery.0-charging",
	443	},
	444	.hw_num = 0,
	445	.bit2 = PASIC3_BIT2_LED0,
	446	.mask = PASIC3_MASK_LED0,
	447	},
	448	{
	449	.led = {
	450	.name = "magician:green",
	451	.default_trigger = "ds2760-battery.0-charging-or-full",
	452	},
	453	.hw_num = 1,
	454	.bit2 = PASIC3_BIT2_LED1,
	455	.mask = PASIC3_MASK_LED1,
	456	},
	457	{
	458	.led = {
	459	.name = "magician:blue",
	460	.default_trigger = "bluetooth",
	461	},
	462	.hw_num = 2,
	463	.bit2 = PASIC3_BIT2_LED2,
	464	.mask = PASIC3_MASK_LED2,
	465	},
	466	};
	467
	468	static struct platform_device pasic3;
	469
e03e0590	470	static struct pasic3_leds_machinfo pasic3_leds_info = {
81447b2e PZ	471	.num_leds = ARRAY_SIZE(pasic3_leds),
	472	.power_gpio = EGPIO_MAGICIAN_LED_POWER,
	473	.leds = pasic3_leds,
	474	};
	475
	476	/*
	477	* PASIC3 with DS1WM
	478	*/
	479
	480	static struct resource pasic3_resources[] = {
	481	[0] = {
	482	.start = PXA_CS2_PHYS,
	483	.end = PXA_CS2_PHYS + 0x1b,
	484	.flags = IORESOURCE_MEM,
	485	},
	486	/* No IRQ handler in the PASIC3, DS1WM needs an external IRQ */
	487	[1] = {
	488	.start = gpio_to_irq(GPIO107_MAGICIAN_DS1WM_IRQ),
	489	.end = gpio_to_irq(GPIO107_MAGICIAN_DS1WM_IRQ),
	490	.flags = IORESOURCE_IRQ \| IORESOURCE_IRQ_HIGHEDGE,
	491	}
	492	};
	493
	494	static struct pasic3_platform_data pasic3_platform_data = {
	495	.bus_shift = 2,
	496	.led_pdata = &pasic3_leds_info,
	497	.clock_rate = 4000000,
	498	};
	499
	500	static struct platform_device pasic3 = {
	501	.name = "pasic3",
	502	.id = -1,
	503	.num_resources = ARRAY_SIZE(pasic3_resources),
	504	.resource = pasic3_resources,
	505	.dev = {
	506	.platform_data = &pasic3_platform_data,
	507	},
	508	};
e5c271ec	509
350d115d PZ	510	/*
	511	* External power
	512	*/
	513
	514	static int magician_is_ac_online(void)
	515	{
	516	return gpio_get_value(EGPIO_MAGICIAN_CABLE_STATE_AC);
	517	}
	518
	519	static int magician_is_usb_online(void)
	520	{
	521	return gpio_get_value(EGPIO_MAGICIAN_CABLE_STATE_USB);
	522	}
	523
	524	static void magician_set_charge(int flags)
	525	{
	526	gpio_set_value(GPIO30_MAGICIAN_nCHARGE_EN, !flags);
	527	gpio_set_value(EGPIO_MAGICIAN_CHARGE_EN, flags);
	528	}
	529
81447b2e PZ	530	static char *magician_supplicants[] = {
	531	"ds2760-battery.0", "backup-battery"
	532	};
	533
350d115d	534	static struct pda_power_pdata power_supply_info = {
81447b2e PZ	535	.is_ac_online = magician_is_ac_online,
	536	.is_usb_online = magician_is_usb_online,
	537	.set_charge = magician_set_charge,
	538	.supplied_to = magician_supplicants,
	539	.num_supplicants = ARRAY_SIZE(magician_supplicants),
350d115d PZ	540	};
	541
	542	static struct resource power_supply_resources[] = {
	543	[0] = {
	544	.name = "ac",
	545	.flags = IORESOURCE_IRQ,
	546	.start = IRQ_MAGICIAN_AC,
	547	.end = IRQ_MAGICIAN_AC,
	548	},
	549	[1] = {
	550	.name = "usb",
	551	.flags = IORESOURCE_IRQ,
	552	.start = IRQ_MAGICIAN_AC,
	553	.end = IRQ_MAGICIAN_AC,
	554	},
	555	};
	556
	557	static struct platform_device power_supply = {
	558	.name = "pda-power",
	559	.id = -1,
	560	.dev = {
	561	.platform_data = &power_supply_info,
	562	},
	563	.resource = power_supply_resources,
	564	.num_resources = ARRAY_SIZE(power_supply_resources),
	565	};
	566
	567
bdb0c16a PZ	568	/*
	569	* MMC/SD
	570	*/
	571
	572	static int magician_mci_init(struct device *dev,
	573	irq_handler_t detect_irq, void *data)
	574	{
a1999cd1 PZ	575	int err;
	576
	577	err = request_irq(IRQ_MAGICIAN_SD, detect_irq,
bdb0c16a PZ	578	IRQF_DISABLED \| IRQF_SAMPLE_RANDOM,
bdb0c16a PZ	579	"MMC card detect", data);
a1999cd1 PZ	580	if (err)
	581	goto err_request_irq;
	582	err = gpio_request(EGPIO_MAGICIAN_SD_POWER, "SD_POWER");
	583	if (err)
	584	goto err_request_power;
	585	err = gpio_request(EGPIO_MAGICIAN_nSD_READONLY, "nSD_READONLY");
	586	if (err)
	587	goto err_request_readonly;
	588
	589	return 0;
	590
	591	err_request_readonly:
	592	gpio_free(EGPIO_MAGICIAN_SD_POWER);
	593	err_request_power:
	594	free_irq(IRQ_MAGICIAN_SD, data);
	595	err_request_irq:
	596	return err;
bdb0c16a PZ	597	}
	598
	599	static void magician_mci_setpower(struct device *dev, unsigned int vdd)
	600	{
	601	struct pxamci_platform_data *pdata = dev->platform_data;
	602
	603	gpio_set_value(EGPIO_MAGICIAN_SD_POWER, (1 << vdd) & pdata->ocr_mask);
	604	}
	605
	606	static int magician_mci_get_ro(struct device *dev)
	607	{
	608	return (!gpio_get_value(EGPIO_MAGICIAN_nSD_READONLY));
	609	}
	610
	611	static void magician_mci_exit(struct device dev, void data)
	612	{
a1999cd1 PZ	613	gpio_free(EGPIO_MAGICIAN_nSD_READONLY);
a1999cd1 PZ	614	gpio_free(EGPIO_MAGICIAN_SD_POWER);
bdb0c16a PZ	615	free_irq(IRQ_MAGICIAN_SD, data);
	616	}
	617
	618	static struct pxamci_platform_data magician_mci_info = {
	619	.ocr_mask = MMC_VDD_32_33\|MMC_VDD_33_34,
	620	.init = magician_mci_init,
	621	.get_ro = magician_mci_get_ro,
	622	.setpower = magician_mci_setpower,
	623	.exit = magician_mci_exit,
	624	};
	625
	626
e5c271ec PZ	627	/*
	628	* USB OHCI
	629	*/
	630
	631	static int magician_ohci_init(struct device *dev)
	632	{
	633	UHCHR = (UHCHR \| UHCHR_SSEP2 \| UHCHR_PCPL \| UHCHR_CGR) &
	634	~(UHCHR_SSEP1 \| UHCHR_SSEP3 \| UHCHR_SSE);
	635
	636	return 0;
	637	}
	638
	639	static struct pxaohci_platform_data magician_ohci_info = {
	640	.port_mode = PMM_PERPORT_MODE,
	641	.init = magician_ohci_init,
	642	.power_budget = 0,
	643	};
	644
	645
	646	/*
	647	* StrataFlash
	648	*/
	649
aa797590 PZ	650	static void magician_set_vpp(struct map_info *map, int vpp)
	651	{
	652	gpio_set_value(EGPIO_MAGICIAN_FLASH_VPP, vpp);
	653	}
	654
e5c271ec PZ	655	#define PXA_CS_SIZE 0x04000000
	656
	657	static struct resource strataflash_resource = {
	658	.start = PXA_CS0_PHYS,
	659	.end = PXA_CS0_PHYS + PXA_CS_SIZE - 1,
	660	.flags = IORESOURCE_MEM,
	661	};
	662
	663	static struct physmap_flash_data strataflash_data = {
	664	.width = 4,
aa797590	665	.set_vpp = magician_set_vpp,
e5c271ec PZ	666	};
	667
	668	static struct platform_device strataflash = {
	669	.name = "physmap-flash",
	670	.id = -1,
e5c271ec	671	.resource = &strataflash_resource,
70e357f8	672	.num_resources = 1,
e5c271ec PZ	673	.dev = {
	674	.platform_data = &strataflash_data,
	675	},
	676	};
	677
	678	/*
	679	* Platform devices
	680	*/
	681
	682	static struct platform_device *devices[] __initdata = {
	683	&gpio_keys,
70e357f8	684	&egpio,
e5c271ec	685	&backlight,
81447b2e	686	&pasic3,
350d115d	687	&power_supply,
e5c271ec	688	&strataflash,
81447b2e	689	&leds_gpio,
e5c271ec PZ	690	};
	691
	692	static void __init magician_init(void)
	693	{
e07ff8d8 PZ	694	void __iomem *cpld;
e07ff8d8 PZ	695	int lcd_select;
a1999cd1 PZ	696	int err;
	697
	698	gpio_request(GPIO13_MAGICIAN_CPLD_IRQ, "CPLD_IRQ");
	699	gpio_request(GPIO107_MAGICIAN_DS1WM_IRQ, "DS1WM_IRQ");
e07ff8d8	700
b168281c PZ	701	pxa2xx_mfp_config(ARRAY_AND_SIZE(magician_pin_config));
b168281c PZ	702
e5c271ec	703	platform_add_devices(devices, ARRAY_SIZE(devices));
a1999cd1 PZ	704
	705	err = gpio_request(GPIO83_MAGICIAN_nIR_EN, "nIR_EN");
	706	if (!err) {
	707	gpio_direction_output(GPIO83_MAGICIAN_nIR_EN, 1);
	708	pxa_set_ficp_info(&magician_ficp_info);
	709	}
e6816f34	710	pxa_set_i2c_info(NULL);
bdb0c16a	711	pxa_set_mci_info(&magician_mci_info);
e5c271ec	712	pxa_set_ohci_info(&magician_ohci_info);
e07ff8d8 PZ	713
	714	/* Check LCD type we have */
	715	cpld = ioremap_nocache(PXA_CS3_PHYS, 0x1000);
	716	if (cpld) {
	717	u8 board_id = __raw_readb(cpld+0x14);
a1999cd1	718	iounmap(cpld);
e07ff8d8 PZ	719	system_rev = board_id & 0x7;
e07ff8d8 PZ	720	lcd_select = board_id & 0x8;
e07ff8d8	721	pr_info("LCD type: %s\n", lcd_select ? "Samsung" : "Toppoly");
a1999cd1 PZ	722	if (lcd_select && (system_rev < 3)) {
	723	gpio_request(GPIO75_MAGICIAN_SAMSUNG_POWER, "SAMSUNG_POWER");
	724	gpio_direction_output(GPIO75_MAGICIAN_SAMSUNG_POWER, 0);
	725	}
	726	gpio_request(GPIO104_MAGICIAN_LCD_POWER_1, "LCD_POWER_1");
	727	gpio_request(GPIO105_MAGICIAN_LCD_POWER_2, "LCD_POWER_2");
	728	gpio_request(GPIO106_MAGICIAN_LCD_POWER_3, "LCD_POWER_3");
	729	gpio_direction_output(GPIO104_MAGICIAN_LCD_POWER_1, 0);
	730	gpio_direction_output(GPIO105_MAGICIAN_LCD_POWER_2, 0);
	731	gpio_direction_output(GPIO106_MAGICIAN_LCD_POWER_3, 0);
e07ff8d8 PZ	732	set_pxa_fb_info(lcd_select ? &samsung_info : &toppoly_info);
	733	} else
	734	pr_err("LCD detection: CPLD mapping failed\n");
e5c271ec PZ	735	}
	736
	737
	738	MACHINE_START(MAGICIAN, "HTC Magician")
	739	.phys_io = 0x40000000,
	740	.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
	741	.boot_params = 0xa0000100,
	742	.map_io = pxa_map_io,
	743	.init_irq = pxa27x_init_irq,
	744	.init_machine = magician_init,
	745	.timer = &pxa_timer,
	746	MACHINE_END