ARM: davinci: remove tnetv107x support (9d6eccb9) · Commits · 戴 / test

arch/arm/Kconfig.debug

+1 −12

Original line number	Original line	Diff line number	Diff line
	@@ -176,15 +176,6 @@ choice
	Say Y here if you want the debug print routines to direct		Say Y here if you want the debug print routines to direct
	their output to UART0 serial port on DaVinci DMx devices.		their output to UART0 serial port on DaVinci DMx devices.

	config DEBUG_DAVINCI_TNETV107X_UART1
	bool "Kernel low-level debugging on DaVinci TNETV107x using UART1"
	depends on ARCH_DAVINCI_TNETV107X
	select DEBUG_UART_8250
	help
	Say Y here if you want the debug print routines to direct
	their output to UART1 serial port on DaVinci TNETV107X
	devices.

	config DEBUG_ZYNQ_UART0		config DEBUG_ZYNQ_UART0
	bool "Kernel low-level debugging on Xilinx Zynq using UART0"		bool "Kernel low-level debugging on Xilinx Zynq using UART0"
	depends on ARCH_ZYNQ		depends on ARCH_ZYNQ
	@@ -1019,7 +1010,6 @@ config DEBUG_UART_PHYS
	default 0x02530c00 if DEBUG_KEYSTONE_UART0		default 0x02530c00 if DEBUG_KEYSTONE_UART0
	default 0x02531000 if DEBUG_KEYSTONE_UART1		default 0x02531000 if DEBUG_KEYSTONE_UART1
	default 0x03010fe0 if ARCH_RPC		default 0x03010fe0 if ARCH_RPC
	default 0x08108300 if DEBUG_DAVINCI_TNETV107X_UART1
	default 0x10009000 if DEBUG_REALVIEW_STD_PORT \|\| DEBUG_CNS3XXX \|\| \		default 0x10009000 if DEBUG_REALVIEW_STD_PORT \|\| DEBUG_CNS3XXX \|\| \
	DEBUG_VEXPRESS_UART0_CA9		DEBUG_VEXPRESS_UART0_CA9
	default 0x1010c000 if DEBUG_REALVIEW_PB1176_PORT		default 0x1010c000 if DEBUG_REALVIEW_PB1176_PORT
	@@ -1117,7 +1107,6 @@ config DEBUG_UART_VIRT
	default 0xfed12000 if ARCH_KIRKWOOD		default 0xfed12000 if ARCH_KIRKWOOD
	default 0xfedc0000 if ARCH_EP93XX		default 0xfedc0000 if ARCH_EP93XX
	default 0xfee003f8 if FOOTBRIDGE		default 0xfee003f8 if FOOTBRIDGE
	default 0xfee08300 if DEBUG_DAVINCI_TNETV107X_UART1
	default 0xfee20000 if DEBUG_NSPIRE_CLASSIC_UART \|\| DEBUG_NSPIRE_CX_UART		default 0xfee20000 if DEBUG_NSPIRE_CLASSIC_UART \|\| DEBUG_NSPIRE_CX_UART
	default 0xfef36000 if DEBUG_HIGHBANK_UART		default 0xfef36000 if DEBUG_HIGHBANK_UART
	default 0xfee82340 if ARCH_IOP13XX		default 0xfee82340 if ARCH_IOP13XX
	@@ -1142,7 +1131,7 @@ config DEBUG_UART_8250_WORD
	default y if DEBUG_PICOXCELL_UART \|\| DEBUG_SOCFPGA_UART \|\| \		default y if DEBUG_PICOXCELL_UART \|\| DEBUG_SOCFPGA_UART \|\| \
	ARCH_KEYSTONE \|\| \		ARCH_KEYSTONE \|\| \
	DEBUG_DAVINCI_DMx_UART0 \|\| DEBUG_DAVINCI_DA8XX_UART1 \|\| \		DEBUG_DAVINCI_DMx_UART0 \|\| DEBUG_DAVINCI_DA8XX_UART1 \|\| \
	DEBUG_DAVINCI_DA8XX_UART2 \|\| DEBUG_DAVINCI_TNETV107X_UART1 \|\| \		DEBUG_DAVINCI_DA8XX_UART2 \|\| \
	DEBUG_BCM_KONA_UART		DEBUG_BCM_KONA_UART

	config DEBUG_UART_8250_FLOW_CONTROL		config DEBUG_UART_8250_FLOW_CONTROL

