[deliverable/linux.git] / arch / arm / mach-shmobile / board-kota2.c

/*
 * kota2 board support
 *
 * Copyright (C) 2011  Renesas Solutions Corp.
 * Copyright (C) 2011  Magnus Damm
 * Copyright (C) 2010  Takashi Yoshii <yoshii.takashi.zj@renesas.com>
 * Copyright (C) 2009  Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/regulator/fixed.h>
#include <linux/regulator/machine.h>
#include <linux/smsc911x.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/input/sh_keysc.h>
#include <linux/gpio_keys.h>
#include <linux/leds.h>
#include <linux/irqchip/arm-gic.h>
#include <linux/platform_data/leds-renesas-tpu.h>
#include <linux/mmc/host.h>
#include <linux/mmc/sh_mmcif.h>
#include <linux/mfd/tmio.h>
#include <linux/mmc/sh_mobile_sdhi.h>
#include <mach/hardware.h>
#include <mach/irqs.h>
#include <mach/sh73a0.h>
#include <mach/common.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/time.h>
#include <asm/hardware/cache-l2x0.h>
#include <asm/traps.h>

/* Dummy supplies, where voltage doesn't matter */
static struct regulator_consumer_supply dummy_supplies[] = {
	REGULATOR_SUPPLY("vddvario", "smsc911x"),
	REGULATOR_SUPPLY("vdd33a", "smsc911x"),
};

/* SMSC 9220 */
static struct resource smsc9220_resources[] = {
	[0] = {
		.start		= 0x14000000, /* CS5A */
		.end		= 0x140000ff, /* A1->A7 */
		.flags		= IORESOURCE_MEM,
	},
	[1] = {
		.start		= SH73A0_PINT0_IRQ(2), /* PINTA2 */
		.flags		= IORESOURCE_IRQ,
	},
};

static struct smsc911x_platform_config smsc9220_platdata = {
	.flags		= SMSC911X_USE_32BIT, /* 32-bit SW on 16-bit HW bus */
	.phy_interface	= PHY_INTERFACE_MODE_MII,
	.irq_polarity	= SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
	.irq_type	= SMSC911X_IRQ_TYPE_PUSH_PULL,
};

static struct platform_device eth_device = {
	.name		= "smsc911x",
	.id		= 0,
	.dev  = {
		.platform_data = &smsc9220_platdata,
	},
	.resource	= smsc9220_resources,
	.num_resources	= ARRAY_SIZE(smsc9220_resources),
};

/* KEYSC */
static struct sh_keysc_info keysc_platdata = {
	.mode		= SH_KEYSC_MODE_6,
	.scan_timing	= 3,
	.delay		= 100,
	.keycodes	= {
		KEY_NUMERIC_STAR, KEY_NUMERIC_0, KEY_NUMERIC_POUND,
		0, 0, 0, 0, 0,
		KEY_NUMERIC_7, KEY_NUMERIC_8, KEY_NUMERIC_9,
		0, KEY_DOWN, 0, 0, 0,
		KEY_NUMERIC_4, KEY_NUMERIC_5, KEY_NUMERIC_6,
		KEY_LEFT, KEY_ENTER, KEY_RIGHT, 0, 0,
		KEY_NUMERIC_1, KEY_NUMERIC_2, KEY_NUMERIC_3,
		0, KEY_UP, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
	},
};

