ARM: davinci: Delete DM644x board files (7dd33764) · Commits · EulixOS / Software / Kernel

arch/arm/mach-davinci/Kconfig

+0 −27

Original line number	Diff line number	Diff line
		@@ -19,11 +19,6 @@ config ARCH_DAVINCI_DMx

		comment "DaVinci Core Type"

		config ARCH_DAVINCI_DM644x
		bool "DaVinci 644x based system"
		select DAVINCI_AINTC
		select ARCH_DAVINCI_DMx

		config ARCH_DAVINCI_DM355
		bool "DaVinci 355 based system"
		select DAVINCI_AINTC
		@@ -67,28 +62,6 @@ config MACH_DA8XX_DT
		Say y here to include support for TI DaVinci DA850 based using
		Flattened Device Tree. More information at Documentation/devicetree

		config MACH_DAVINCI_EVM
		bool "TI DM644x EVM"
		default ARCH_DAVINCI_DM644x
		depends on ARCH_DAVINCI_DM644x
		help
		Configure this option to specify the whether the board used
		for development is a DM644x EVM

		config MACH_SFFSDR
		bool "Lyrtech SFFSDR"
		depends on ARCH_DAVINCI_DM644x
		help
		Say Y here to select the Lyrtech Small Form Factor
		Software Defined Radio (SFFSDR) board.

		config MACH_NEUROS_OSD2
		bool "Neuros OSD2 Open Television Set Top Box"
		depends on ARCH_DAVINCI_DM644x
		help
		Configure this option to specify the whether the board used
		for development is a Neuros OSD2 Open Set Top Box.

		config MACH_DAVINCI_DM355_EVM
		bool "TI DM355 EVM"
		default ARCH_DAVINCI_DM355

arch/arm/mach-davinci/Makefile

+0 −4

Original line number	Diff line number	Diff line
		@@ -10,7 +10,6 @@ obj-y := serial.o usb.o common.o sram.o
		obj-$(CONFIG_DAVINCI_MUX) += mux.o

		# Chip specific
		obj-$(CONFIG_ARCH_DAVINCI_DM644x) += dm644x.o devices.o
		obj-$(CONFIG_ARCH_DAVINCI_DM355) += dm355.o devices.o
		obj-$(CONFIG_ARCH_DAVINCI_DM646x) += dm646x.o devices.o
		obj-$(CONFIG_ARCH_DAVINCI_DM365) += dm365.o devices.o
		@@ -19,9 +18,6 @@ obj-$(CONFIG_ARCH_DAVINCI_DA850) += da850.o devices-da8xx.o usb-da8xx.o

		# Board specific
		obj-$(CONFIG_MACH_DA8XX_DT) += da8xx-dt.o pdata-quirks.o
		obj-$(CONFIG_MACH_DAVINCI_EVM) += board-dm644x-evm.o
		obj-$(CONFIG_MACH_SFFSDR) += board-sffsdr.o
		obj-$(CONFIG_MACH_NEUROS_OSD2) += board-neuros-osd2.o
		obj-$(CONFIG_MACH_DAVINCI_DM355_EVM) += board-dm355-evm.o
		obj-$(CONFIG_MACH_DM355_LEOPARD) += board-dm355-leopard.o
		obj-$(CONFIG_MACH_DAVINCI_DM6467_EVM) += board-dm646x-evm.o

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

deleted100644 → 0

+0 −928

File deleted.

Preview size limit exceeded, changes collapsed.

arch/arm/mach-davinci/board-neuros-osd2.c

deleted100644 → 0

+0 −238