arch/arm/mach-davinci/Kconfig

+0 −12

Original line number	Original line	Diff line number	Diff line
	@@ -51,11 +51,6 @@ config ARCH_DAVINCI_DM365
	select AINTC		select AINTC
	select ARCH_DAVINCI_DMx		select ARCH_DAVINCI_DMx

	config ARCH_DAVINCI_TNETV107X
	bool "TNETV107X based system"
	select CPU_V6
	select CP_INTC

	comment "DaVinci Board Type"		comment "DaVinci Board Type"

	config MACH_DA8XX_DT		config MACH_DA8XX_DT
	@@ -220,13 +215,6 @@ config GPIO_PCA953X
	config KEYBOARD_GPIO_POLLED		config KEYBOARD_GPIO_POLLED
	default MACH_DAVINCI_DA850_EVM		default MACH_DAVINCI_DA850_EVM

	config MACH_TNETV107X
	bool "TI TNETV107X Reference Platform"
	default ARCH_DAVINCI_TNETV107X
	depends on ARCH_DAVINCI_TNETV107X
	help
	Say Y here to select the TI TNETV107X Evaluation Module.

	config MACH_MITYOMAPL138		config MACH_MITYOMAPL138
	bool "Critical Link MityDSP-L138/MityARM-1808 SoM"		bool "Critical Link MityDSP-L138/MityARM-1808 SoM"
	depends on ARCH_DAVINCI_DA850		depends on ARCH_DAVINCI_DA850

arch/arm/mach-davinci/Makefile

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -16,7 +16,6 @@ obj-$(CONFIG_ARCH_DAVINCI_DM646x) += dm646x.o devices.o
	obj-$(CONFIG_ARCH_DAVINCI_DM365) += dm365.o devices.o		obj-$(CONFIG_ARCH_DAVINCI_DM365) += dm365.o devices.o
	obj-$(CONFIG_ARCH_DAVINCI_DA830) += da830.o devices-da8xx.o		obj-$(CONFIG_ARCH_DAVINCI_DA830) += da830.o devices-da8xx.o
	obj-$(CONFIG_ARCH_DAVINCI_DA850) += da850.o devices-da8xx.o		obj-$(CONFIG_ARCH_DAVINCI_DA850) += da850.o devices-da8xx.o
	obj-$(CONFIG_ARCH_DAVINCI_TNETV107X) += tnetv107x.o devices-tnetv107x.o

	obj-$(CONFIG_AINTC) += irq.o		obj-$(CONFIG_AINTC) += irq.o
	obj-$(CONFIG_CP_INTC) += cp_intc.o		obj-$(CONFIG_CP_INTC) += cp_intc.o
	@@ -32,7 +31,6 @@ obj-$(CONFIG_MACH_DAVINCI_DM6467_EVM) += board-dm646x-evm.o cdce949.o
	obj-$(CONFIG_MACH_DAVINCI_DM365_EVM) += board-dm365-evm.o		obj-$(CONFIG_MACH_DAVINCI_DM365_EVM) += board-dm365-evm.o
	obj-$(CONFIG_MACH_DAVINCI_DA830_EVM) += board-da830-evm.o		obj-$(CONFIG_MACH_DAVINCI_DA830_EVM) += board-da830-evm.o
	obj-$(CONFIG_MACH_DAVINCI_DA850_EVM) += board-da850-evm.o		obj-$(CONFIG_MACH_DAVINCI_DA850_EVM) += board-da850-evm.o
	obj-$(CONFIG_MACH_TNETV107X) += board-tnetv107x-evm.o
	obj-$(CONFIG_MACH_MITYOMAPL138) += board-mityomapl138.o		obj-$(CONFIG_MACH_MITYOMAPL138) += board-mityomapl138.o
	obj-$(CONFIG_MACH_OMAPL138_HAWKBOARD) += board-omapl138-hawk.o		obj-$(CONFIG_MACH_OMAPL138_HAWKBOARD) += board-omapl138-hawk.o

