ARM: clps711x: remove extraneous files

/*

 *  linux/arch/arm/mach-clps711x/autcpu12.c

 *

 * (c) 2001 Thomas Gleixner, autronix automation <gleixner@autronix.de>

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/types.h>

#include <linux/string.h>

#include <linux/mm.h>

#include <linux/io.h>

#include <linux/gpio.h>

#include <linux/ioport.h>

#include <linux/interrupt.h>

#include <linux/mtd/physmap.h>

#include <linux/mtd/plat-ram.h>

#include <linux/mtd/partitions.h>

#include <linux/mtd/nand-gpio.h>

#include <linux/platform_device.h>

#include <linux/gpio/driver.h>

#include <mach/hardware.h>

#include <asm/sizes.h>

#include <asm/setup.h>

#include <asm/mach-types.h>

#include <asm/mach/arch.h>

#include <asm/pgtable.h>

#include <asm/page.h>

#include <asm/mach/map.h>

#include "common.h"

#include "devices.h"

/* NOR flash */

#define AUTCPU12_FLASH_BASE	(CS0_PHYS_BASE)

/* Board specific hardware definitions */

#define AUTCPU12_CHAR_LCD_BASE	(CS1_PHYS_BASE + 0x00000000)

#define AUTCPU12_CSAUX1_BASE	(CS1_PHYS_BASE + 0x04000000)

#define AUTCPU12_CAN_BASE	(CS1_PHYS_BASE + 0x08000000)

#define AUTCPU12_TOUCH_BASE	(CS1_PHYS_BASE + 0x0a000000)

#define AUTCPU12_IO_BASE	(CS1_PHYS_BASE + 0x0c000000)

#define AUTCPU12_LPT_BASE	(CS1_PHYS_BASE + 0x0e000000)

/* NVRAM */

#define AUTCPU12_NVRAM_BASE	(CS1_PHYS_BASE + 0x02000000)

/* SmartMedia flash */

#define AUTCPU12_SMC_BASE	(CS1_PHYS_BASE + 0x06000000)

#define AUTCPU12_SMC_SEL_BASE	(AUTCPU12_SMC_BASE + 0x10)

/* Ethernet */

#define AUTCPU12_CS8900_BASE	(CS2_PHYS_BASE + 0x300)

#define AUTCPU12_CS8900_IRQ	(IRQ_EINT3)

/* NAND flash */

#define AUTCPU12_MMGPIO_BASE	(CLPS711X_NR_GPIO)

#define AUTCPU12_SMC_NCE	(AUTCPU12_MMGPIO_BASE + 0) /* Bit 0 */

#define AUTCPU12_SMC_RDY	CLPS711X_GPIO(1, 2)

#define AUTCPU12_SMC_ALE	CLPS711X_GPIO(1, 3)

#define AUTCPU12_SMC_CLE	CLPS711X_GPIO(1, 4)

/* LCD contrast digital potentiometer */

#define AUTCPU12_DPOT_CS	CLPS711X_GPIO(4, 0)

#define AUTCPU12_DPOT_CLK	CLPS711X_GPIO(4, 1)

#define AUTCPU12_DPOT_UD	CLPS711X_GPIO(4, 2)

static struct resource autcpu12_cs8900_resource[] __initdata = {

	DEFINE_RES_MEM(AUTCPU12_CS8900_BASE, SZ_1K),

	DEFINE_RES_IRQ(AUTCPU12_CS8900_IRQ),

};

static struct resource autcpu12_nand_resource[] __initdata = {

	DEFINE_RES_MEM(AUTCPU12_SMC_BASE, SZ_16),

};

static struct mtd_partition autcpu12_nand_parts[] __initdata = {

	{

		.name	= "Flash partition 1",

		.offset	= 0,

		.size	= SZ_8M,

	},

	{

		.name	= "Flash partition 2",

		.offset	= MTDPART_OFS_APPEND,

		.size	= MTDPART_SIZ_FULL,

	},

};

static void __init autcpu12_adjust_parts(struct gpio_nand_platdata *pdata,

					 size_t sz)

{

	switch (sz) {

	case SZ_16M:

	case SZ_32M:

		break;

	case SZ_64M:

	case SZ_128M:

		pdata->parts[0].size = SZ_16M;

		break;

	default:

		pr_warn("Unsupported SmartMedia device size %u\n", sz);

		break;

	}

}

static struct gpio_nand_platdata autcpu12_nand_pdata __initdata = {

	.gpio_rdy	= AUTCPU12_SMC_RDY,

	.gpio_nce	= AUTCPU12_SMC_NCE,

