[ARM] 3433/1: ARM: OMAP: 8/8 Update board files (9b6553cd) · Commits · e / devices / android_kernel_teracube_2e

arch/arm/mach-omap1/Kconfig

+14 −6

Original line number	Diff line number	Diff line
		@@ -69,12 +69,6 @@ config MACH_VOICEBLUE
		Support for Voiceblue GSM/VoIP gateway. Say Y here if you have
		such a board.

		config MACH_NETSTAR
		bool "NetStar"
		depends on ARCH_OMAP1 && ARCH_OMAP15XX
		help
		Support for NetStar PBX. Say Y here if you have such a board.

		config MACH_OMAP_PALMTE
		bool "Palm Tungsten E"
		depends on ARCH_OMAP1 && ARCH_OMAP15XX
		@@ -85,6 +79,20 @@ config MACH_OMAP_PALMTE
		informations.
		Say Y here if you have such a PDA, say NO otherwise.

		config MACH_NOKIA770
		bool "Nokia 770"
		depends on ARCH_OMAP1 && ARCH_OMAP16XX
		help
		Support for the Nokia 770 Internet Tablet. Say Y here if you
		have such a device.

		config MACH_AMS_DELTA
		bool "Amstrad E3 (Delta)"
		depends on ARCH_OMAP1 && ARCH_OMAP15XX
		help
		Support for the Amstrad E3 (codename Delta) videophone. Say Y here
		if you have such a device.

		config MACH_OMAP_GENERIC
		bool "Generic OMAP board"
		depends on ARCH_OMAP1 && (ARCH_OMAP15XX \|\| ARCH_OMAP16XX)

arch/arm/mach-omap1/board-ams-delta.c

0 → 100644

+116 −0

Original line number	Diff line number	Diff line
		/*
		* linux/arch/arm/mach-omap1/board-ams-delta.c
		*
		* Modified from board-generic.c
		*
		* Board specific inits for the Amstrad E3 (codename Delta) videophone
		*
		* Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
		*
		* 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 <asm/hardware.h>
		#include <asm/mach-types.h>
		#include <asm/mach/arch.h>
		#include <asm/mach/map.h>

		#include <asm/arch/board-ams-delta.h>
		#include <asm/arch/gpio.h>
		#include <asm/arch/mux.h>
		#include <asm/arch/usb.h>
		#include <asm/arch/board.h>
		#include <asm/arch/common.h>

		static u8 ams_delta_latch1_reg;
		static u16 ams_delta_latch2_reg;

		void ams_delta_latch1_write(u8 mask, u8 value)
		{
		ams_delta_latch1_reg &= ~mask;
		ams_delta_latch1_reg \|= value;
		(volatile __u8 ) AMS_DELTA_LATCH1_VIRT = ams_delta_latch1_reg;
		}

		void ams_delta_latch2_write(u16 mask, u16 value)
		{
		ams_delta_latch2_reg &= ~mask;
		ams_delta_latch2_reg \|= value;
		(volatile __u16 ) AMS_DELTA_LATCH2_VIRT = ams_delta_latch2_reg;
		}

		static void __init ams_delta_init_irq(void)
		{
		omap1_init_common_hw();
		omap_init_irq();
		omap_gpio_init();
		}

		static struct map_desc ams_delta_io_desc[] __initdata = {
		// AMS_DELTA_LATCH1
		{
		.virtual = AMS_DELTA_LATCH1_VIRT,
		.pfn = __phys_to_pfn(AMS_DELTA_LATCH1_PHYS),
		.length = 0x01000000,
		.type = MT_DEVICE
		},
		// AMS_DELTA_LATCH2
		{
		.virtual = AMS_DELTA_LATCH2_VIRT,
		.pfn = __phys_to_pfn(AMS_DELTA_LATCH2_PHYS),
		.length = 0x01000000,
		.type = MT_DEVICE
		},
		// AMS_DELTA_MODEM
		{
		.virtual = AMS_DELTA_MODEM_VIRT,
		.pfn = __phys_to_pfn(AMS_DELTA_MODEM_PHYS),
		.length = 0x01000000,
		.type = MT_DEVICE
		}
		};

		static struct omap_uart_config ams_delta_uart_config __initdata = {
		.enabled_uarts = 1,
		};

		static struct omap_board_config_kernel ams_delta_config[] = {
		{ OMAP_TAG_UART, &ams_delta_uart_config },
		};

		static void __init ams_delta_init(void)
		{
		iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));

		omap_board_config = ams_delta_config;
		omap_board_config_size = ARRAY_SIZE(ams_delta_config);
		omap_serial_init();

		/* Clear latch2 (NAND, LCD, modem enable) */
		ams_delta_latch2_write(~0, 0);
		}

		static void __init ams_delta_map_io(void)
		{
		omap1_map_common_io();
		}

		MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)")
		/* Maintainer: Jonathan McDowell <noodles@earth.li> */
		.phys_io = 0xfff00000,
		.io_pg_offst = ((0xfef00000) >> 18) & 0xfffc,
		.boot_params = 0x10000100,
		.map_io = ams_delta_map_io,
		.init_irq = ams_delta_init_irq,
		.init_machine = ams_delta_init,
		.timer = &omap_timer,
		MACHINE_END

		EXPORT_SYMBOL(ams_delta_latch1_write);
		EXPORT_SYMBOL(ams_delta_latch2_write);

