ARM: davinci: remove tnetv107x support (9d6eccb9) · Commits · e / devices / android_kernel_teracube_2e

arch/arm/Kconfig.debug

+1 −12

Original line number	Diff line number	Diff line
		@@ -176,15 +176,6 @@ choice
		Say Y here if you want the debug print routines to direct
		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
		bool "Kernel low-level debugging on Xilinx Zynq using UART0"
		depends on ARCH_ZYNQ
		@@ -1019,7 +1010,6 @@ config DEBUG_UART_PHYS
		default 0x02530c00 if DEBUG_KEYSTONE_UART0
		default 0x02531000 if DEBUG_KEYSTONE_UART1
		default 0x03010fe0 if ARCH_RPC
		default 0x08108300 if DEBUG_DAVINCI_TNETV107X_UART1
		default 0x10009000 if DEBUG_REALVIEW_STD_PORT \|\| DEBUG_CNS3XXX \|\| \
		DEBUG_VEXPRESS_UART0_CA9
		default 0x1010c000 if DEBUG_REALVIEW_PB1176_PORT
		@@ -1117,7 +1107,6 @@ config DEBUG_UART_VIRT
		default 0xfed12000 if ARCH_KIRKWOOD
		default 0xfedc0000 if ARCH_EP93XX
		default 0xfee003f8 if FOOTBRIDGE
		default 0xfee08300 if DEBUG_DAVINCI_TNETV107X_UART1
		default 0xfee20000 if DEBUG_NSPIRE_CLASSIC_UART \|\| DEBUG_NSPIRE_CX_UART
		default 0xfef36000 if DEBUG_HIGHBANK_UART
		default 0xfee82340 if ARCH_IOP13XX
		@@ -1142,7 +1131,7 @@ config DEBUG_UART_8250_WORD
		default y if DEBUG_PICOXCELL_UART \|\| DEBUG_SOCFPGA_UART \|\| \
		ARCH_KEYSTONE \|\| \
		DEBUG_DAVINCI_DMx_UART0 \|\| DEBUG_DAVINCI_DA8XX_UART1 \|\| \
		DEBUG_DAVINCI_DA8XX_UART2 \|\| DEBUG_DAVINCI_TNETV107X_UART1 \|\| \
		DEBUG_DAVINCI_DA8XX_UART2 \|\| \
		DEBUG_BCM_KONA_UART

		config DEBUG_UART_8250_FLOW_CONTROL

arch/arm/mach-davinci/Kconfig

+0 −12

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

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

		comment "DaVinci Board Type"

		config MACH_DA8XX_DT
		@@ -220,13 +215,6 @@ config GPIO_PCA953X
		config KEYBOARD_GPIO_POLLED
		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
		bool "Critical Link MityDSP-L138/MityARM-1808 SoM"
		depends on ARCH_DAVINCI_DA850

arch/arm/mach-davinci/Makefile

+0 −2

Original line number	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_DA830) += da830.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_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_DA830_EVM) += board-da830-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_OMAPL138_HAWKBOARD) += board-omapl138-hawk.o

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

deleted100644 → 0

+0 −287

Original line number	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	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);
		}
		}