	.gpio_ale	= AUTCPU12_SMC_ALE,

	.gpio_cle	= AUTCPU12_SMC_CLE,

	.gpio_nwp	= -1,

	.chip_delay	= 20,

	.parts		= autcpu12_nand_parts,

	.num_parts	= ARRAY_SIZE(autcpu12_nand_parts),

	.adjust_parts	= autcpu12_adjust_parts,

};

static struct platform_device autcpu12_nand_pdev __initdata = {

	.name		= "gpio-nand",

	.id		= -1,

	.resource	= autcpu12_nand_resource,

	.num_resources	= ARRAY_SIZE(autcpu12_nand_resource),

	.dev		= {

		.platform_data = &autcpu12_nand_pdata,

	},

};

static struct resource autcpu12_mmgpio_resource[] __initdata = {

	DEFINE_RES_MEM_NAMED(AUTCPU12_SMC_SEL_BASE, SZ_1, "dat"),

};

static struct bgpio_pdata autcpu12_mmgpio_pdata __initdata = {

	.base	= AUTCPU12_MMGPIO_BASE,

	.ngpio	= 8,

};

static struct platform_device autcpu12_mmgpio_pdev __initdata = {

	.name		= "basic-mmio-gpio",

	.id		= -1,

	.resource	= autcpu12_mmgpio_resource,

	.num_resources	= ARRAY_SIZE(autcpu12_mmgpio_resource),

	.dev		= {

		.platform_data = &autcpu12_mmgpio_pdata,

	},

};

static const struct gpio const autcpu12_gpios[] __initconst = {

	{ AUTCPU12_DPOT_CS,	GPIOF_OUT_INIT_HIGH,	"DPOT CS" },

	{ AUTCPU12_DPOT_CLK,	GPIOF_OUT_INIT_LOW,	"DPOT CLK" },

	{ AUTCPU12_DPOT_UD,	GPIOF_OUT_INIT_LOW,	"DPOT UD" },

};

static struct mtd_partition autcpu12_flash_partitions[] = {

	{

		.name	= "NOR.0",

		.offset	= 0,

		.size	= MTDPART_SIZ_FULL,

	},

};

static struct physmap_flash_data autcpu12_flash_pdata = {

	.width		= 4,

	.parts		= autcpu12_flash_partitions,

	.nr_parts	= ARRAY_SIZE(autcpu12_flash_partitions),

};

static struct resource autcpu12_flash_resources[] __initdata = {

	DEFINE_RES_MEM(AUTCPU12_FLASH_BASE, SZ_8M),

};

static struct platform_device autcpu12_flash_pdev __initdata = {

	.name		= "physmap-flash",

	.id		= 0,

	.resource	= autcpu12_flash_resources,

	.num_resources	= ARRAY_SIZE(autcpu12_flash_resources),

	.dev		= {

		.platform_data	= &autcpu12_flash_pdata,

	},

};

static struct resource autcpu12_nvram_resource[] __initdata = {

	DEFINE_RES_MEM(AUTCPU12_NVRAM_BASE, 0),

};

static struct platdata_mtd_ram autcpu12_nvram_pdata = {

	.bankwidth	= 4,

};

static struct platform_device autcpu12_nvram_pdev __initdata = {

	.name		= "mtd-ram",

	.id		= 0,

	.resource	= autcpu12_nvram_resource,

	.num_resources	= ARRAY_SIZE(autcpu12_nvram_resource),

	.dev		= {

		.platform_data	= &autcpu12_nvram_pdata,

	},

};

static void __init autcpu12_nvram_init(void)

{

	void __iomem *nvram;

	unsigned int save[2];

	resource_size_t nvram_size = SZ_128K;

	/*

	 * Check for 32K/128K

	 * Read ofs 0K

	 * Read ofs 64K

	 * Write complement to ofs 64K

	 * Read and check result on ofs 0K

	 * Restore contents

	 */

	nvram = ioremap(autcpu12_nvram_resource[0].start, SZ_128K);

	if (nvram) {

		save[0] = readl(nvram + 0);

		save[1] = readl(nvram + SZ_64K);

		writel(~save[0], nvram + SZ_64K);

		if (readl(nvram + 0) != save[0]) {

			writel(save[0], nvram + 0);

			nvram_size = SZ_32K;

		} else

			writel(save[1], nvram + SZ_64K);

		iounmap(nvram);

		autcpu12_nvram_resource[0].end =

			autcpu12_nvram_resource[0].start + nvram_size - 1;

		platform_device_register(&autcpu12_nvram_pdev);

	} else

		pr_err("Failed to remap NVRAM resource\n");

}

static void __init autcpu12_init(void)