Original line number	Diff line number	Diff line
		/*
		* Neuros Technologies OSD2 board support
		*
		* Modified from original 644X-EVM board support.
		* 2008 (c) Neuros Technology, LLC.
		* 2009 (c) Jorge Luis Zapata Muga <jorgeluis.zapata@gmail.com>
		* 2009 (c) Andrey A. Porodko <Andrey.Porodko@gmail.com>
		*
		* The Neuros OSD 2.0 is the hardware component of the Neuros Open
		* Internet Television Platform. Hardware is very close to TI
		* DM644X-EVM board. It has:
		* DM6446M02 module with 256MB NAND, 256MB RAM, TLV320AIC32 AIC,
		* USB, Ethernet, SD/MMC, UART, THS8200, TVP7000 for video.
		* Additionally realtime clock, IR remote control receiver,
		* IR Blaster based on MSP430 (firmware although is different
		* from used in DM644X-EVM), internal ATA-6 3.5” HDD drive
		* with PATA interface, two muxed red-green leds.
		*
		* For more information please refer to
		* http://wiki.neurostechnology.com/index.php/OSD_2.0_HD
		*
		* This file is licensed under the terms of the GNU General Public
		* License version 2. This program is licensed "as is" without any
		* warranty of any kind, whether express or implied.
		*/
		#include <linux/platform_device.h>
		#include <linux/gpio.h>
		#include <linux/leds.h>
		#include <linux/mtd/partitions.h>
		#include <linux/platform_data/gpio-davinci.h>
		#include <linux/platform_data/i2c-davinci.h>
		#include <linux/platform_data/mmc-davinci.h>
		#include <linux/platform_data/mtd-davinci.h>
		#include <linux/platform_data/usb-davinci.h>

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

		#include "common.h"
		#include "serial.h"
		#include "mux.h"
		#include "davinci.h"

		#define NEUROS_OSD2_PHY_ID "davinci_mdio-0:01"
		#define LXT971_PHY_ID 0x001378e2
		#define LXT971_PHY_MASK 0xfffffff0

		#define NTOSD2_AUDIOSOC_I2C_ADDR 0x18
		#define NTOSD2_MSP430_I2C_ADDR 0x59
		#define NTOSD2_MSP430_IRQ 2

		/* Neuros OSD2 has a Samsung 256 MByte NAND flash (Dev ID of 0xAA,
		* 2048 blocks in the device, 64 pages per block, 2048 bytes per
		* page.
		*/

		#define NAND_BLOCK_SIZE SZ_128K

		static struct mtd_partition davinci_ntosd2_nandflash_partition[] = {
		{
		/* UBL (a few copies) plus U-Boot */
		.name = "bootloader",
		.offset = 0,
		.size = 15 * NAND_BLOCK_SIZE,
		.mask_flags = MTD_WRITEABLE, /* force read-only */
		}, {
		/* U-Boot environment */
		.name = "params",
		.offset = MTDPART_OFS_APPEND,
		.size = 1 * NAND_BLOCK_SIZE,
		.mask_flags = 0,
		}, {
		/* Kernel */
		.name = "kernel",
		.offset = MTDPART_OFS_APPEND,
		.size = SZ_4M,
		.mask_flags = 0,
		}, {
		/* File System */
		.name = "filesystem",
		.offset = MTDPART_OFS_APPEND,
		.size = MTDPART_SIZ_FULL,
		.mask_flags = 0,
		}
		/* A few blocks at end hold a flash Bad Block Table. */
		};

		static struct davinci_nand_pdata davinci_ntosd2_nandflash_data = {
		.core_chipsel = 0,
		.parts = davinci_ntosd2_nandflash_partition,
		.nr_parts = ARRAY_SIZE(davinci_ntosd2_nandflash_partition),
		.engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST,
		.ecc_bits = 1,
		.bbt_options = NAND_BBT_USE_FLASH,
		};

		static struct resource davinci_ntosd2_nandflash_resource[] = {
		{
		.start = DM644X_ASYNC_EMIF_DATA_CE0_BASE,
		.end = DM644X_ASYNC_EMIF_DATA_CE0_BASE + SZ_16M - 1,
		.flags = IORESOURCE_MEM,
		}, {
		.start = DM644X_ASYNC_EMIF_CONTROL_BASE,
		.end = DM644X_ASYNC_EMIF_CONTROL_BASE + SZ_4K - 1,
		.flags = IORESOURCE_MEM,
		},
		};

		static struct platform_device davinci_ntosd2_nandflash_device = {
		.name = "davinci_nand",
		.id = 0,
		.dev = {
		.platform_data = &davinci_ntosd2_nandflash_data,
		},
		.num_resources = ARRAY_SIZE(davinci_ntosd2_nandflash_resource),
		.resource = davinci_ntosd2_nandflash_resource,
		};

		static u64 davinci_fb_dma_mask = DMA_BIT_MASK(32);

		static struct platform_device davinci_fb_device = {
		.name = "davincifb",
		.id = -1,
		.dev = {
		.dma_mask = &davinci_fb_dma_mask,
		.coherent_dma_mask = DMA_BIT_MASK(32),
		},
		.num_resources = 0,
		};

		static const struct gpio_led ntosd2_leds[] = {
		{ .name = "led1_green", .gpio = 10, },
		{ .name = "led1_red", .gpio = 11, },
		{ .name = "led2_green", .gpio = 12, },
		{ .name = "led2_red", .gpio = 13, },
		};

		static struct gpio_led_platform_data ntosd2_leds_data = {
		.num_leds = ARRAY_SIZE(ntosd2_leds),
		.leds = ntosd2_leds,
		};

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


		static struct platform_device *davinci_ntosd2_devices[] __initdata = {
		&davinci_fb_device,
		&ntosd2_leds_dev,
		};

		static void __init davinci_ntosd2_map_io(void)
		{
		dm644x_init();
		}

		static struct davinci_mmc_config davinci_ntosd2_mmc_config = {
		.wires = 4,
		};

		#define HAS_ATA (IS_ENABLED(CONFIG_BLK_DEV_PALMCHIP_BK3710) \|\| \
		IS_ENABLED(CONFIG_PATA_BK3710))

		#define HAS_NAND IS_ENABLED(CONFIG_MTD_NAND_DAVINCI)

		static __init void davinci_ntosd2_init(void)
		{
		int ret;
		struct clk *aemif_clk;
		struct davinci_soc_info *soc_info = &davinci_soc_info;

		dm644x_register_clocks();

		dm644x_init_devices();

		ret = dm644x_gpio_register();
		if (ret)
		pr_warn("%s: GPIO init failed: %d\n", __func__, ret);

		aemif_clk = clk_get(NULL, "aemif");
		clk_prepare_enable(aemif_clk);

		if (HAS_ATA) {
		if (HAS_NAND)
		pr_warn("WARNING: both IDE and Flash are enabled, but they share AEMIF pins\n"
		"\tDisable IDE for NAND/NOR support\n");
		davinci_init_ide();
		} else if (HAS_NAND) {
		davinci_cfg_reg(DM644X_HPIEN_DISABLE);
		davinci_cfg_reg(DM644X_ATAEN_DISABLE);

		/* only one device will be jumpered and detected */
		if (HAS_NAND)
		platform_device_register(
		&davinci_ntosd2_nandflash_device);
		}

		platform_add_devices(davinci_ntosd2_devices,
		ARRAY_SIZE(davinci_ntosd2_devices));

		davinci_serial_init(dm644x_serial_device);
		dm644x_init_asp();

		soc_info->emac_pdata->phy_id = NEUROS_OSD2_PHY_ID;

		davinci_setup_usb(1000, 8);
		/*
		* Mux the pins to be GPIOs, VLYNQEN is already done at startup.
		* The AEAWx are five new AEAW pins that can be muxed by separately.
		* They are a bitmask for GPIO management. According TI
		* documentation (https://www.ti.com/lit/gpn/tms320dm6446) to employ
		* gpio(10,11,12,13) for leds any combination of bits works except
		* four last. So we are to reset all five.
		*/
		davinci_cfg_reg(DM644X_AEAW0);
		davinci_cfg_reg(DM644X_AEAW1);
		davinci_cfg_reg(DM644X_AEAW2);
		davinci_cfg_reg(DM644X_AEAW3);
		davinci_cfg_reg(DM644X_AEAW4);

		davinci_setup_mmc(0, &davinci_ntosd2_mmc_config);
		}

		MACHINE_START(NEUROS_OSD2, "Neuros OSD2")
		/* Maintainer: Neuros Technologies <neuros@groups.google.com> */
		.atag_offset = 0x100,
		.map_io = davinci_ntosd2_map_io,
		.init_irq = dm644x_init_irq,
		.init_time = dm644x_init_time,
		.init_machine = davinci_ntosd2_init,
		.init_late = davinci_init_late,
		.dma_zone_size = SZ_128M,
		MACHINE_END