arch/arm/mach-davinci/board-tnetv107x-evm.c

deleted100644 → 0

+0 −287

Original line number	Original line	Diff line number	Diff line
	/*
	* Texas Instruments TNETV107X EVM Board Support
	*
	* Copyright (C) 2010 Texas Instruments
	*
	* 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.
	*
	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	* kind, whether express or implied; without even the implied warranty
	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/
	#include <linux/kernel.h>
	#include <linux/init.h>
	#include <linux/console.h>
	#include <linux/dma-mapping.h>
	#include <linux/interrupt.h>
	#include <linux/gpio.h>
	#include <linux/delay.h>
	#include <linux/platform_device.h>
	#include <linux/ratelimit.h>
	#include <linux/mtd/mtd.h>
	#include <linux/mtd/partitions.h>
	#include <linux/input.h>
	#include <linux/input/matrix_keypad.h>
	#include <linux/spi/spi.h>
	#include <linux/platform_data/edma.h>

	#include <asm/mach/arch.h>
	#include <asm/mach-types.h>

	#include <mach/irqs.h>
	#include <mach/mux.h>
	#include <mach/cp_intc.h>
	#include <mach/tnetv107x.h>

	#define EVM_MMC_WP_GPIO 21
	#define EVM_MMC_CD_GPIO 24
	#define EVM_SPI_CS_GPIO 54

	static int initialize_gpio(int gpio, char *desc)
	{
	int ret;

	ret = gpio_request(gpio, desc);
	if (ret < 0) {
	pr_err_ratelimited("cannot open %s gpio\n", desc);
	return -ENOSYS;
	}
	gpio_direction_input(gpio);
	return gpio;
	}

	static int mmc_get_cd(int index)
	{
	static int gpio;

	if (!gpio)
	gpio = initialize_gpio(EVM_MMC_CD_GPIO, "mmc card detect");

	if (gpio < 0)
	return gpio;

	return gpio_get_value(gpio) ? 0 : 1;
	}

	static int mmc_get_ro(int index)
	{
	static int gpio;

	if (!gpio)
	gpio = initialize_gpio(EVM_MMC_WP_GPIO, "mmc write protect");

	if (gpio < 0)
	return gpio;

	return gpio_get_value(gpio) ? 1 : 0;
	}

	static struct davinci_mmc_config mmc_config = {
	.get_cd = mmc_get_cd,
	.get_ro = mmc_get_ro,
	.wires = 4,
	.max_freq = 50000000,
	.caps = MMC_CAP_MMC_HIGHSPEED \| MMC_CAP_SD_HIGHSPEED,
	};

	static const short sdio1_pins[] __initconst = {
	TNETV107X_SDIO1_CLK_1, TNETV107X_SDIO1_CMD_1,
	TNETV107X_SDIO1_DATA0_1, TNETV107X_SDIO1_DATA1_1,
	TNETV107X_SDIO1_DATA2_1, TNETV107X_SDIO1_DATA3_1,
	TNETV107X_GPIO21, TNETV107X_GPIO24,
	-1
	};

	static const short uart1_pins[] __initconst = {
	TNETV107X_UART1_RD, TNETV107X_UART1_TD,
	-1
	};

	static const short ssp_pins[] __initconst = {
	TNETV107X_SSP0_0, TNETV107X_SSP0_1, TNETV107X_SSP0_2,
	TNETV107X_SSP1_0, TNETV107X_SSP1_1, TNETV107X_SSP1_2,
	TNETV107X_SSP1_3, -1
	};

	static struct mtd_partition nand_partitions[] = {
	/* bootloader (U-Boot, etc) in first 12 sectors */
	{
	.name = "bootloader",
	.offset = 0,
	.size = (12*SZ_128K),
	.mask_flags = MTD_WRITEABLE, /* force read-only */
	},
	/* bootloader params in the next sector */
	{
	.name = "params",
	.offset = MTDPART_OFS_NXTBLK,
	.size = SZ_128K,
	.mask_flags = MTD_WRITEABLE, /* force read-only */
	},
	/* kernel */
	{
	.name = "kernel",
	.offset = MTDPART_OFS_NXTBLK,
	.size = SZ_4M,
	.mask_flags = 0,
	},
	/* file system */
	{
	.name = "filesystem",
	.offset = MTDPART_OFS_NXTBLK,
	.size = MTDPART_SIZ_FULL,
	.mask_flags = 0,
	}
	};

	static struct davinci_nand_pdata nand_config = {
	.mask_cle = 0x4000,
	.mask_ale = 0x2000,
	.parts = nand_partitions,
	.nr_parts = ARRAY_SIZE(nand_partitions),
	.ecc_mode = NAND_ECC_HW,
	.bbt_options = NAND_BBT_USE_FLASH,
	.ecc_bits = 1,
	};

	static struct davinci_uart_config serial_config __initconst = {
	.enabled_uarts = BIT(1),
	};

	static const uint32_t keymap[] = {
	KEY(0, 0, KEY_NUMERIC_1),
	KEY(0, 1, KEY_NUMERIC_2),
	KEY(0, 2, KEY_NUMERIC_3),
	KEY(0, 3, KEY_FN_F1),
	KEY(0, 4, KEY_MENU),

	KEY(1, 0, KEY_NUMERIC_4),
	KEY(1, 1, KEY_NUMERIC_5),
	KEY(1, 2, KEY_NUMERIC_6),
	KEY(1, 3, KEY_UP),
	KEY(1, 4, KEY_FN_F2),

	KEY(2, 0, KEY_NUMERIC_7),
	KEY(2, 1, KEY_NUMERIC_8),
	KEY(2, 2, KEY_NUMERIC_9),
	KEY(2, 3, KEY_LEFT),
	KEY(2, 4, KEY_ENTER),

	KEY(3, 0, KEY_NUMERIC_STAR),
	KEY(3, 1, KEY_NUMERIC_0),
	KEY(3, 2, KEY_NUMERIC_POUND),
	KEY(3, 3, KEY_DOWN),
	KEY(3, 4, KEY_RIGHT),

	KEY(4, 0, KEY_FN_F3),
	KEY(4, 1, KEY_FN_F4),
	KEY(4, 2, KEY_MUTE),
	KEY(4, 3, KEY_HOME),
	KEY(4, 4, KEY_BACK),

	KEY(5, 0, KEY_VOLUMEDOWN),
	KEY(5, 1, KEY_VOLUMEUP),
	KEY(5, 2, KEY_F1),
	KEY(5, 3, KEY_F2),
	KEY(5, 4, KEY_F3),
	};

	static const struct matrix_keymap_data keymap_data = {
	.keymap = keymap,
	.keymap_size = ARRAY_SIZE(keymap),
	};

	static struct matrix_keypad_platform_data keypad_config = {
	.keymap_data = &keymap_data,
	.num_row_gpios = 6,
	.num_col_gpios = 5,
	.debounce_ms = 0, /* minimum */
	.active_low = 0, /* pull up realization */
	.no_autorepeat = 0,
	};

	static void spi_select_device(int cs)
	{
	static int gpio;

	if (!gpio) {
	int ret;
	ret = gpio_request(EVM_SPI_CS_GPIO, "spi chipsel");
	if (ret < 0) {
	pr_err("cannot open spi chipsel gpio\n");
	gpio = -ENOSYS;
	return;
	} else {
	gpio = EVM_SPI_CS_GPIO;
	gpio_direction_output(gpio, 0);
	}
	}

	if (gpio < 0)
	return;

	return gpio_set_value(gpio, cs ? 1 : 0);
	}

	static struct ti_ssp_spi_data spi_master_data = {
	.num_cs = 2,
	.select = spi_select_device,
	.iosel = SSP_PIN_SEL(0, SSP_CLOCK) \| SSP_PIN_SEL(1, SSP_DATA) \|
	SSP_PIN_SEL(2, SSP_CHIPSEL) \| SSP_PIN_SEL(3, SSP_IN) \|
	SSP_INPUT_SEL(3),
	};

	static struct ti_ssp_data ssp_config = {
	.out_clock = 250 * 1000,
	.dev_data = {
	[1] = {
	.dev_name = "ti-ssp-spi",
	.pdata = &spi_master_data,
	.pdata_size = sizeof(spi_master_data),
	},
	},
	};

	static struct tnetv107x_device_info evm_device_info __initconst = {
	.serial_config = &serial_config,
	.mmc_config[1] = &mmc_config, /* controller 1 */
	.nand_config[0] = &nand_config, /* chip select 0 */
	.keypad_config = &keypad_config,
	.ssp_config = &ssp_config,
	};

	static struct spi_board_info spi_info[] __initconst = {
	};

	static __init void tnetv107x_evm_board_init(void)
	{
	davinci_cfg_reg_list(sdio1_pins);
	davinci_cfg_reg_list(uart1_pins);
	davinci_cfg_reg_list(ssp_pins);

	tnetv107x_devices_init(&evm_device_info);

	spi_register_board_info(spi_info, ARRAY_SIZE(spi_info));
	}

	#ifdef CONFIG_SERIAL_8250_CONSOLE
	static int __init tnetv107x_evm_console_init(void)
	{
	return add_preferred_console("ttyS", 0, "115200");
	}
	console_initcall(tnetv107x_evm_console_init);
	#endif

	MACHINE_START(TNETV107X, "TNETV107X EVM")
	.atag_offset = 0x100,
	.map_io = tnetv107x_init,
	.init_irq = cp_intc_init,
	.init_time = davinci_timer_init,
	.init_machine = tnetv107x_evm_board_init,
	.init_late = davinci_init_late,
	.dma_zone_size = SZ_128M,
	.restart = tnetv107x_restart,
	MACHINE_END