{

	clps711x_devices_init();

	platform_device_register(&autcpu12_flash_pdev);

	platform_device_register_simple("video-clps711x", 0, NULL, 0);

	platform_device_register_simple("cs89x0", 0, autcpu12_cs8900_resource,

					ARRAY_SIZE(autcpu12_cs8900_resource));

	platform_device_register(&autcpu12_mmgpio_pdev);

	autcpu12_nvram_init();

}

static void __init autcpu12_init_late(void)

{

	gpio_request_array(autcpu12_gpios, ARRAY_SIZE(autcpu12_gpios));

	platform_device_register(&autcpu12_nand_pdev);

}

MACHINE_START(AUTCPU12, "autronix autcpu12")

	/* Maintainer: Thomas Gleixner */

	.atag_offset	= 0x20000,

	.map_io		= clps711x_map_io,

	.init_irq	= clps711x_init_irq,

	.init_time	= clps711x_timer_init,

	.init_machine	= autcpu12_init,

	.init_late	= autcpu12_init_late,

	.restart	= clps711x_restart,

MACHINE_END

/*

 *  linux/arch/arm/mach-clps711x/cdb89712.c

 *

 *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/types.h>

#include <linux/string.h>

#include <linux/mm.h>

#include <linux/io.h>

#include <linux/interrupt.h>

#include <linux/platform_device.h>

#include <linux/mtd/physmap.h>

#include <linux/mtd/plat-ram.h>

#include <linux/mtd/partitions.h>

#include <mach/hardware.h>

#include <asm/pgtable.h>

#include <asm/page.h>

#include <asm/setup.h>

#include <asm/mach-types.h>

#include <asm/mach/arch.h>

#include <asm/mach/map.h>

#include "common.h"

#include "devices.h"

#define CDB89712_CS8900_BASE	(CS2_PHYS_BASE + 0x300)

#define CDB89712_CS8900_IRQ	(IRQ_EINT3)

static struct resource cdb89712_cs8900_resource[] __initdata = {

	DEFINE_RES_MEM(CDB89712_CS8900_BASE, SZ_1K),

	DEFINE_RES_IRQ(CDB89712_CS8900_IRQ),

};

static struct mtd_partition cdb89712_flash_partitions[] __initdata = {

	{

		.name	= "Flash",

		.offset	= 0,

		.size	= MTDPART_SIZ_FULL,

	},

};

static struct physmap_flash_data cdb89712_flash_pdata __initdata = {

	.width		= 4,

	.probe_type	= "map_rom",

	.parts		= cdb89712_flash_partitions,

	.nr_parts	= ARRAY_SIZE(cdb89712_flash_partitions),

};

static struct resource cdb89712_flash_resources[] __initdata = {

	DEFINE_RES_MEM(CS0_PHYS_BASE, SZ_8M),

};

static struct platform_device cdb89712_flash_pdev __initdata = {

	.name		= "physmap-flash",

	.id		= 0,

	.resource	= cdb89712_flash_resources,

	.num_resources	= ARRAY_SIZE(cdb89712_flash_resources),

	.dev	= {

		.platform_data	= &cdb89712_flash_pdata,

	},

};

static struct mtd_partition cdb89712_bootrom_partitions[] __initdata = {

	{

		.name	= "BootROM",

		.offset	= 0,

		.size	= MTDPART_SIZ_FULL,

	},

};

static struct physmap_flash_data cdb89712_bootrom_pdata __initdata = {

	.width		= 4,

	.probe_type	= "map_rom",

	.parts		= cdb89712_bootrom_partitions,

	.nr_parts	= ARRAY_SIZE(cdb89712_bootrom_partitions),

};

static struct resource cdb89712_bootrom_resources[] __initdata = {

	DEFINE_RES_NAMED(CS7_PHYS_BASE, SZ_128, "BOOTROM", IORESOURCE_MEM |

			 IORESOURCE_READONLY),

};

static struct platform_device cdb89712_bootrom_pdev __initdata = {

	.name		= "physmap-flash",

	.id		= 1,

	.resource	= cdb89712_bootrom_resources,

	.num_resources	= ARRAY_SIZE(cdb89712_bootrom_resources),

	.dev	= {

		.platform_data	= &cdb89712_bootrom_pdata,

	},

};

static struct platdata_mtd_ram cdb89712_sram_pdata __initdata = {

	.bankwidth	= 4,

};

static struct resource cdb89712_sram_resources[] __initdata = {

	DEFINE_RES_MEM(CLPS711X_SRAM_BASE, CLPS711X_SRAM_SIZE),

};

static struct platform_device cdb89712_sram_pdev __initdata = {

	.name		= "mtd-ram",

	.id		= 0,

	.resource	= cdb89712_sram_resources,

	.num_resources	= ARRAY_SIZE(cdb89712_sram_resources),

	.dev	= {

		.platform_data	= &cdb89712_sram_pdata,

	},

};

static void __init cdb89712_init(void)

{

	clps711x_devices_init();

	platform_device_register(&cdb89712_flash_pdev);

	platform_device_register(&cdb89712_bootrom_pdev);

	platform_device_register(&cdb89712_sram_pdev);

	platform_device_register_simple("cs89x0", 0, cdb89712_cs8900_resource,

					ARRAY_SIZE(cdb89712_cs8900_resource));

}

MACHINE_START(CDB89712, "Cirrus-CDB89712")

	/* Maintainer: Ray Lehtiniemi */

	.atag_offset	= 0x100,

	.map_io		= clps711x_map_io,

	.init_irq	= clps711x_init_irq,

	.init_time	= clps711x_timer_init,

	.init_machine	= cdb89712_init,

	.restart	= clps711x_restart,