arch/arm/mach-davinci/board-sffsdr.c

deleted100644 → 0

+0 −151

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/*
		* Lyrtech SFFSDR board support.
		*
		* Copyright (C) 2008 Philip Balister, OpenSDR <philip@opensdr.com>
		* Copyright (C) 2008 Lyrtech <www.lyrtech.com>
		*
		* Based on DV-EVM platform, original copyright follows:
		*
		* Copyright (C) 2007 MontaVista Software, Inc.
		*/

		#include <linux/init.h>
		#include <linux/platform_device.h>
		#include <linux/i2c.h>
		#include <linux/property.h>
		#include <linux/mtd/mtd.h>
		#include <linux/mtd/rawnand.h>
		#include <linux/mtd/partitions.h>

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

		#include <linux/platform_data/i2c-davinci.h>
		#include <linux/platform_data/usb-davinci.h>

		#include "common.h"
		#include "serial.h"
		#include "mux.h"
		#include "davinci.h"

		#define SFFSDR_PHY_ID "davinci_mdio-0:01"
		static struct mtd_partition davinci_sffsdr_nandflash_partition[] = {
		/* U-Boot Environment: Block 0
		* UBL: Block 1
		* U-Boot: Blocks 6-7 (256 kb)
		* Integrity Kernel: Blocks 8-31 (3 Mb)
		* Integrity Data: Blocks 100-END
		*/
		{
		.name = "Linux Kernel",
		.offset = 32 * SZ_128K,
		.size = 16 * SZ_128K, /* 2 Mb */
		.mask_flags = MTD_WRITEABLE, /* Force read-only */
		},
		{
		.name = "Linux ROOT",
		.offset = MTDPART_OFS_APPEND,
		.size = 256 * SZ_128K, /* 32 Mb */
		.mask_flags = 0, /* R/W */
		},
		};

		static struct flash_platform_data davinci_sffsdr_nandflash_data = {
		.parts = davinci_sffsdr_nandflash_partition,
		.nr_parts = ARRAY_SIZE(davinci_sffsdr_nandflash_partition),
		};

		static struct resource davinci_sffsdr_nandflash_resource[] = {
		{
		.start = DM644X_ASYNC_EMIF_DATA_CE0_BASE,
		.end = DM644X_ASYNC_EMIF_DATA_CE0_BASE + SZ_16M - 1,
		.flags = IORESOURCE_MEM,
		}, {
		.start = DM644X_ASYNC_EMIF_CONTROL_BASE,
		.end = DM644X_ASYNC_EMIF_CONTROL_BASE + SZ_4K - 1,
		.flags = IORESOURCE_MEM,
		},
		};

		static struct platform_device davinci_sffsdr_nandflash_device = {
		.name = "davinci_nand", /* Name of driver */
		.id = 0,
		.dev = {
		.platform_data = &davinci_sffsdr_nandflash_data,
		},
		.num_resources = ARRAY_SIZE(davinci_sffsdr_nandflash_resource),
		.resource = davinci_sffsdr_nandflash_resource,
		};

		static const struct property_entry eeprom_properties[] = {
		PROPERTY_ENTRY_U32("pagesize", 32),
		{ }
		};

		static const struct software_node eeprom_node = {
		.properties = eeprom_properties,
		};

		static struct i2c_board_info __initdata i2c_info[] = {
		{
		I2C_BOARD_INFO("24c64", 0x50),
		.swnode = &eeprom_node,
		},
		/* Other I2C devices:
		* MSP430, addr 0x23 (not used)
		* PCA9543, addr 0x70 (setup done by U-Boot)
		* ADS7828, addr 0x48 (ADC for voltage monitoring.)
		*/
		};

		static struct davinci_i2c_platform_data i2c_pdata = {
		.bus_freq = 20 /* kHz */,
		.bus_delay = 100 /* usec */,
		};

		static void __init sffsdr_init_i2c(void)
		{
		davinci_init_i2c(&i2c_pdata);
		i2c_register_board_info(1, i2c_info, ARRAY_SIZE(i2c_info));
		}

		static struct platform_device *davinci_sffsdr_devices[] __initdata = {
		&davinci_sffsdr_nandflash_device,
		};

		static void __init davinci_sffsdr_map_io(void)
		{
		dm644x_init();
		}

		static __init void davinci_sffsdr_init(void)
		{
		struct davinci_soc_info *soc_info = &davinci_soc_info;

		dm644x_register_clocks();

		dm644x_init_devices();

		platform_add_devices(davinci_sffsdr_devices,
		ARRAY_SIZE(davinci_sffsdr_devices));
		sffsdr_init_i2c();
		davinci_serial_init(dm644x_serial_device);
		soc_info->emac_pdata->phy_id = SFFSDR_PHY_ID;
		davinci_setup_usb(0, 0); /* We support only peripheral mode. */

		/* mux VLYNQ pins */
		davinci_cfg_reg(DM644X_VLYNQEN);
		davinci_cfg_reg(DM644X_VLYNQWD);
		}

		MACHINE_START(SFFSDR, "Lyrtech SFFSDR")
		.atag_offset = 0x100,
		.map_io = davinci_sffsdr_map_io,
		.init_irq = dm644x_init_irq,
		.init_time = dm644x_init_time,
		.init_machine = davinci_sffsdr_init,
		.init_late = davinci_init_late,
		.dma_zone_size = SZ_128M,
		MACHINE_END