arch/arm/mach-omap1/board-generic.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -88,7 +88,7 @@ static struct omap_board_config_kernel generic_config[] = {
		static void __init omap_generic_init(void)
		{
		#ifdef CONFIG_ARCH_OMAP15XX
		if (cpu_is_omap1510()) {
		if (cpu_is_omap15xx()) {
		generic_config[0].data = &generic1510_usb_config;
		}
		#endif

arch/arm/mach-omap1/board-h2.c

+186 −14

Original line number	Diff line number	Diff line
		@@ -24,7 +24,9 @@
		#include <linux/platform_device.h>
		#include <linux/delay.h>
		#include <linux/mtd/mtd.h>
		#include <linux/mtd/nand.h>
		#include <linux/mtd/partitions.h>
		#include <linux/input.h>

		#include <asm/hardware.h>
		#include <asm/mach-types.h>
		@@ -35,12 +37,55 @@
		#include <asm/arch/gpio.h>
		#include <asm/arch/mux.h>
		#include <asm/arch/tc.h>
		#include <asm/arch/irda.h>
		#include <asm/arch/usb.h>
		#include <asm/arch/keypad.h>
		#include <asm/arch/common.h>
		#include <asm/arch/mcbsp.h>
		#include <asm/arch/omap-alsa.h>

		extern int omap_gpio_init(void);

		static struct mtd_partition h2_partitions[] = {
		static int h2_keymap[] = {
		KEY(0, 0, KEY_LEFT),
		KEY(0, 1, KEY_RIGHT),
		KEY(0, 2, KEY_3),
		KEY(0, 3, KEY_F10),
		KEY(0, 4, KEY_F5),
		KEY(0, 5, KEY_9),
		KEY(1, 0, KEY_DOWN),
		KEY(1, 1, KEY_UP),
		KEY(1, 2, KEY_2),
		KEY(1, 3, KEY_F9),
		KEY(1, 4, KEY_F7),
		KEY(1, 5, KEY_0),
		KEY(2, 0, KEY_ENTER),
		KEY(2, 1, KEY_6),
		KEY(2, 2, KEY_1),
		KEY(2, 3, KEY_F2),
		KEY(2, 4, KEY_F6),
		KEY(2, 5, KEY_HOME),
		KEY(3, 0, KEY_8),
		KEY(3, 1, KEY_5),
		KEY(3, 2, KEY_F12),
		KEY(3, 3, KEY_F3),
		KEY(3, 4, KEY_F8),
		KEY(3, 5, KEY_END),
		KEY(4, 0, KEY_7),
		KEY(4, 1, KEY_4),
		KEY(4, 2, KEY_F11),
		KEY(4, 3, KEY_F1),
		KEY(4, 4, KEY_F4),
		KEY(4, 5, KEY_ESC),
		KEY(5, 0, KEY_F13),
		KEY(5, 1, KEY_F14),
		KEY(5, 2, KEY_F15),
		KEY(5, 3, KEY_F16),
		KEY(5, 4, KEY_SLEEP),
		0
		};

		static struct mtd_partition h2_nor_partitions[] = {
		/* bootloader (U-Boot, etc) in first sector */
		{
		.name = "bootloader",
		@@ -71,26 +116,26 @@ static struct mtd_partition h2_partitions[] = {
		}
		};

		static struct flash_platform_data h2_flash_data = {
		static struct flash_platform_data h2_nor_data = {
		.map_name = "cfi_probe",
		.width = 2,
		.parts = h2_partitions,
		.nr_parts = ARRAY_SIZE(h2_partitions),
		.parts = h2_nor_partitions,
		.nr_parts = ARRAY_SIZE(h2_nor_partitions),
		};

		static struct resource h2_flash_resource = {
		static struct resource h2_nor_resource = {
		/* This is on CS3, wherever it's mapped */
		.flags = IORESOURCE_MEM,
		};

		static struct platform_device h2_flash_device = {
		static struct platform_device h2_nor_device = {
		.name = "omapflash",
		.id = 0,
		.dev = {
		.platform_data = &h2_flash_data,
		.platform_data = &h2_nor_data,
		},
		.num_resources = 1,
		.resource = &h2_flash_resource,
		.resource = &h2_nor_resource,
		};

		static struct resource h2_smc91x_resources[] = {
		@@ -113,9 +158,119 @@ static struct platform_device h2_smc91x_device = {
		.resource = h2_smc91x_resources,
		};

		static struct resource h2_kp_resources[] = {
		[0] = {
		.start = INT_KEYBOARD,
		.end = INT_KEYBOARD,
		.flags = IORESOURCE_IRQ,
		},
		};

		static struct omap_kp_platform_data h2_kp_data = {
		.rows = 8,
		.cols = 8,
		.keymap = h2_keymap,
		.rep = 1,
		};

		static struct platform_device h2_kp_device = {
		.name = "omap-keypad",
		.id = -1,
		.dev = {
		.platform_data = &h2_kp_data,
		},
		.num_resources = ARRAY_SIZE(h2_kp_resources),
		.resource = h2_kp_resources,
		};

		#define H2_IRDA_FIRSEL_GPIO_PIN 17

		#if defined(CONFIG_OMAP_IR) \|\| defined(CONFIG_OMAP_IR_MODULE)
		static int h2_transceiver_mode(struct device *dev, int state)
		{
		if (state & IR_SIRMODE)
		omap_set_gpio_dataout(H2_IRDA_FIRSEL_GPIO_PIN, 0);
		else /* MIR/FIR */
		omap_set_gpio_dataout(H2_IRDA_FIRSEL_GPIO_PIN, 1);

		return 0;
		}
		#endif

		static struct omap_irda_config h2_irda_data = {
		.transceiver_cap = IR_SIRMODE \| IR_MIRMODE \| IR_FIRMODE,
		.rx_channel = OMAP_DMA_UART3_RX,
		.tx_channel = OMAP_DMA_UART3_TX,
		.dest_start = UART3_THR,
		.src_start = UART3_RHR,
		.tx_trigger = 0,
		.rx_trigger = 0,
		};

		static struct resource h2_irda_resources[] = {
		[0] = {
		.start = INT_UART3,
		.end = INT_UART3,
		.flags = IORESOURCE_IRQ,
		},
		};
		static struct platform_device h2_irda_device = {
		.name = "omapirda",
		.id = 0,
		.dev = {
		.platform_data = &h2_irda_data,
		},
		.num_resources = ARRAY_SIZE(h2_irda_resources),
		.resource = h2_irda_resources,
		};

		static struct platform_device h2_lcd_device = {
		.name = "lcd_h2",
		.id = -1,
		};

		static struct omap_mcbsp_reg_cfg mcbsp_regs = {
		.spcr2 = FREE \| FRST \| GRST \| XRST \| XINTM(3),
		.spcr1 = RINTM(3) \| RRST,
		.rcr2 = RPHASE \| RFRLEN2(OMAP_MCBSP_WORD_8) \|
		RWDLEN2(OMAP_MCBSP_WORD_16) \| RDATDLY(1),
		.rcr1 = RFRLEN1(OMAP_MCBSP_WORD_8) \| RWDLEN1(OMAP_MCBSP_WORD_16),
		.xcr2 = XPHASE \| XFRLEN2(OMAP_MCBSP_WORD_8) \|
		XWDLEN2(OMAP_MCBSP_WORD_16) \| XDATDLY(1) \| XFIG,
		.xcr1 = XFRLEN1(OMAP_MCBSP_WORD_8) \| XWDLEN1(OMAP_MCBSP_WORD_16),
		.srgr1 = FWID(15),
		.srgr2 = GSYNC \| CLKSP \| FSGM \| FPER(31),

		.pcr0 = CLKXM \| CLKRM \| FSXP \| FSRP \| CLKXP \| CLKRP,
		//.pcr0 = CLKXP \| CLKRP, /* mcbsp: slave */
		};

		static struct omap_alsa_codec_config alsa_config = {
		.name = "H2 TSC2101",
		.mcbsp_regs_alsa = &mcbsp_regs,
		.codec_configure_dev = NULL, // tsc2101_configure,
		.codec_set_samplerate = NULL, // tsc2101_set_samplerate,
		.codec_clock_setup = NULL, // tsc2101_clock_setup,
		.codec_clock_on = NULL, // tsc2101_clock_on,
		.codec_clock_off = NULL, // tsc2101_clock_off,
		.get_default_samplerate = NULL, // tsc2101_get_default_samplerate,
		};

		static struct platform_device h2_mcbsp1_device = {
		.name = "omap_alsa_mcbsp",
		.id = 1,
		.dev = {
		.platform_data = &alsa_config,
		},
		};

		static struct platform_device *h2_devices[] __initdata = {
		&h2_flash_device,
		&h2_nor_device,
		&h2_smc91x_device,
		&h2_irda_device,
		&h2_kp_device,
		&h2_lcd_device,
		&h2_mcbsp1_device,
		};

		static void __init h2_init_smc91x(void)
		@@ -164,7 +319,6 @@ static struct omap_uart_config h2_uart_config __initdata = {
		};

		static struct omap_lcd_config h2_lcd_config __initdata = {
		.panel_name = "h2",
		.ctrl_name = "internal",
		};

		@@ -177,16 +331,34 @@ static struct omap_board_config_kernel h2_config[] = {

		static void __init h2_init(void)
		{
		/* NOTE: revC boards support NAND-boot, which can put NOR on CS2B
		* and NAND (either 16bit or 8bit) on CS3.
		/* Here we assume the NOR boot config: NOR on CS3 (possibly swapped
		* to address 0 by a dip switch), NAND on CS2B. The NAND driver will
		* notice whether a NAND chip is enabled at probe time.
		*
		* FIXME revC boards (and H3) support NAND-boot, with a dip switch to
		* put NOR on CS2B and NAND (which on H2 may be 16bit) on CS3. Try
		* detecting that in code here, to avoid probing every possible flash
		* configuration...
		*/
		h2_flash_resource.end = h2_flash_resource.start = omap_cs3_phys();
		h2_flash_resource.end += SZ_32M - 1;
		h2_nor_resource.end = h2_nor_resource.start = omap_cs3_phys();
		h2_nor_resource.end += SZ_32M - 1;

		omap_cfg_reg(L3_1610_FLASH_CS2B_OE);
		omap_cfg_reg(M8_1610_FLASH_CS2B_WE);

		/* MMC: card detect and WP */
		// omap_cfg_reg(U19_ARMIO1); /* CD */
		omap_cfg_reg(BALLOUT_V8_ARMIO3); /* WP */

		/* Irda */
		#if defined(CONFIG_OMAP_IR) \|\| defined(CONFIG_OMAP_IR_MODULE)
		omap_writel(omap_readl(FUNC_MUX_CTRL_A) \| 7, FUNC_MUX_CTRL_A);
		if (!(omap_request_gpio(H2_IRDA_FIRSEL_GPIO_PIN))) {
		omap_set_gpio_direction(H2_IRDA_FIRSEL_GPIO_PIN, 0);
		h2_irda_data.transceiver_mode = h2_transceiver_mode;
		}
		#endif

		platform_add_devices(h2_devices, ARRAY_SIZE(h2_devices));
		omap_board_config = h2_config;
		omap_board_config_size = ARRAY_SIZE(h2_config);

arch/arm/mach-omap1/board-h3.c

+264 −13

Original line number	Diff line number	Diff line
		@@ -21,8 +21,11 @@
		#include <linux/kernel.h>
		#include <linux/platform_device.h>
		#include <linux/errno.h>
		#include <linux/workqueue.h>
		#include <linux/mtd/mtd.h>
		#include <linux/mtd/nand.h>
		#include <linux/mtd/partitions.h>
		#include <linux/input.h>

		#include <asm/setup.h>
		#include <asm/page.h>
		@@ -33,15 +36,59 @@
		#include <asm/mach/map.h>

		#include <asm/arch/gpio.h>
		#include <asm/arch/gpioexpander.h>
		#include <asm/arch/irqs.h>
		#include <asm/arch/mux.h>
		#include <asm/arch/tc.h>
		#include <asm/arch/irda.h>
		#include <asm/arch/usb.h>
		#include <asm/arch/keypad.h>
		#include <asm/arch/dma.h>
		#include <asm/arch/common.h>

		extern int omap_gpio_init(void);

		static struct mtd_partition h3_partitions[] = {
		static int h3_keymap[] = {
		KEY(0, 0, KEY_LEFT),
		KEY(0, 1, KEY_RIGHT),
		KEY(0, 2, KEY_3),
		KEY(0, 3, KEY_F10),
		KEY(0, 4, KEY_F5),
		KEY(0, 5, KEY_9),
		KEY(1, 0, KEY_DOWN),
		KEY(1, 1, KEY_UP),
		KEY(1, 2, KEY_2),
		KEY(1, 3, KEY_F9),
		KEY(1, 4, KEY_F7),
		KEY(1, 5, KEY_0),
		KEY(2, 0, KEY_ENTER),
		KEY(2, 1, KEY_6),
		KEY(2, 2, KEY_1),
		KEY(2, 3, KEY_F2),
		KEY(2, 4, KEY_F6),
		KEY(2, 5, KEY_HOME),
		KEY(3, 0, KEY_8),
		KEY(3, 1, KEY_5),
		KEY(3, 2, KEY_F12),
		KEY(3, 3, KEY_F3),
		KEY(3, 4, KEY_F8),
		KEY(3, 5, KEY_END),
		KEY(4, 0, KEY_7),
		KEY(4, 1, KEY_4),
		KEY(4, 2, KEY_F11),
		KEY(4, 3, KEY_F1),
		KEY(4, 4, KEY_F4),
		KEY(4, 5, KEY_ESC),
		KEY(5, 0, KEY_F13),
		KEY(5, 1, KEY_F14),
		KEY(5, 2, KEY_F15),
		KEY(5, 3, KEY_F16),
		KEY(5, 4, KEY_SLEEP),
		0
		};


		static struct mtd_partition nor_partitions[] = {
		/* bootloader (U-Boot, etc) in first sector */
		{
		.name = "bootloader",
		@@ -72,26 +119,80 @@ static struct mtd_partition h3_partitions[] = {
		}
		};

		static struct flash_platform_data h3_flash_data = {
		static struct flash_platform_data nor_data = {
		.map_name = "cfi_probe",
		.width = 2,
		.parts = h3_partitions,
		.nr_parts = ARRAY_SIZE(h3_partitions),
		.parts = nor_partitions,
		.nr_parts = ARRAY_SIZE(nor_partitions),
		};

		static struct resource h3_flash_resource = {
		static struct resource nor_resource = {
		/* This is on CS3, wherever it's mapped */
		.flags = IORESOURCE_MEM,
		};

		static struct platform_device flash_device = {
		static struct platform_device nor_device = {
		.name = "omapflash",
		.id = 0,
		.dev = {
		.platform_data = &h3_flash_data,
		.platform_data = &nor_data,
		},
		.num_resources = 1,
		.resource = &nor_resource,
		};

		static struct mtd_partition nand_partitions[] = {
		#if 0
		/* REVISIT: enable these partitions if you make NAND BOOT work */
		{
		.name = "xloader",
		.offset = 0,
		.size = 64 * 1024,
		.mask_flags = MTD_WRITEABLE, /* force read-only */
		},
		{
		.name = "bootloader",
		.offset = MTDPART_OFS_APPEND,
		.size = 256 * 1024,
		.mask_flags = MTD_WRITEABLE, /* force read-only */
		},
		{
		.name = "params",
		.offset = MTDPART_OFS_APPEND,
		.size = 192 * 1024,
		},
		{
		.name = "kernel",
		.offset = MTDPART_OFS_APPEND,
		.size = 2 * SZ_1M,
		},
		#endif
		{
		.name = "filesystem",
		.size = MTDPART_SIZ_FULL,
		.offset = MTDPART_OFS_APPEND,
		},
		};

		/* dip switches control NAND chip access: 8 bit, 16 bit, or neither */
		static struct nand_platform_data nand_data = {
		.options = NAND_SAMSUNG_LP_OPTIONS,
		.parts = nand_partitions,
		.nr_parts = ARRAY_SIZE(nand_partitions),
		};

		static struct resource nand_resource = {
		.flags = IORESOURCE_MEM,
		};

		static struct platform_device nand_device = {
		.name = "omapnand",
		.id = 0,
		.dev = {
		.platform_data = &nand_data,
		},
		.num_resources = 1,
		.resource = &h3_flash_resource,
		.resource = &nand_resource,
		};

		static struct resource smc91x_resources[] = {
		@@ -138,10 +239,136 @@ static struct platform_device intlat_device = {
		.resource = intlat_resources,
		};

		static struct resource h3_kp_resources[] = {
		[0] = {
		.start = INT_KEYBOARD,
		.end = INT_KEYBOARD,
		.flags = IORESOURCE_IRQ,
		},
		};

		static struct omap_kp_platform_data h3_kp_data = {
		.rows = 8,
		.cols = 8,
		.keymap = h3_keymap,
		.rep = 1,
		};

		static struct platform_device h3_kp_device = {
		.name = "omap-keypad",
		.id = -1,
		.dev = {
		.platform_data = &h3_kp_data,
		},
		.num_resources = ARRAY_SIZE(h3_kp_resources),
		.resource = h3_kp_resources,
		};


		/* Select between the IrDA and aGPS module
		*/
		static int h3_select_irda(struct device *dev, int state)
		{
		unsigned char expa;
		int err = 0;

		if ((err = read_gpio_expa(&expa, 0x26))) {
		printk(KERN_ERR "Error reading from I/O EXPANDER \n");
		return err;
		}

		/* 'P6' enable/disable IRDA_TX and IRDA_RX */
		if (state & IR_SEL) { /* IrDA */
		if ((err = write_gpio_expa(expa \| 0x40, 0x26))) {
		printk(KERN_ERR "Error writing to I/O EXPANDER \n");
		return err;
		}
		} else {
		if ((err = write_gpio_expa(expa & ~0x40, 0x26))) {
		printk(KERN_ERR "Error writing to I/O EXPANDER \n");
		return err;
		}
		}
		return err;
		}

		static void set_trans_mode(void *data)
		{
		int *mode = data;
		unsigned char expa;
		int err = 0;

		if ((err = read_gpio_expa(&expa, 0x27)) != 0) {
		printk(KERN_ERR "Error reading from I/O expander\n");
		}

		expa &= ~0x03;

		if (*mode & IR_SIRMODE) {
		expa \|= 0x01;
		} else { /* MIR/FIR */
		expa \|= 0x03;
		}

		if ((err = write_gpio_expa(expa, 0x27)) != 0) {
		printk(KERN_ERR "Error writing to I/O expander\n");
		}
		}

		static int h3_transceiver_mode(struct device *dev, int mode)
		{
		struct omap_irda_config *irda_config = dev->platform_data;

		cancel_delayed_work(&irda_config->gpio_expa);
		PREPARE_WORK(&irda_config->gpio_expa, set_trans_mode, &mode);
		schedule_work(&irda_config->gpio_expa);

		return 0;
		}

		static struct omap_irda_config h3_irda_data = {
		.transceiver_cap = IR_SIRMODE \| IR_MIRMODE \| IR_FIRMODE,
		.transceiver_mode = h3_transceiver_mode,
		.select_irda = h3_select_irda,
		.rx_channel = OMAP_DMA_UART3_RX,
		.tx_channel = OMAP_DMA_UART3_TX,
		.dest_start = UART3_THR,
		.src_start = UART3_RHR,
		.tx_trigger = 0,
		.rx_trigger = 0,
		};

		static struct resource h3_irda_resources[] = {
		[0] = {
		.start = INT_UART3,
		.end = INT_UART3,
		.flags = IORESOURCE_IRQ,
		},
		};

		static struct platform_device h3_irda_device = {
		.name = "omapirda",
		.id = 0,
		.dev = {
		.platform_data = &h3_irda_data,
		},
		.num_resources = ARRAY_SIZE(h3_irda_resources),
		.resource = h3_irda_resources,
		};

		static struct platform_device h3_lcd_device = {
		.name = "lcd_h3",
		.id = -1,
		};

		static struct platform_device *devices[] __initdata = {
		&flash_device,
		&nor_device,
		&nand_device,
		&smc91x_device,
		&intlat_device,
		&h3_irda_device,
		&h3_kp_device,
		&h3_lcd_device,
		};

		static struct omap_usb_config h3_usb_config __initdata = {
		@@ -171,7 +398,6 @@ static struct omap_uart_config h3_uart_config __initdata = {
		};

		static struct omap_lcd_config h3_lcd_config __initdata = {
		.panel_name = "h3",
		.ctrl_name = "internal",
		};

		@@ -182,11 +408,36 @@ static struct omap_board_config_kernel h3_config[] = {
		{ OMAP_TAG_LCD, &h3_lcd_config },
		};

		#define H3_NAND_RB_GPIO_PIN 10

		static int nand_dev_ready(struct nand_platform_data *data)
		{
		return omap_get_gpio_datain(H3_NAND_RB_GPIO_PIN);
		}

		static void __init h3_init(void)
		{
		h3_flash_resource.end = h3_flash_resource.start = omap_cs3_phys();
		h3_flash_resource.end += OMAP_CS3_SIZE - 1;
		(void) platform_add_devices(devices, ARRAY_SIZE(devices));
		/* Here we assume the NOR boot config: NOR on CS3 (possibly swapped
		* to address 0 by a dip switch), NAND on CS2B. The NAND driver will
		* notice whether a NAND chip is enabled at probe time.
		*
		* H3 support NAND-boot, with a dip switch to put NOR on CS2B and NAND
		* (which on H2 may be 16bit) on CS3. Try detecting that in code here,
		* to avoid probing every possible flash configuration...
		*/
		nor_resource.end = nor_resource.start = omap_cs3_phys();
		nor_resource.end += SZ_32M - 1;

		nand_resource.end = nand_resource.start = OMAP_CS2B_PHYS;
		nand_resource.end += SZ_4K - 1;
		if (!(omap_request_gpio(H3_NAND_RB_GPIO_PIN)))
		nand_data.dev_ready = nand_dev_ready;

		/* GPIO10 Func_MUX_CTRL reg bit 29:27, Configure V2 to mode1 as GPIO */
		/* GPIO10 pullup/down register, Enable pullup on GPIO10 */
		omap_cfg_reg(V2_1710_GPIO10);

		platform_add_devices(devices, ARRAY_SIZE(devices));
		omap_board_config = h3_config;
		omap_board_config_size = ARRAY_SIZE(h3_config);
		omap_serial_init();