MACHINE_END

/*

 *  linux/arch/arm/mach-clps711x/clep7312.c

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include <linux/init.h>

#include <linux/types.h>

#include <linux/string.h>

#include <linux/memblock.h>

#include <asm/setup.h>

#include <asm/mach-types.h>

#include <asm/mach/arch.h>

#include "common.h"

#include "devices.h"

static void __init

fixup_clep7312(struct tag *tags, char **cmdline)

{

	memblock_add(0xc0000000, 0x01000000);

}

MACHINE_START(CLEP7212, "Cirrus Logic 7212/7312")

	/* Maintainer: Nobody */

	.atag_offset	= 0x0100,

	.fixup		= fixup_clep7312,

	.map_io		= clps711x_map_io,

	.init_irq	= clps711x_init_irq,

	.init_time	= clps711x_timer_init,

	.init_machine	= clps711x_devices_init,

	.restart	= clps711x_restart,

MACHINE_END

/*

 *  Copyright (C) 2000, 2001 Blue Mug, Inc.  All Rights Reserved.

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 */

#include <linux/init.h>

#include <linux/gpio.h>

#include <linux/delay.h>

#include <linux/memblock.h>

#include <linux/types.h>

#include <linux/i2c-gpio.h>

#include <linux/interrupt.h>

#include <linux/platform_device.h>

#include <linux/pwm.h>

#include <linux/pwm_backlight.h>

#include <linux/memblock.h>

#include <linux/mtd/physmap.h>

#include <linux/mtd/partitions.h>

#include <asm/setup.h>

#include <asm/mach/map.h>

#include <asm/mach/arch.h>

#include <asm/mach-types.h>

#include <video/platform_lcd.h>

#include <mach/hardware.h>

#include "common.h"

#include "devices.h"

#define VIDEORAM_SIZE		SZ_128K

#define EDB7211_LCD_DC_DC_EN	CLPS711X_GPIO(3, 1)

#define EDB7211_LCDEN		CLPS711X_GPIO(3, 2)

#define EDB7211_LCDBL		CLPS711X_GPIO(3, 3)

#define EDB7211_I2C_SDA		CLPS711X_GPIO(3, 4)

#define EDB7211_I2C_SCL		CLPS711X_GPIO(3, 5)

#define EDB7211_FLASH0_BASE	(CS0_PHYS_BASE)

#define EDB7211_FLASH1_BASE	(CS1_PHYS_BASE)

#define EDB7211_CS8900_BASE	(CS2_PHYS_BASE + 0x300)

#define EDB7211_CS8900_IRQ	(IRQ_EINT3)

/* The extra 8 lines of the keyboard matrix */

#define EDB7211_EXTKBD_BASE	(CS3_PHYS_BASE)

static struct i2c_gpio_platform_data edb7211_i2c_pdata __initdata = {

	.sda_pin	= EDB7211_I2C_SDA,

	.scl_pin	= EDB7211_I2C_SCL,

	.scl_is_output_only = 1,

};

static struct resource edb7211_cs8900_resource[] __initdata = {

	DEFINE_RES_MEM(EDB7211_CS8900_BASE, SZ_1K),

	DEFINE_RES_IRQ(EDB7211_CS8900_IRQ),

};

static struct mtd_partition edb7211_flash_partitions[] __initdata = {

	{

		.name	= "Flash",

		.offset	= 0,

		.size	= MTDPART_SIZ_FULL,

	},

};

static struct physmap_flash_data edb7211_flash_pdata __initdata = {

	.width		= 4,