arch/arm/mach-davinci/devices-tnetv107x.c

deleted100644 → 0

+0 −434

Original line number	Original line	Diff line number	Diff line
	/*
	* Texas Instruments TNETV107X SoC devices
	*
	* Copyright (C) 2010 Texas Instruments
	*
	* 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.
	*
	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	* kind, whether express or implied; without even the implied warranty
	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/
	#include <linux/kernel.h>
	#include <linux/init.h>
	#include <linux/platform_device.h>
	#include <linux/dma-mapping.h>
	#include <linux/clk.h>
	#include <linux/slab.h>
	#include <linux/platform_data/edma.h>

	#include <mach/common.h>
	#include <mach/irqs.h>
	#include <mach/tnetv107x.h>

	#include "clock.h"

	/* Base addresses for on-chip devices */
	#define TNETV107X_TPCC_BASE 0x01c00000
	#define TNETV107X_TPTC0_BASE 0x01c10000
	#define TNETV107X_TPTC1_BASE 0x01c10400
	#define TNETV107X_WDOG_BASE 0x08086700
	#define TNETV107X_TSC_BASE 0x08088500
	#define TNETV107X_SDIO0_BASE 0x08088700
	#define TNETV107X_SDIO1_BASE 0x08088800
	#define TNETV107X_KEYPAD_BASE 0x08088a00
	#define TNETV107X_SSP_BASE 0x08088c00
	#define TNETV107X_ASYNC_EMIF_CNTRL_BASE 0x08200000
	#define TNETV107X_ASYNC_EMIF_DATA_CE0_BASE 0x30000000
	#define TNETV107X_ASYNC_EMIF_DATA_CE1_BASE 0x40000000
	#define TNETV107X_ASYNC_EMIF_DATA_CE2_BASE 0x44000000
	#define TNETV107X_ASYNC_EMIF_DATA_CE3_BASE 0x48000000

	/* TNETV107X specific EDMA3 information */
	#define EDMA_TNETV107X_NUM_DMACH 64
	#define EDMA_TNETV107X_NUM_TCC 64
	#define EDMA_TNETV107X_NUM_PARAMENTRY 128
	#define EDMA_TNETV107X_NUM_EVQUE 2
	#define EDMA_TNETV107X_NUM_TC 2
	#define EDMA_TNETV107X_CHMAP_EXIST 0
	#define EDMA_TNETV107X_NUM_REGIONS 4
	#define TNETV107X_DMACH2EVENT_MAP0 0x3C0CE000u
	#define TNETV107X_DMACH2EVENT_MAP1 0x000FFFFFu

	#define TNETV107X_DMACH_SDIO0_RX 26
	#define TNETV107X_DMACH_SDIO0_TX 27
	#define TNETV107X_DMACH_SDIO1_RX 28
	#define TNETV107X_DMACH_SDIO1_TX 29

	static s8 edma_tc_mapping[][2] = {
	/* event queue no TC no */
	{ 0, 0 },
	{ 1, 1 },
	{ -1, -1 }
	};

	static s8 edma_priority_mapping[][2] = {
	/* event queue no Prio */
	{ 0, 3 },
	{ 1, 7 },
	{ -1, -1 }
	};

	static struct edma_soc_info edma_cc0_info = {
	.n_channel = EDMA_TNETV107X_NUM_DMACH,
	.n_region = EDMA_TNETV107X_NUM_REGIONS,
	.n_slot = EDMA_TNETV107X_NUM_PARAMENTRY,
	.n_tc = EDMA_TNETV107X_NUM_TC,
	.n_cc = 1,
	.queue_tc_mapping = edma_tc_mapping,
	.queue_priority_mapping = edma_priority_mapping,
	.default_queue = EVENTQ_1,
	};

	static struct edma_soc_info *tnetv107x_edma_info[EDMA_MAX_CC] = {
	&edma_cc0_info,
	};

	static struct resource edma_resources[] = {
	{
	.name = "edma_cc0",
	.start = TNETV107X_TPCC_BASE,
	.end = TNETV107X_TPCC_BASE + SZ_32K - 1,
	.flags = IORESOURCE_MEM,
	},
	{
	.name = "edma_tc0",
	.start = TNETV107X_TPTC0_BASE,
	.end = TNETV107X_TPTC0_BASE + SZ_1K - 1,
	.flags = IORESOURCE_MEM,
	},
	{
	.name = "edma_tc1",
	.start = TNETV107X_TPTC1_BASE,
	.end = TNETV107X_TPTC1_BASE + SZ_1K - 1,
	.flags = IORESOURCE_MEM,
	},
	{
	.name = "edma0",
	.start = IRQ_TNETV107X_TPCC,
	.flags = IORESOURCE_IRQ,
	},
	{
	.name = "edma0_err",
	.start = IRQ_TNETV107X_TPCC_ERR,
	.flags = IORESOURCE_IRQ,
	},
	};

	static struct platform_device edma_device = {
	.name = "edma",
	.id = -1,
	.num_resources = ARRAY_SIZE(edma_resources),
	.resource = edma_resources,
	.dev.platform_data = tnetv107x_edma_info,
	};

	static struct plat_serial8250_port serial0_platform_data[] = {
	{
	.mapbase = TNETV107X_UART0_BASE,
	.irq = IRQ_TNETV107X_UART0,
	.flags = UPF_BOOT_AUTOCONF \| UPF_SKIP_TEST \|
	UPF_FIXED_TYPE \| UPF_IOREMAP,
	.type = PORT_AR7,
	.iotype = UPIO_MEM32,
	.regshift = 2,
	},
	{
	.flags = 0,
	}
	};
	static struct plat_serial8250_port serial1_platform_data[] = {
	{
	.mapbase = TNETV107X_UART1_BASE,
	.irq = IRQ_TNETV107X_UART1,
	.flags = UPF_BOOT_AUTOCONF \| UPF_SKIP_TEST \|
	UPF_FIXED_TYPE \| UPF_IOREMAP,
	.type = PORT_AR7,
	.iotype = UPIO_MEM32,
	.regshift = 2,
	},
	{
	.flags = 0,
	}
	};
	static struct plat_serial8250_port serial2_platform_data[] = {
	{
	.mapbase = TNETV107X_UART2_BASE,
	.irq = IRQ_TNETV107X_UART2,
	.flags = UPF_BOOT_AUTOCONF \| UPF_SKIP_TEST \|
	UPF_FIXED_TYPE \| UPF_IOREMAP,
	.type = PORT_AR7,
	.iotype = UPIO_MEM32,
	.regshift = 2,
	},
	{
	.flags = 0,
	}
	};


	struct platform_device tnetv107x_serial_device[] = {
	{
	.name = "serial8250",
	.id = PLAT8250_DEV_PLATFORM,
	.dev.platform_data = serial0_platform_data,
	},
	{
	.name = "serial8250",
	.id = PLAT8250_DEV_PLATFORM1,
	.dev.platform_data = serial1_platform_data,
	},
	{
	.name = "serial8250",
	.id = PLAT8250_DEV_PLATFORM2,
	.dev.platform_data = serial2_platform_data,
	},
	{
	}
	};

	static struct resource mmc0_resources[] = {
	{ /* Memory mapped registers */
	.start = TNETV107X_SDIO0_BASE,
	.end = TNETV107X_SDIO0_BASE + 0x0ff,
	.flags = IORESOURCE_MEM
	},
	{ /* MMC interrupt */
	.start = IRQ_TNETV107X_MMC0,
	.flags = IORESOURCE_IRQ
	},
	{ /* SDIO interrupt */
	.start = IRQ_TNETV107X_SDIO0,
	.flags = IORESOURCE_IRQ
	},
	{ /* DMA RX */
	.start = EDMA_CTLR_CHAN(0, TNETV107X_DMACH_SDIO0_RX),
	.flags = IORESOURCE_DMA
	},
	{ /* DMA TX */
	.start = EDMA_CTLR_CHAN(0, TNETV107X_DMACH_SDIO0_TX),
	.flags = IORESOURCE_DMA
	},
	};

	static struct resource mmc1_resources[] = {
	{ /* Memory mapped registers */
	.start = TNETV107X_SDIO1_BASE,
	.end = TNETV107X_SDIO1_BASE + 0x0ff,
	.flags = IORESOURCE_MEM
	},
	{ /* MMC interrupt */
	.start = IRQ_TNETV107X_MMC1,
	.flags = IORESOURCE_IRQ
	},
	{ /* SDIO interrupt */
	.start = IRQ_TNETV107X_SDIO1,
	.flags = IORESOURCE_IRQ
	},
	{ /* DMA RX */
	.start = EDMA_CTLR_CHAN(0, TNETV107X_DMACH_SDIO1_RX),
	.flags = IORESOURCE_DMA
	},
	{ /* DMA TX */
	.start = EDMA_CTLR_CHAN(0, TNETV107X_DMACH_SDIO1_TX),
	.flags = IORESOURCE_DMA
	},
	};

	static u64 mmc0_dma_mask = DMA_BIT_MASK(32);
	static u64 mmc1_dma_mask = DMA_BIT_MASK(32);

	static struct platform_device mmc_devices[2] = {
	{
	.name = "dm6441-mmc",
	.id = 0,
	.dev = {
	.dma_mask = &mmc0_dma_mask,
	.coherent_dma_mask = DMA_BIT_MASK(32),
	},
	.num_resources = ARRAY_SIZE(mmc0_resources),
	.resource = mmc0_resources
	},
	{
	.name = "dm6441-mmc",
	.id = 1,
	.dev = {
	.dma_mask = &mmc1_dma_mask,
	.coherent_dma_mask = DMA_BIT_MASK(32),
	},
	.num_resources = ARRAY_SIZE(mmc1_resources),
	.resource = mmc1_resources
	},
	};

	static const u32 emif_windows[] = {
	TNETV107X_ASYNC_EMIF_DATA_CE0_BASE, TNETV107X_ASYNC_EMIF_DATA_CE1_BASE,
	TNETV107X_ASYNC_EMIF_DATA_CE2_BASE, TNETV107X_ASYNC_EMIF_DATA_CE3_BASE,
	};

	static const u32 emif_window_sizes[] = { SZ_256M, SZ_64M, SZ_64M, SZ_64M };

	static struct resource wdt_resources[] = {
	{
	.start = TNETV107X_WDOG_BASE,
	.end = TNETV107X_WDOG_BASE + SZ_4K - 1,
	.flags = IORESOURCE_MEM,
	},
	};

	struct platform_device tnetv107x_wdt_device = {
	.name = "tnetv107x_wdt",
	.id = 0,
	.num_resources = ARRAY_SIZE(wdt_resources),
	.resource = wdt_resources,
	};

	static int __init nand_init(int chipsel, struct davinci_nand_pdata *data)
	{
	struct resource res[2];
	struct platform_device *pdev;
	u32 range;
	int ret;

	/* Figure out the resource range from the ale/cle masks */
	range = max(data->mask_cle, data->mask_ale);
	range = PAGE_ALIGN(range + 4) - 1;

	if (range >= emif_window_sizes[chipsel])
	return -EINVAL;

	pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
	if (!pdev)
	return -ENOMEM;

	pdev->name = "davinci_nand";
	pdev->id = chipsel;
	pdev->dev.platform_data = data;

	memset(res, 0, sizeof(res));

	res[0].start = emif_windows[chipsel];
	res[0].end = res[0].start + range;
	res[0].flags = IORESOURCE_MEM;

	res[1].start = TNETV107X_ASYNC_EMIF_CNTRL_BASE;
	res[1].end = res[1].start + SZ_4K - 1;
	res[1].flags = IORESOURCE_MEM;

	ret = platform_device_add_resources(pdev, res, ARRAY_SIZE(res));
	if (ret < 0) {
	kfree(pdev);
	return ret;
	}

	return platform_device_register(pdev);
	}

	static struct resource keypad_resources[] = {
	{
	.start = TNETV107X_KEYPAD_BASE,
	.end = TNETV107X_KEYPAD_BASE + 0xff,
	.flags = IORESOURCE_MEM,
	},
	{
	.start = IRQ_TNETV107X_KEYPAD,
	.flags = IORESOURCE_IRQ,
	.name = "press",
	},
	{
	.start = IRQ_TNETV107X_KEYPAD_FREE,
	.flags = IORESOURCE_IRQ,
	.name = "release",
	},
	};

	static struct platform_device keypad_device = {
	.name = "tnetv107x-keypad",
	.num_resources = ARRAY_SIZE(keypad_resources),
	.resource = keypad_resources,
	};

	static struct resource tsc_resources[] = {
	{
	.start = TNETV107X_TSC_BASE,
	.end = TNETV107X_TSC_BASE + 0xff,
	.flags = IORESOURCE_MEM,
	},
	{
	.start = IRQ_TNETV107X_TSC,
	.flags = IORESOURCE_IRQ,
	},
	};

	static struct platform_device tsc_device = {
	.name = "tnetv107x-ts",
	.num_resources = ARRAY_SIZE(tsc_resources),
	.resource = tsc_resources,
	};

	static struct resource ssp_resources[] = {
	{
	.start = TNETV107X_SSP_BASE,
	.end = TNETV107X_SSP_BASE + 0x1ff,
	.flags = IORESOURCE_MEM,
	},
	{
	.start = IRQ_TNETV107X_SSP,
	.flags = IORESOURCE_IRQ,
	},
	};

	static struct platform_device ssp_device = {
	.name = "ti-ssp",
	.id = -1,
	.num_resources = ARRAY_SIZE(ssp_resources),
	.resource = ssp_resources,
	};

	void __init tnetv107x_devices_init(struct tnetv107x_device_info *info)
	{
	int i, error;
	struct clk *tsc_clk;

	/*
	* The reset defaults for tnetv107x tsc clock divider is set too high.
	* This forces the clock down to a range that allows the ADC to
	* complete sample conversion in time.
	*/
	tsc_clk = clk_get(NULL, "sys_tsc_clk");
	if (!IS_ERR(tsc_clk)) {
	error = clk_set_rate(tsc_clk, 5000000);
	WARN_ON(error < 0);
	clk_put(tsc_clk);
	}

	platform_device_register(&edma_device);
	platform_device_register(&tnetv107x_wdt_device);
	platform_device_register(&tsc_device);

	if (info->serial_config)
	davinci_serial_init(tnetv107x_serial_device);

	for (i = 0; i < 2; i++)
	if (info->mmc_config[i]) {
	mmc_devices[i].dev.platform_data = info->mmc_config[i];
	platform_device_register(&mmc_devices[i]);
	}

	for (i = 0; i < 4; i++)
	if (info->nand_config[i])
	nand_init(i, info->nand_config[i]);

	if (info->keypad_config) {
	keypad_device.dev.platform_data = info->keypad_config;
	platform_device_register(&keypad_device);
	}

	if (info->ssp_config) {
	ssp_device.dev.platform_data = info->ssp_config;
	platform_device_register(&ssp_device);
	}
	}

Admin message