static struct resource keysc_resources[] = {
	[0] = {
		.name	= "KEYSC",
		.start	= 0xe61b0000,
		.end	= 0xe61b0098 - 1,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= gic_spi(71),
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device keysc_device = {
	.name		= "sh_keysc",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(keysc_resources),
	.resource	= keysc_resources,
	.dev		= {
		.platform_data	= &keysc_platdata,
	},
};

/* GPIO KEY */
#define GPIO_KEY(c, g, d) { .code = c, .gpio = g, .desc = d, .active_low = 1 }

static struct gpio_keys_button gpio_buttons[] = {
	GPIO_KEY(KEY_VOLUMEUP, GPIO_PORT56, "+"), /* S2: VOL+ [IRQ9] */
	GPIO_KEY(KEY_VOLUMEDOWN, GPIO_PORT54, "-"), /* S3: VOL- [IRQ10] */
	GPIO_KEY(KEY_MENU, GPIO_PORT27, "Menu"), /* S4: MENU [IRQ30] */
	GPIO_KEY(KEY_HOMEPAGE, GPIO_PORT26, "Home"), /* S5: HOME [IRQ31] */
	GPIO_KEY(KEY_BACK, GPIO_PORT11, "Back"), /* S6: BACK [IRQ0] */
	GPIO_KEY(KEY_PHONE, GPIO_PORT238, "Tel"), /* S7: TEL [IRQ11] */
	GPIO_KEY(KEY_POWER, GPIO_PORT239, "C1"), /* S8: CAM [IRQ13] */
	GPIO_KEY(KEY_MAIL, GPIO_PORT224, "Mail"), /* S9: MAIL [IRQ3] */
	/* Omitted button "C3?": GPIO_PORT223 - S10: CUST [IRQ8] */
	GPIO_KEY(KEY_CAMERA, GPIO_PORT164, "C2"), /* S11: CAM_HALF [IRQ25] */
	/* Omitted button "?": GPIO_PORT152 - S12: CAM_FULL [No IRQ] */
};

static struct gpio_keys_platform_data gpio_key_info = {
	.buttons        = gpio_buttons,
	.nbuttons       = ARRAY_SIZE(gpio_buttons),
};

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

/* GPIO LED */
#define GPIO_LED(n, g) { .name = n, .gpio = g }

static struct gpio_led gpio_leds[] = {
	GPIO_LED("G", GPIO_PORT20), /* PORT20 [GPO0] -> LED7 -> "G" */
	GPIO_LED("H", GPIO_PORT21), /* PORT21 [GPO1] -> LED8 -> "H" */
	GPIO_LED("J", GPIO_PORT22), /* PORT22 [GPO2] -> LED9 -> "J" */
};

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

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

/* TPU LED */
static struct led_renesas_tpu_config led_renesas_tpu12_pdata = {
	.name		= "V2513",
	.pin_gpio_fn	= GPIO_FN_TPU1TO2,
	.pin_gpio	= GPIO_PORT153,
	.channel_offset = 0x90,
	.timer_bit = 2,
	.max_brightness = 1000,
};

static struct resource tpu12_resources[] = {
	[0] = {
		.name	= "TPU12",
		.start	= 0xe6610090,
		.end	= 0xe66100b5,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device leds_tpu12_device = {
	.name = "leds-renesas-tpu",
	.id = 12,
	.dev = {
		.platform_data  = &led_renesas_tpu12_pdata,
	},
	.num_resources	= ARRAY_SIZE(tpu12_resources),
	.resource	= tpu12_resources,
};

static struct led_renesas_tpu_config led_renesas_tpu41_pdata = {
	.name		= "V2514",
	.pin_gpio_fn	= GPIO_FN_TPU4TO1,
	.pin_gpio	= GPIO_PORT199,
	.channel_offset = 0x50,
	.timer_bit = 1,
	.max_brightness = 1000,
};

static struct resource tpu41_resources[] = {
	[0] = {
		.name	= "TPU41",
		.start	= 0xe6640050,
		.end	= 0xe6640075,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device leds_tpu41_device = {
	.name = "leds-renesas-tpu",
	.id = 41,
	.dev = {
		.platform_data  = &led_renesas_tpu41_pdata,
	},
	.num_resources	= ARRAY_SIZE(tpu41_resources),
	.resource	= tpu41_resources,
};

static struct led_renesas_tpu_config led_renesas_tpu21_pdata = {
	.name		= "V2515",
	.pin_gpio_fn	= GPIO_FN_TPU2TO1,
	.pin_gpio	= GPIO_PORT197,
	.channel_offset = 0x50,
	.timer_bit = 1,
	.max_brightness = 1000,
};

static struct resource tpu21_resources[] = {
	[0] = {
		.name	= "TPU21",
		.start	= 0xe6620050,
		.end	= 0xe6620075,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device leds_tpu21_device = {
	.name = "leds-renesas-tpu",
	.id = 21,
	.dev = {
		.platform_data  = &led_renesas_tpu21_pdata,
	},
	.num_resources	= ARRAY_SIZE(tpu21_resources),
	.resource	= tpu21_resources,
};

static struct led_renesas_tpu_config led_renesas_tpu30_pdata = {
	.name		= "KEYLED",
	.pin_gpio_fn	= GPIO_FN_TPU3TO0,
	.pin_gpio	= GPIO_PORT163,
	.channel_offset = 0x10,
	.timer_bit = 0,
	.max_brightness = 1000,
};

static struct resource tpu30_resources[] = {
	[0] = {
		.name	= "TPU30",
		.start	= 0xe6630010,
		.end	= 0xe6630035,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device leds_tpu30_device = {
	.name = "leds-renesas-tpu",
	.id = 30,
	.dev = {
		.platform_data  = &led_renesas_tpu30_pdata,
	},
	.num_resources	= ARRAY_SIZE(tpu30_resources),
	.resource	= tpu30_resources,
};

/* Fixed 1.8V regulator to be used by MMCIF */
static struct regulator_consumer_supply fixed1v8_power_consumers[] =
{
	REGULATOR_SUPPLY("vmmc", "sh_mmcif.0"),
	REGULATOR_SUPPLY("vqmmc", "sh_mmcif.0"),
};

/* MMCIF */
static struct resource mmcif_resources[] = {
	[0] = {
		.name   = "MMCIF",
		.start  = 0xe6bd0000,
		.end    = 0xe6bd00ff,
		.flags  = IORESOURCE_MEM,
	},
	[1] = {
		.start  = gic_spi(140),
		.flags  = IORESOURCE_IRQ,
	},
	[2] = {
		.start  = gic_spi(141),
		.flags  = IORESOURCE_IRQ,
	},
};

static struct sh_mmcif_plat_data mmcif_info = {
	.ocr            = MMC_VDD_165_195,
	.caps           = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE,
};

static struct platform_device mmcif_device = {
	.name           = "sh_mmcif",
	.id             = 0,
	.dev            = {
		.platform_data          = &mmcif_info,
	},
	.num_resources  = ARRAY_SIZE(mmcif_resources),
	.resource       = mmcif_resources,
};

/* Fixed 3.3V regulator to be used by SDHI0 and SDHI1 */
static struct regulator_consumer_supply fixed3v3_power_consumers[] =
{
	REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
	REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
	REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
	REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.1"),
};

/* SDHI0 */
static struct sh_mobile_sdhi_info sdhi0_info = {
	.tmio_caps      = MMC_CAP_SD_HIGHSPEED,
	.tmio_flags     = TMIO_MMC_WRPROTECT_DISABLE | TMIO_MMC_HAS_IDLE_WAIT,
};

static struct resource sdhi0_resources[] = {
	[0] = {
		.name   = "SDHI0",
		.start  = 0xee100000,
		.end    = 0xee1000ff,
		.flags  = IORESOURCE_MEM,
	},
	[1] = {
		.start  = gic_spi(83),
		.flags  = IORESOURCE_IRQ,
	},
	[2] = {
		.start  = gic_spi(84),
		.flags  = IORESOURCE_IRQ,
	},
	[3] = {
		.start	= gic_spi(85),
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device sdhi0_device = {
	.name           = "sh_mobile_sdhi",
	.id             = 0,
	.num_resources  = ARRAY_SIZE(sdhi0_resources),
	.resource       = sdhi0_resources,
	.dev    = {
		.platform_data  = &sdhi0_info,
	},
};

/* SDHI1 */
static struct sh_mobile_sdhi_info sdhi1_info = {
	.tmio_caps      = MMC_CAP_NONREMOVABLE | MMC_CAP_SDIO_IRQ,
	.tmio_flags     = TMIO_MMC_WRPROTECT_DISABLE | TMIO_MMC_HAS_IDLE_WAIT,
};

static struct resource sdhi1_resources[] = {
	[0] = {
		.name   = "SDHI1",
		.start  = 0xee120000,
		.end    = 0xee1200ff,
		.flags  = IORESOURCE_MEM,
	},
	[1] = {
		.start  = gic_spi(87),
		.flags  = IORESOURCE_IRQ,
	},
	[2] = {
		.start  = gic_spi(88),
		.flags  = IORESOURCE_IRQ,
	},
	[3] = {
		.start	= gic_spi(89),
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device sdhi1_device = {
	.name           = "sh_mobile_sdhi",
	.id             = 1,
	.num_resources  = ARRAY_SIZE(sdhi1_resources),
	.resource       = sdhi1_resources,
	.dev    = {
		.platform_data  = &sdhi1_info,
	},
};

static struct platform_device *kota2_devices[] __initdata = {
	&eth_device,
	&keysc_device,
	&gpio_keys_device,
	&gpio_leds_device,
	&leds_tpu12_device,
	&leds_tpu41_device,
	&leds_tpu21_device,
	&leds_tpu30_device,
	&mmcif_device,
	&sdhi0_device,
	&sdhi1_device,
};

static void __init kota2_init(void)
{
	regulator_register_always_on(0, "fixed-1.8V", fixed1v8_power_consumers,
				     ARRAY_SIZE(fixed1v8_power_consumers), 1800000);
	regulator_register_always_on(1, "fixed-3.3V", fixed3v3_power_consumers,
				     ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
	regulator_register_fixed(2, dummy_supplies, ARRAY_SIZE(dummy_supplies));

	sh73a0_pinmux_init();

	/* SCIFA2 (UART2) */
	gpio_request(GPIO_FN_SCIFA2_TXD1, NULL);
	gpio_request(GPIO_FN_SCIFA2_RXD1, NULL);
	gpio_request(GPIO_FN_SCIFA2_RTS1_, NULL);
	gpio_request(GPIO_FN_SCIFA2_CTS1_, NULL);

	/* SCIFA4 (UART1) */
	gpio_request(GPIO_FN_SCIFA4_TXD, NULL);
	gpio_request(GPIO_FN_SCIFA4_RXD, NULL);
	gpio_request(GPIO_FN_SCIFA4_RTS_, NULL);
	gpio_request(GPIO_FN_SCIFA4_CTS_, NULL);

	/* SMSC911X */
	gpio_request(GPIO_FN_D0_NAF0, NULL);
	gpio_request(GPIO_FN_D1_NAF1, NULL);
	gpio_request(GPIO_FN_D2_NAF2, NULL);
	gpio_request(GPIO_FN_D3_NAF3, NULL);
	gpio_request(GPIO_FN_D4_NAF4, NULL);
	gpio_request(GPIO_FN_D5_NAF5, NULL);
	gpio_request(GPIO_FN_D6_NAF6, NULL);
	gpio_request(GPIO_FN_D7_NAF7, NULL);
	gpio_request(GPIO_FN_D8_NAF8, NULL);
	gpio_request(GPIO_FN_D9_NAF9, NULL);
	gpio_request(GPIO_FN_D10_NAF10, NULL);
	gpio_request(GPIO_FN_D11_NAF11, NULL);
	gpio_request(GPIO_FN_D12_NAF12, NULL);
	gpio_request(GPIO_FN_D13_NAF13, NULL);
	gpio_request(GPIO_FN_D14_NAF14, NULL);
	gpio_request(GPIO_FN_D15_NAF15, NULL);
	gpio_request(GPIO_FN_CS5A_, NULL);
	gpio_request(GPIO_FN_WE0__FWE, NULL);
	gpio_request_one(GPIO_PORT144, GPIOF_IN, NULL); /* PINTA2 */
	gpio_request_one(GPIO_PORT145, GPIOF_OUT_INIT_HIGH, NULL); /* RESET */

	/* KEYSC */
	gpio_request(GPIO_FN_KEYIN0_PU, NULL);
	gpio_request(GPIO_FN_KEYIN1_PU, NULL);
	gpio_request(GPIO_FN_KEYIN2_PU, NULL);
	gpio_request(GPIO_FN_KEYIN3_PU, NULL);
	gpio_request(GPIO_FN_KEYIN4_PU, NULL);
	gpio_request(GPIO_FN_KEYIN5_PU, NULL);
	gpio_request(GPIO_FN_KEYIN6_PU, NULL);
	gpio_request(GPIO_FN_KEYIN7_PU, NULL);
	gpio_request(GPIO_FN_KEYOUT0, NULL);
	gpio_request(GPIO_FN_KEYOUT1, NULL);
	gpio_request(GPIO_FN_KEYOUT2, NULL);
	gpio_request(GPIO_FN_KEYOUT3, NULL);
	gpio_request(GPIO_FN_KEYOUT4, NULL);
	gpio_request(GPIO_FN_KEYOUT5, NULL);
	gpio_request(GPIO_FN_PORT59_KEYOUT6, NULL);
	gpio_request(GPIO_FN_PORT58_KEYOUT7, NULL);
	gpio_request(GPIO_FN_KEYOUT8, NULL);

	/* MMCIF */
	gpio_request(GPIO_FN_MMCCLK0, NULL);
	gpio_request(GPIO_FN_MMCD0_0, NULL);
	gpio_request(GPIO_FN_MMCD0_1, NULL);
	gpio_request(GPIO_FN_MMCD0_2, NULL);
	gpio_request(GPIO_FN_MMCD0_3, NULL);
	gpio_request(GPIO_FN_MMCD0_4, NULL);
	gpio_request(GPIO_FN_MMCD0_5, NULL);
	gpio_request(GPIO_FN_MMCD0_6, NULL);
	gpio_request(GPIO_FN_MMCD0_7, NULL);
	gpio_request(GPIO_FN_MMCCMD0, NULL);
	gpio_request_one(GPIO_PORT208, GPIOF_OUT_INIT_HIGH, NULL); /* Reset */

	/* SDHI0 (microSD) */
	gpio_request(GPIO_FN_SDHICD0_PU, NULL);
	gpio_request(GPIO_FN_SDHICMD0_PU, NULL);
	gpio_request(GPIO_FN_SDHICLK0, NULL);
	gpio_request(GPIO_FN_SDHID0_3_PU, NULL);
	gpio_request(GPIO_FN_SDHID0_2_PU, NULL);
	gpio_request(GPIO_FN_SDHID0_1_PU, NULL);
	gpio_request(GPIO_FN_SDHID0_0_PU, NULL);

	/* SCIFB (BT) */
	gpio_request(GPIO_FN_PORT159_SCIFB_SCK, NULL);
	gpio_request(GPIO_FN_PORT160_SCIFB_TXD, NULL);
	gpio_request(GPIO_FN_PORT161_SCIFB_CTS_, NULL);
	gpio_request(GPIO_FN_PORT162_SCIFB_RXD, NULL);
	gpio_request(GPIO_FN_PORT163_SCIFB_RTS_, NULL);

	/* SDHI1 (BCM4330) */
	gpio_request(GPIO_FN_SDHICLK1, NULL);
	gpio_request(GPIO_FN_SDHICMD1_PU, NULL);
	gpio_request(GPIO_FN_SDHID1_3_PU, NULL);
	gpio_request(GPIO_FN_SDHID1_2_PU, NULL);
	gpio_request(GPIO_FN_SDHID1_1_PU, NULL);
	gpio_request(GPIO_FN_SDHID1_0_PU, NULL);

#ifdef CONFIG_CACHE_L2X0
	/* Early BRESP enable, Shared attribute override enable, 64K*8way */
	l2x0_init(IOMEM(0xf0100000), 0x40460000, 0x82000fff);
#endif
	sh73a0_add_standard_devices();
	platform_add_devices(kota2_devices, ARRAY_SIZE(kota2_devices));
}

MACHINE_START(KOTA2, "kota2")
	.smp		= smp_ops(sh73a0_smp_ops),
	.map_io		= sh73a0_map_io,
	.init_early	= sh73a0_add_early_devices,
	.nr_irqs	= NR_IRQS_LEGACY,
	.init_irq	= sh73a0_init_irq,
	.init_machine	= kota2_init,
	.init_late	= shmobile_init_late,
	.init_time	= sh73a0_earlytimer_init,
MACHINE_END
Commit	Line	Data
28626632 MD	1	/*
	2	* kota2 board support
	3	*
	4	* Copyright (C) 2011 Renesas Solutions Corp.
	5	* Copyright (C) 2011 Magnus Damm
	6	* Copyright (C) 2010 Takashi Yoshii <yoshii.takashi.zj@renesas.com>
	7	* Copyright (C) 2009 Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
	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 as published by
	11	* the Free Software Foundation; version 2 of the License.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include <linux/kernel.h>
	24	#include <linux/init.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/irq.h>
	27	#include <linux/platform_device.h>
	28	#include <linux/delay.h>
	29	#include <linux/io.h>
f185c214 GL	30	#include <linux/regulator/fixed.h>
f185c214 GL	31	#include <linux/regulator/machine.h>
28626632 MD	32	#include <linux/smsc911x.h>
28626632 MD	33	#include <linux/gpio.h>
ef4f994a MD	34	#include <linux/input.h>
ef4f994a MD	35	#include <linux/input/sh_keysc.h>
6b7c0ea2	36	#include <linux/gpio_keys.h>
ae6e7083	37	#include <linux/leds.h>
520f7bd7	38	#include <linux/irqchip/arm-gic.h>
33661c9e	39	#include <linux/platform_data/leds-renesas-tpu.h>
4e927945 MD	40	#include <linux/mmc/host.h>
4e927945 MD	41	#include <linux/mmc/sh_mmcif.h>
8722c996 MD	42	#include <linux/mfd/tmio.h>
8722c996 MD	43	#include <linux/mmc/sh_mobile_sdhi.h>
28626632	44	#include <mach/hardware.h>
250a2723	45	#include <mach/irqs.h>
28626632 MD	46	#include <mach/sh73a0.h>
	47	#include <mach/common.h>
	48	#include <asm/mach-types.h>
	49	#include <asm/mach/arch.h>
28626632	50	#include <asm/mach/time.h>
28626632 MD	51	#include <asm/hardware/cache-l2x0.h>
	52	#include <asm/traps.h>
	53
f185c214 GL	54	/* Dummy supplies, where voltage doesn't matter */
	55	static struct regulator_consumer_supply dummy_supplies[] = {
	56	REGULATOR_SUPPLY("vddvario", "smsc911x"),
	57	REGULATOR_SUPPLY("vdd33a", "smsc911x"),
	58	};
	59
c5e7bcd9	60	/* SMSC 9220 */
28626632 MD	61	static struct resource smsc9220_resources[] = {
	62	[0] = {
	63	.start = 0x14000000, /* CS5A */
	64	.end = 0x140000ff, /* A1->A7 */
	65	.flags = IORESOURCE_MEM,
	66	},
	67	[1] = {
1b6cec8a	68	.start = SH73A0_PINT0_IRQ(2), /* PINTA2 */
28626632 MD	69	.flags = IORESOURCE_IRQ,
	70	},
	71	};
	72
	73	static struct smsc911x_platform_config smsc9220_platdata = {
	74	.flags = SMSC911X_USE_32BIT, /* 32-bit SW on 16-bit HW bus */
	75	.phy_interface = PHY_INTERFACE_MODE_MII,
	76	.irq_polarity = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
	77	.irq_type = SMSC911X_IRQ_TYPE_PUSH_PULL,
	78	};
	79
	80	static struct platform_device eth_device = {
	81	.name = "smsc911x",
	82	.id = 0,
	83	.dev = {
	84	.platform_data = &smsc9220_platdata,
	85	},
	86	.resource = smsc9220_resources,
	87	.num_resources = ARRAY_SIZE(smsc9220_resources),
	88	};
	89
c5e7bcd9	90	/* KEYSC */
ef4f994a MD	91	static struct sh_keysc_info keysc_platdata = {
	92	.mode = SH_KEYSC_MODE_6,
	93	.scan_timing = 3,
	94	.delay = 100,
	95	.keycodes = {
	96	KEY_NUMERIC_STAR, KEY_NUMERIC_0, KEY_NUMERIC_POUND,
	97	0, 0, 0, 0, 0,
	98	KEY_NUMERIC_7, KEY_NUMERIC_8, KEY_NUMERIC_9,
	99	0, KEY_DOWN, 0, 0, 0,
	100	KEY_NUMERIC_4, KEY_NUMERIC_5, KEY_NUMERIC_6,
	101	KEY_LEFT, KEY_ENTER, KEY_RIGHT, 0, 0,
	102	KEY_NUMERIC_1, KEY_NUMERIC_2, KEY_NUMERIC_3,
	103	0, KEY_UP, 0, 0, 0,
	104	0, 0, 0, 0, 0, 0, 0, 0,
	105	0, 0, 0, 0, 0, 0, 0, 0,
	106	0, 0, 0, 0, 0, 0, 0, 0,
	107	0, 0, 0, 0, 0, 0, 0, 0,
	108	},
	109	};
	110
	111	static struct resource keysc_resources[] = {
	112	[0] = {
	113	.name = "KEYSC",
	114	.start = 0xe61b0000,
	115	.end = 0xe61b0098 - 1,
	116	.flags = IORESOURCE_MEM,
	117	},
	118	[1] = {
	119	.start = gic_spi(71),
	120	.flags = IORESOURCE_IRQ,
	121	},
	122	};
	123
	124	static struct platform_device keysc_device = {
	125	.name = "sh_keysc",
	126	.id = 0,
	127	.num_resources = ARRAY_SIZE(keysc_resources),
	128	.resource = keysc_resources,
	129	.dev = {
	130	.platform_data = &keysc_platdata,
	131	},
	132	};
	133
c5e7bcd9	134	/* GPIO KEY */
6b7c0ea2 MD	135	#define GPIO_KEY(c, g, d) { .code = c, .gpio = g, .desc = d, .active_low = 1 }
	136
	137	static struct gpio_keys_button gpio_buttons[] = {
	138	GPIO_KEY(KEY_VOLUMEUP, GPIO_PORT56, "+"), /* S2: VOL+ [IRQ9] */
	139	GPIO_KEY(KEY_VOLUMEDOWN, GPIO_PORT54, "-"), /* S3: VOL- [IRQ10] */
	140	GPIO_KEY(KEY_MENU, GPIO_PORT27, "Menu"), /* S4: MENU [IRQ30] */
	141	GPIO_KEY(KEY_HOMEPAGE, GPIO_PORT26, "Home"), /* S5: HOME [IRQ31] */
	142	GPIO_KEY(KEY_BACK, GPIO_PORT11, "Back"), /* S6: BACK [IRQ0] */
	143	GPIO_KEY(KEY_PHONE, GPIO_PORT238, "Tel"), /* S7: TEL [IRQ11] */
	144	GPIO_KEY(KEY_POWER, GPIO_PORT239, "C1"), /* S8: CAM [IRQ13] */
	145	GPIO_KEY(KEY_MAIL, GPIO_PORT224, "Mail"), /* S9: MAIL [IRQ3] */
	146	/* Omitted button "C3?": GPIO_PORT223 - S10: CUST [IRQ8] */
	147	GPIO_KEY(KEY_CAMERA, GPIO_PORT164, "C2"), /* S11: CAM_HALF [IRQ25] */
	148	/* Omitted button "?": GPIO_PORT152 - S12: CAM_FULL [No IRQ] */
	149	};
	150
	151	static struct gpio_keys_platform_data gpio_key_info = {
	152	.buttons = gpio_buttons,
	153	.nbuttons = ARRAY_SIZE(gpio_buttons),
6b7c0ea2 MD	154	};
	155
	156	static struct platform_device gpio_keys_device = {
2fde109c	157	.name = "gpio-keys",
6b7c0ea2 MD	158	.id = -1,
	159	.dev = {
	160	.platform_data = &gpio_key_info,
	161	},
	162	};
	163
c5e7bcd9	164	/* GPIO LED */
ae6e7083 MD	165	#define GPIO_LED(n, g) { .name = n, .gpio = g }
	166
	167	static struct gpio_led gpio_leds[] = {
ae6e7083 MD	168	GPIO_LED("G", GPIO_PORT20), /* PORT20 [GPO0] -> LED7 -> "G" */
	169	GPIO_LED("H", GPIO_PORT21), /* PORT21 [GPO1] -> LED8 -> "H" */
	170	GPIO_LED("J", GPIO_PORT22), /* PORT22 [GPO2] -> LED9 -> "J" */
	171	};
	172
	173	static struct gpio_led_platform_data gpio_leds_info = {
	174	.leds = gpio_leds,
	175	.num_leds = ARRAY_SIZE(gpio_leds),
	176	};
	177
	178	static struct platform_device gpio_leds_device = {
	179	.name = "leds-gpio",
	180	.id = -1,
	181	.dev = {
	182	.platform_data = &gpio_leds_info,
	183	},
	184	};
	185
33661c9e MD	186	/* TPU LED */
	187	static struct led_renesas_tpu_config led_renesas_tpu12_pdata = {
	188	.name = "V2513",
	189	.pin_gpio_fn = GPIO_FN_TPU1TO2,
	190	.pin_gpio = GPIO_PORT153,
	191	.channel_offset = 0x90,
	192	.timer_bit = 2,
	193	.max_brightness = 1000,
	194	};
	195
	196	static struct resource tpu12_resources[] = {
	197	[0] = {
	198	.name = "TPU12",
	199	.start = 0xe6610090,
	200	.end = 0xe66100b5,
	201	.flags = IORESOURCE_MEM,
	202	},
	203	};
	204
	205	static struct platform_device leds_tpu12_device = {
	206	.name = "leds-renesas-tpu",
	207	.id = 12,
	208	.dev = {
	209	.platform_data = &led_renesas_tpu12_pdata,
	210	},
	211	.num_resources = ARRAY_SIZE(tpu12_resources),
	212	.resource = tpu12_resources,
	213	};
	214
	215	static struct led_renesas_tpu_config led_renesas_tpu41_pdata = {
	216	.name = "V2514",
	217	.pin_gpio_fn = GPIO_FN_TPU4TO1,
	218	.pin_gpio = GPIO_PORT199,
	219	.channel_offset = 0x50,
	220	.timer_bit = 1,
	221	.max_brightness = 1000,
	222	};
	223
	224	static struct resource tpu41_resources[] = {
	225	[0] = {
	226	.name = "TPU41",
	227	.start = 0xe6640050,
	228	.end = 0xe6640075,
	229	.flags = IORESOURCE_MEM,
	230	},
	231	};
	232
	233	static struct platform_device leds_tpu41_device = {
	234	.name = "leds-renesas-tpu",
	235	.id = 41,
	236	.dev = {
	237	.platform_data = &led_renesas_tpu41_pdata,
	238	},
	239	.num_resources = ARRAY_SIZE(tpu41_resources),
	240	.resource = tpu41_resources,
	241	};
	242
	243	static struct led_renesas_tpu_config led_renesas_tpu21_pdata = {
	244	.name = "V2515",
	245	.pin_gpio_fn = GPIO_FN_TPU2TO1,
	246	.pin_gpio = GPIO_PORT197,
	247	.channel_offset = 0x50,
	248	.timer_bit = 1,
	249	.max_brightness = 1000,
250	};
251
252	static struct resource tpu21_resources[] = {
253	[0] = {
254	.name = "TPU21",
255	.start = 0xe6620050,
256	.end = 0xe6620075,
257	.flags = IORESOURCE_MEM,
258	},
259	};
260
261	static struct platform_device leds_tpu21_device = {
262	.name = "leds-renesas-tpu",
263	.id = 21,
264	.dev = {
265	.platform_data = &led_renesas_tpu21_pdata,
266	},
267	.num_resources = ARRAY_SIZE(tpu21_resources),
268	.resource = tpu21_resources,
269	};
270
271	static struct led_renesas_tpu_config led_renesas_tpu30_pdata = {
272	.name = "KEYLED",
273	.pin_gpio_fn = GPIO_FN_TPU3TO0,
274	.pin_gpio = GPIO_PORT163,
275	.channel_offset = 0x10,
276	.timer_bit = 0,
277	.max_brightness = 1000,
278	};
279
280	static struct resource tpu30_resources[] = {
281	[0] = {
282	.name = "TPU30",
283	.start = 0xe6630010,
284	.end = 0xe6630035,
285	.flags = IORESOURCE_MEM,
286	},
287	};
288
289	static struct platform_device leds_tpu30_device = {
290	.name = "leds-renesas-tpu",
291	.id = 30,
292	.dev = {
293	.platform_data = &led_renesas_tpu30_pdata,
294	},
295	.num_resources = ARRAY_SIZE(tpu30_resources),
296	.resource = tpu30_resources,
297	};
298
f185c214 GL	299	/* Fixed 1.8V regulator to be used by MMCIF */
	300	static struct regulator_consumer_supply fixed1v8_power_consumers[] =
	301	{
	302	REGULATOR_SUPPLY("vmmc", "sh_mmcif.0"),
	303	REGULATOR_SUPPLY("vqmmc", "sh_mmcif.0"),
	304	};
	305
c5e7bcd9	306	/* MMCIF */
4e927945 MD	307	static struct resource mmcif_resources[] = {
	308	[0] = {
	309	.name = "MMCIF",
	310	.start = 0xe6bd0000,
	311	.end = 0xe6bd00ff,
	312	.flags = IORESOURCE_MEM,
	313	},
	314	[1] = {
	315	.start = gic_spi(140),
	316	.flags = IORESOURCE_IRQ,
	317	},
	318	[2] = {
	319	.start = gic_spi(141),
	320	.flags = IORESOURCE_IRQ,
	321	},
	322	};
	323
	324	static struct sh_mmcif_plat_data mmcif_info = {
	325	.ocr = MMC_VDD_165_195,
	326	.caps = MMC_CAP_8_BIT_DATA \| MMC_CAP_NONREMOVABLE,
	327	};
	328
	329	static struct platform_device mmcif_device = {
	330	.name = "sh_mmcif",
	331	.id = 0,
	332	.dev = {
	333	.platform_data = &mmcif_info,
	334	},
	335	.num_resources = ARRAY_SIZE(mmcif_resources),
	336	.resource = mmcif_resources,
	337	};
	338
f185c214 GL	339	/* Fixed 3.3V regulator to be used by SDHI0 and SDHI1 */
	340	static struct regulator_consumer_supply fixed3v3_power_consumers[] =
	341	{
	342	REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
	343	REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
	344	REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
	345	REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.1"),
	346	};
	347
c5e7bcd9	348	/* SDHI0 */
8722c996 MD	349	static struct sh_mobile_sdhi_info sdhi0_info = {
	350	.tmio_caps = MMC_CAP_SD_HIGHSPEED,
	351	.tmio_flags = TMIO_MMC_WRPROTECT_DISABLE \| TMIO_MMC_HAS_IDLE_WAIT,
	352	};
	353
	354	static struct resource sdhi0_resources[] = {
	355	[0] = {
	356	.name = "SDHI0",
	357	.start = 0xee100000,
	358	.end = 0xee1000ff,
	359	.flags = IORESOURCE_MEM,
	360	},
	361	[1] = {
	362	.start = gic_spi(83),
	363	.flags = IORESOURCE_IRQ,
	364	},
	365	[2] = {
	366	.start = gic_spi(84),
	367	.flags = IORESOURCE_IRQ,
	368	},
	369	[3] = {
	370	.start = gic_spi(85),
	371	.flags = IORESOURCE_IRQ,
	372	},
	373	};
	374
	375	static struct platform_device sdhi0_device = {
	376	.name = "sh_mobile_sdhi",
	377	.id = 0,
	378	.num_resources = ARRAY_SIZE(sdhi0_resources),
	379	.resource = sdhi0_resources,
	380	.dev = {
	381	.platform_data = &sdhi0_info,
	382	},
	383	};
	384
c5e7bcd9	385	/* SDHI1 */
8722c996 MD	386	static struct sh_mobile_sdhi_info sdhi1_info = {
	387	.tmio_caps = MMC_CAP_NONREMOVABLE \| MMC_CAP_SDIO_IRQ,
	388	.tmio_flags = TMIO_MMC_WRPROTECT_DISABLE \| TMIO_MMC_HAS_IDLE_WAIT,
	389	};
	390
	391	static struct resource sdhi1_resources[] = {
	392	[0] = {
	393	.name = "SDHI1",
	394	.start = 0xee120000,
	395	.end = 0xee1200ff,
	396	.flags = IORESOURCE_MEM,
	397	},
	398	[1] = {
	399	.start = gic_spi(87),
	400	.flags = IORESOURCE_IRQ,
	401	},
	402	[2] = {
	403	.start = gic_spi(88),
	404	.flags = IORESOURCE_IRQ,
	405	},
	406	[3] = {
	407	.start = gic_spi(89),
	408	.flags = IORESOURCE_IRQ,
	409	},
	410	};
	411
	412	static struct platform_device sdhi1_device = {
	413	.name = "sh_mobile_sdhi",
	414	.id = 1,
	415	.num_resources = ARRAY_SIZE(sdhi1_resources),
	416	.resource = sdhi1_resources,
	417	.dev = {
	418	.platform_data = &sdhi1_info,
	419	},
	420	};
	421
28626632 MD	422	static struct platform_device *kota2_devices[] __initdata = {
28626632 MD	423	&eth_device,
ef4f994a	424	&keysc_device,
6b7c0ea2	425	&gpio_keys_device,
ae6e7083	426	&gpio_leds_device,
33661c9e MD	427	&leds_tpu12_device,
	428	&leds_tpu41_device,
	429	&leds_tpu21_device,
	430	&leds_tpu30_device,
4e927945	431	&mmcif_device,
8722c996 MD	432	&sdhi0_device,
8722c996 MD	433	&sdhi1_device,
28626632 MD	434	};
28626632 MD	435
28626632 MD	436	static void __init kota2_init(void)
28626632 MD	437	{
f185c214 GL	438	regulator_register_always_on(0, "fixed-1.8V", fixed1v8_power_consumers,
	439	ARRAY_SIZE(fixed1v8_power_consumers), 1800000);
	440	regulator_register_always_on(1, "fixed-3.3V", fixed3v3_power_consumers,
	441	ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
	442	regulator_register_fixed(2, dummy_supplies, ARRAY_SIZE(dummy_supplies));
	443
28626632 MD	444	sh73a0_pinmux_init();
	445
	446	/* SCIFA2 (UART2) */
	447	gpio_request(GPIO_FN_SCIFA2_TXD1, NULL);
	448	gpio_request(GPIO_FN_SCIFA2_RXD1, NULL);
	449	gpio_request(GPIO_FN_SCIFA2_RTS1_, NULL);
	450	gpio_request(GPIO_FN_SCIFA2_CTS1_, NULL);
	451
9e9a8924 MD	452	/* SCIFA4 (UART1) */
	453	gpio_request(GPIO_FN_SCIFA4_TXD, NULL);
	454	gpio_request(GPIO_FN_SCIFA4_RXD, NULL);
	455	gpio_request(GPIO_FN_SCIFA4_RTS_, NULL);
	456	gpio_request(GPIO_FN_SCIFA4_CTS_, NULL);
	457
28626632 MD	458	/* SMSC911X */
	459	gpio_request(GPIO_FN_D0_NAF0, NULL);
	460	gpio_request(GPIO_FN_D1_NAF1, NULL);
	461	gpio_request(GPIO_FN_D2_NAF2, NULL);
	462	gpio_request(GPIO_FN_D3_NAF3, NULL);
	463	gpio_request(GPIO_FN_D4_NAF4, NULL);
	464	gpio_request(GPIO_FN_D5_NAF5, NULL);
	465	gpio_request(GPIO_FN_D6_NAF6, NULL);
	466	gpio_request(GPIO_FN_D7_NAF7, NULL);
	467	gpio_request(GPIO_FN_D8_NAF8, NULL);
	468	gpio_request(GPIO_FN_D9_NAF9, NULL);
	469	gpio_request(GPIO_FN_D10_NAF10, NULL);
	470	gpio_request(GPIO_FN_D11_NAF11, NULL);
	471	gpio_request(GPIO_FN_D12_NAF12, NULL);
	472	gpio_request(GPIO_FN_D13_NAF13, NULL);
	473	gpio_request(GPIO_FN_D14_NAF14, NULL);
	474	gpio_request(GPIO_FN_D15_NAF15, NULL);
	475	gpio_request(GPIO_FN_CS5A_, NULL);
	476	gpio_request(GPIO_FN_WE0__FWE, NULL);
6c52bce4 LP	477	gpio_request_one(GPIO_PORT144, GPIOF_IN, NULL); /* PINTA2 */
6c52bce4 LP	478	gpio_request_one(GPIO_PORT145, GPIOF_OUT_INIT_HIGH, NULL); /* RESET */
28626632	479
ef4f994a MD	480	/* KEYSC */
	481	gpio_request(GPIO_FN_KEYIN0_PU, NULL);
	482	gpio_request(GPIO_FN_KEYIN1_PU, NULL);
	483	gpio_request(GPIO_FN_KEYIN2_PU, NULL);
	484	gpio_request(GPIO_FN_KEYIN3_PU, NULL);
	485	gpio_request(GPIO_FN_KEYIN4_PU, NULL);
	486	gpio_request(GPIO_FN_KEYIN5_PU, NULL);
	487	gpio_request(GPIO_FN_KEYIN6_PU, NULL);
	488	gpio_request(GPIO_FN_KEYIN7_PU, NULL);
	489	gpio_request(GPIO_FN_KEYOUT0, NULL);
	490	gpio_request(GPIO_FN_KEYOUT1, NULL);
	491	gpio_request(GPIO_FN_KEYOUT2, NULL);
	492	gpio_request(GPIO_FN_KEYOUT3, NULL);
	493	gpio_request(GPIO_FN_KEYOUT4, NULL);
	494	gpio_request(GPIO_FN_KEYOUT5, NULL);
	495	gpio_request(GPIO_FN_PORT59_KEYOUT6, NULL);
	496	gpio_request(GPIO_FN_PORT58_KEYOUT7, NULL);
	497	gpio_request(GPIO_FN_KEYOUT8, NULL);
	498
4e927945 MD	499	/* MMCIF */
	500	gpio_request(GPIO_FN_MMCCLK0, NULL);
	501	gpio_request(GPIO_FN_MMCD0_0, NULL);
	502	gpio_request(GPIO_FN_MMCD0_1, NULL);
	503	gpio_request(GPIO_FN_MMCD0_2, NULL);
	504	gpio_request(GPIO_FN_MMCD0_3, NULL);
	505	gpio_request(GPIO_FN_MMCD0_4, NULL);
	506	gpio_request(GPIO_FN_MMCD0_5, NULL);
	507	gpio_request(GPIO_FN_MMCD0_6, NULL);
	508	gpio_request(GPIO_FN_MMCD0_7, NULL);
	509	gpio_request(GPIO_FN_MMCCMD0, NULL);
6c52bce4	510	gpio_request_one(GPIO_PORT208, GPIOF_OUT_INIT_HIGH, NULL); /* Reset */
4e927945	511
8722c996 MD	512	/* SDHI0 (microSD) */
	513	gpio_request(GPIO_FN_SDHICD0_PU, NULL);
	514	gpio_request(GPIO_FN_SDHICMD0_PU, NULL);
	515	gpio_request(GPIO_FN_SDHICLK0, NULL);
	516	gpio_request(GPIO_FN_SDHID0_3_PU, NULL);
	517	gpio_request(GPIO_FN_SDHID0_2_PU, NULL);
	518	gpio_request(GPIO_FN_SDHID0_1_PU, NULL);
	519	gpio_request(GPIO_FN_SDHID0_0_PU, NULL);
	520
9e9a8924 MD	521	/* SCIFB (BT) */
	522	gpio_request(GPIO_FN_PORT159_SCIFB_SCK, NULL);
	523	gpio_request(GPIO_FN_PORT160_SCIFB_TXD, NULL);
	524	gpio_request(GPIO_FN_PORT161_SCIFB_CTS_, NULL);
	525	gpio_request(GPIO_FN_PORT162_SCIFB_RXD, NULL);
	526	gpio_request(GPIO_FN_PORT163_SCIFB_RTS_, NULL);
	527
8722c996 MD	528	/* SDHI1 (BCM4330) */
	529	gpio_request(GPIO_FN_SDHICLK1, NULL);
	530	gpio_request(GPIO_FN_SDHICMD1_PU, NULL);
	531	gpio_request(GPIO_FN_SDHID1_3_PU, NULL);
	532	gpio_request(GPIO_FN_SDHID1_2_PU, NULL);
	533	gpio_request(GPIO_FN_SDHID1_1_PU, NULL);
	534	gpio_request(GPIO_FN_SDHID1_0_PU, NULL);
	535
28626632 MD	536	#ifdef CONFIG_CACHE_L2X0
28626632 MD	537	/* Early BRESP enable, Shared attribute override enable, 64K8way /
a2a47ca3	538	l2x0_init(IOMEM(0xf0100000), 0x40460000, 0x82000fff);
28626632 MD	539	#endif
	540	sh73a0_add_standard_devices();
	541	platform_add_devices(kota2_devices, ARRAY_SIZE(kota2_devices));
	542	}
	543
28626632	544	MACHINE_START(KOTA2, "kota2")
a62580e5	545	.smp = smp_ops(sh73a0_smp_ops),
50e15c34 MD	546	.map_io = sh73a0_map_io,
50e15c34 MD	547	.init_early = sh73a0_add_early_devices,
dcb4ea86	548	.nr_irqs = NR_IRQS_LEGACY,
1b6cec8a	549	.init_irq = sh73a0_init_irq,
28626632	550	.init_machine = kota2_init,
21cc1b7e	551	.init_late = shmobile_init_late,
6bb27d73	552	.init_time = sh73a0_earlytimer_init,
28626632	553	MACHINE_END