	.parts		= edb7211_flash_partitions,

	.nr_parts	= ARRAY_SIZE(edb7211_flash_partitions),

};

static struct resource edb7211_flash_resources[] __initdata = {

	DEFINE_RES_MEM(EDB7211_FLASH0_BASE, SZ_8M),

	DEFINE_RES_MEM(EDB7211_FLASH1_BASE, SZ_8M),

};

static struct platform_device edb7211_flash_pdev __initdata = {

	.name		= "physmap-flash",

	.id		= 0,

	.resource	= edb7211_flash_resources,

	.num_resources	= ARRAY_SIZE(edb7211_flash_resources),

	.dev	= {

		.platform_data	= &edb7211_flash_pdata,

	},

};

static void edb7211_lcd_power_set(struct plat_lcd_data *pd, unsigned int power)

{

	if (power) {

		gpio_set_value(EDB7211_LCDEN, 1);

		udelay(100);

		gpio_set_value(EDB7211_LCD_DC_DC_EN, 1);

	} else {

		gpio_set_value(EDB7211_LCD_DC_DC_EN, 0);

		udelay(100);

		gpio_set_value(EDB7211_LCDEN, 0);

	}

}

static struct plat_lcd_data edb7211_lcd_power_pdata = {

	.set_power	= edb7211_lcd_power_set,

};

static struct pwm_lookup edb7211_pwm_lookup[] = {

	PWM_LOOKUP("clps711x-pwm", 0, "pwm-backlight.0", NULL,

		   0, PWM_POLARITY_NORMAL),

};

static struct platform_pwm_backlight_data pwm_bl_pdata = {

	.dft_brightness	= 0x01,

	.max_brightness	= 0x0f,

	.enable_gpio	= EDB7211_LCDBL,

};

static struct resource clps711x_pwm_res =

	DEFINE_RES_MEM(CLPS711X_PHYS_BASE + PMPCON, SZ_4);

static struct gpio edb7211_gpios[] __initconst = {

	{ EDB7211_LCD_DC_DC_EN,	GPIOF_OUT_INIT_LOW,	"LCD DC-DC" },

	{ EDB7211_LCDEN,	GPIOF_OUT_INIT_LOW,	"LCD POWER" },

};

/* Reserve screen memory region at the start of main system memory. */

static void __init edb7211_reserve(void)

{

	memblock_reserve(PHYS_OFFSET, VIDEORAM_SIZE);

}

static void __init

fixup_edb7211(struct tag *tags, char **cmdline)

{

	/*

	 * Bank start addresses are not present in the information

	 * passed in from the boot loader.  We could potentially

	 * detect them, but instead we hard-code them.

	 *

	 * Banks sizes _are_ present in the param block, but we're

	 * not using that information yet.

	 */

	memblock_add(0xc0000000, SZ_8M);

	memblock_add(0xc1000000, SZ_8M);

}

static void __init edb7211_init_late(void)

{

	gpio_request_array(edb7211_gpios, ARRAY_SIZE(edb7211_gpios));

	platform_device_register(&edb7211_flash_pdev);

	platform_device_register_data(NULL, "platform-lcd", 0,

				      &edb7211_lcd_power_pdata,

				      sizeof(edb7211_lcd_power_pdata));

	platform_device_register_simple("clps711x-pwm", PLATFORM_DEVID_NONE,

					&clps711x_pwm_res, 1);

	pwm_add_table(edb7211_pwm_lookup, ARRAY_SIZE(edb7211_pwm_lookup));

	platform_device_register_data(&platform_bus, "pwm-backlight", 0,

				      &pwm_bl_pdata, sizeof(pwm_bl_pdata));

	platform_device_register_simple("video-clps711x", 0, NULL, 0);

	platform_device_register_simple("cs89x0", 0, edb7211_cs8900_resource,

					ARRAY_SIZE(edb7211_cs8900_resource));

	platform_device_register_data(NULL, "i2c-gpio", 0,

				      &edb7211_i2c_pdata,

				      sizeof(edb7211_i2c_pdata));

}

MACHINE_START(EDB7211, "CL-EDB7211 (EP7211 eval board)")

	/* Maintainer: Jon McClintock */

	.atag_offset	= VIDEORAM_SIZE + 0x100,

	.fixup		= fixup_edb7211,

	.reserve	= edb7211_reserve,

	.map_io		= clps711x_map_io,

	.init_irq	= clps711x_init_irq,

	.init_time	= clps711x_timer_init,

	.init_machine	= clps711x_devices_init,

	.init_late	= edb7211_init_late,

	.restart	= clps711x_restart,

MACHINE_END