# # Patch managed by http://www.holgerschurig.de/patcher.html # --- /dev/null +++ linux/arch/arm/mach-pxa/poodle.c @@ -0,0 +1,216 @@ +/* + * linux/arch/arm/mach-pxa/poodle.c + * + * Support for the SHARP Poodle Board. + * + * Copyright: Lineo Japan Inc. + * + * Based on: + * linux/arch/arm/mach-pxa/lubbock.c + * + * Support for the Intel DBPXA250 Development Platform. + * + * Author: Nicolas Pitre + * Created: Jun 15, 2001 + * Copyright: MontaVista Software Inc. + * + * 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. + * + * Change Log + * 12-Dec-2002 Sharp Corporation for Poodle + * April 30, 2004: John Lenz updates to 2.6 + */ +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include + +#include "generic.h" + +static void __init scoop_init(void) +{ + +#define SCP_INIT_DATA(adr,dat) (((adr)<<16)|(dat)) +#define SCP_INIT_DATA_END ((unsigned long)-1) + static const unsigned long scp_init[] = + { + SCP_INIT_DATA(POODLE_SCP_MCR,0x0140), // 00 + SCP_INIT_DATA(POODLE_SCP_MCR,0x0100), + SCP_INIT_DATA(POODLE_SCP_CDR,0x0000), // 04 + SCP_INIT_DATA(POODLE_SCP_CPR,0x0000), // 0C + SCP_INIT_DATA(POODLE_SCP_CCR,0x0000), // 10 + SCP_INIT_DATA(POODLE_SCP_IMR,0x0000), // 18 + SCP_INIT_DATA(POODLE_SCP_IRM,0x00FF), // 14 + SCP_INIT_DATA(POODLE_SCP_ISR,0x0000), // 1C + SCP_INIT_DATA(POODLE_SCP_IRM,0x0000), + SCP_INIT_DATA(POODLE_SCP_GPCR,POODLE_SCP_IO_DIR), // 20 + SCP_INIT_DATA(POODLE_SCP_GPWR,POODLE_SCP_IO_OUT), // 24 + SCP_INIT_DATA_END + }; + int i; + for(i=0; scp_init[i] != SCP_INIT_DATA_END; i++) + { + int adr = scp_init[i] >> 16; + POODLE_SCP_REG(adr) = scp_init[i] & 0xFFFF; + } +} + +#if 0 +void resume_init(void) +{ +// MSC0 = 0x02da02da; //msc0 +// MSC1 = 0x7FFC7FFC; //msc1 +// MSC2 = 0x7FF47FFC; //msc2 + +// GPDR0=0xDB828000; +// GPDR1=0xFFB6A887; +// GPDR2=0x0001FFFF; + +// PGSR0 = 0x01008000; //Sleep State +// PGSR1 = 0x00160802; //Sleep State +// PGSR2 = 0x0001C000; //Sleep State + +#if 0 + GRER0 = (GRER0 | 1); //raising + GFER0 = (GFER0 | 1); //failing + + ICLR = 0; + + ICMR |= (1 << 10); //bit10, gpio02_80 enable + ICMR |= (1 << 8); //bit8, gpio00 enable + + ICCR = 1; //Only enabled and unmasked will bring the Cotulla out of IDLE mode. +#endif + + CKEN |= 0x03; + CKEN |= CKEN3_SSP; + CKEN |= CKEN1_PWM1; +} +#endif + +static struct resource locomo_resources[] = { + [0] = { + .start = 0x10000000, + .end = 0x10001fff, + .flags = IORESOURCE_MEM, + }, + [1] = { + .start = IRQ_GPIO(10), + .end = IRQ_GPIO(10), + .flags = IORESOURCE_IRQ, + }, +}; + +static struct platform_device locomo_device = { + .name = "locomo", + .id = 0, + .num_resources = ARRAY_SIZE(locomo_resources), + .resource = locomo_resources, +}; + +static struct platform_device *devices[] __initdata = { + &locomo_device, +}; + +static void __init poodle_init(void) +{ + int ret = 0; + + /* cpu initialize */ + /* Pgsr Register */ + PGSR0 = 0x0146dd80; + PGSR1 = 0x03bf0890; + PGSR2 = 0x0001c000; + + /* Alternate Register */ + GAFR0_L = 0x01001000; + GAFR0_U = 0x591a8010; + GAFR1_L = 0x900a8451; + GAFR1_U = 0xaaa5aaaa; + GAFR2_L = 0x8aaaaaaa; + GAFR2_U = 0x00000002; + + /* Direction Register */ + GPDR0 = 0xd3f0904c; + GPDR1 = 0xfcffb7d3; + GPDR2 = 0x0001ffff; + + /* Output Register */ + GPCR0 = 0x00000000; + GPCR1 = 0x00000000; + GPCR2 = 0x00000000; + + GPSR0 = 0x00400000; + GPSR1 = 0x00000000; + GPSR2 = 0x00000000; + + /* i2c initialize */ + //i2c_init(); + + /* scoop initialize */ + scoop_init(); + + /* initialize SSP & CS */ + /*pxa_ssp_init();*/ + + ret = platform_add_devices(devices, ARRAY_SIZE(devices)); + if (ret) { + printk(KERN_WARNING "poodle: Unable to register LoCoMo device\n"); + } +} + +static struct map_desc poodle_io_desc[] __initdata = { + /* virtual physical length */ + { 0xef700000, 0x10800000, 0x00001000, MT_DEVICE }, /* SCOOP */ + { 0xef800000, 0x00000000, 0x00800000, MT_DEVICE }, /* Boot Flash */ +}; + +static void __init poodle_map_io(void) +{ + pxa_map_io(); + iotable_init(poodle_io_desc, ARRAY_SIZE(poodle_io_desc)); + +#if 0 + /* This enables the BTUART */ + CKEN |= CKEN7_BTUART; + set_GPIO_mode(GPIO42_BTRXD_MD); + set_GPIO_mode(GPIO43_BTTXD_MD); + set_GPIO_mode(GPIO44_BTCTS_MD); + set_GPIO_mode(GPIO45_BTRTS_MD); +#endif + + /* setup sleep mode values */ + PWER = 0x00000002; + PFER = 0x00000000; + PRER = 0x00000002; + PGSR0 = 0x00008000; + PGSR1 = 0x003F0202; + PGSR2 = 0x0001C000; + PCFR |= PCFR_OPDE; +} + +MACHINE_START(POODLE, "SHARP Poodle") + BOOT_MEM(0xa0000000, 0x40000000, io_p2v(0x40000000)) + MAPIO(poodle_map_io) + INITIRQ(pxa_init_irq) + INIT_MACHINE(poodle_init) + .timer = &pxa_timer, +MACHINE_END --- linux/arch/arm/mach-pxa/Makefile~poodle_base +++ linux/arch/arm/mach-pxa/Makefile @@ -8,9 +8,10 @@ obj-$(CONFIG_PXA27x) += pxa27x.o # Specific board support -obj-$(CONFIG_ARCH_LUBBOCK) += lubbock.o +obj-$(CONFIG_ARCH_LUBBOCK) += lubbock.o obj-$(CONFIG_MACH_MAINSTONE) += mainstone.o -obj-$(CONFIG_ARCH_PXA_IDP) += idp.o +obj-$(CONFIG_ARCH_PXA_IDP) += idp.o +obj-$(CONFIG_MACH_POODLE) += poodle.o # Support for blinky lights led-y := leds.o --- linux/arch/arm/mach-pxa/Kconfig~poodle_base +++ linux/arch/arm/mach-pxa/Kconfig @@ -18,8 +18,18 @@ bool "Accelent Xscale IDP" select PXA25x +config MACH_POODLE + bool "SHARP Poodle" + select PXA25x + +config SHARP_LOCOMO + bool "SHARP LoCoMo support" + default Y + depends MACH_POODLE + endchoice + endmenu config PXA25x --- /dev/null +++ linux/include/asm-arm/arch-pxa/poodle.h @@ -0,0 +1,197 @@ +/* + * linux/include/asm-arm/arch-pxa/poodle.h + * + * (C) Copyright 2001 Lineo Japan, Inc. + * + * May be copied or modified under the terms of the GNU General Public + * License. See linux/COPYING for more information. + * + * Based on: + * + * linux/include/asm-arm/arch-sa1100/collie.h + * + * This file contains the hardware specific definitions for Collie + * + * (C) Copyright 2001 Lineo Japan, Inc. + * + * May be copied or modified under the terms of the GNU General Public + * License. See linux/COPYING for more information. + * + * ChangeLog: + * 04-06-2001 Lineo Japan, Inc. + * 04-16-2001 SHARP Corporation + * Mar 10, 2004: Update to 2.6 John Lenz + */ +#ifndef __ASM_ARCH_POODLE_H +#define __ASM_ARCH_POODLE_H 1 + + +/* + * GPIOs + */ +/* PXA GPIOs */ +#define POODLE_GPIO_ON_KEY (0) +#define POODLE_GPIO_AC_IN (1) +//#define POODLE_GPIO_nREMOCON_INT POODLE_GPIO_GPIO (15) +#define POODLE_GPIO_CO 16 +//#define POODLE_GPIO_MCP_CLK POODLE_GPIO_GPIO (21) +#define POODLE_GPIO_TP_INT (5) +#define POODLE_GPIO_WAKEUP (11) /* change battery */ +#define POODLE_GPIO_GA_INT (10) +#define POODLE_GPIO_IR_ON (22) +#define POODLE_GPIO_HP_IN (4) // ??? +#define POODLE_GPIO_CF_IRQ (17) +//#define POODLE_GPIO_CF_PRDY (17) +#define POODLE_GPIO_CF_CD (14) +#define POODLE_GPIO_CF_STSCHG (14) +#define POODLE_GPIO_SD_PWR (33) +#define POODLE_GPIO_nSD_CLK (6) +#define POODLE_GPIO_nSD_WP (7) +#define POODLE_GPIO_nSD_INT (8) +#define POODLE_GPIO_nSD_DETECT (9) +#define POODLE_GPIO_MAIN_BAT_LOW (13) +#define POODLE_GPIO_BAT_COVER (13) +#define POODLE_GPIO_ADC_TEMP_ON (21) +#define POODLE_GPIO_BYPASS_ON (36) +#define POODLE_GPIO_CHRG_ON (38) +#define POODLE_GPIO_CHRG_FULL (16) + +/* + * Interrupts + */ +/* PXA GPIOs */ +#define POODLE_IRQ_GPIO_ON_KEY IRQ_GPIO0 +#define POODLE_IRQ_GPIO_AC_IN IRQ_GPIO1 +#define POODLE_IRQ_GPIO_HP_IN IRQ_GPIO4 +//#define POODLE_IRQ_GPIO_nREMOCON_INT IRQ_GPIO15 +#define POODLE_IRQ_GPIO_CO IRQ_GPIO16 +#define POODLE_IRQ_GPIO_TP_INT IRQ_GPIO5 +#define POODLE_IRQ_GPIO_WAKEUP IRQ_GPIO11 +#define POODLE_IRQ_GPIO_GA_INT IRQ_GPIO10 +#define POODLE_IRQ_GPIO_CF_IRQ IRQ_GPIO17 +#define POODLE_IRQ_GPIO_CF_CD IRQ_GPIO14 +#define POODLE_IRQ_GPIO_nSD_INT IRQ_GPIO8 +#define POODLE_IRQ_GPIO_nSD_DETECT IRQ_GPIO9 +#define POODLE_IRQ_GPIO_MAIN_BAT_LOW IRQ_GPIO13 + + +/* + * SCOOP internal I/O mappings + * + * We have the following mapping: + * phys virt + * 10800000 ef7000000 + */ + + +#define CF_BUF_CTRL_BASE 0xef700000 +#define POODLE_SCP_REG(adr) (*(volatile unsigned short*)(CF_BUF_CTRL_BASE+(adr))) + +#define POODLE_SCP_MCR 0x00 +#define POODLE_SCP_CDR 0x04 +#define POODLE_SCP_CSR 0x08 +#define POODLE_SCP_CPR 0x0C +#define POODLE_SCP_CCR 0x10 +#define POODLE_SCP_IRR 0x14 +#define POODLE_SCP_IRM 0x14 +#define POODLE_SCP_IMR 0x18 +#define POODLE_SCP_ISR 0x1C +#define POODLE_SCP_GPCR 0x20 +#define POODLE_SCP_GPWR 0x24 +#define POODLE_SCP_GPRR 0x28 +#define POODLE_SCP_REG_MCR POODLE_SCP_REG(POODLE_SCP_MCR) +#define POODLE_SCP_REG_CDR POODLE_SCP_REG(POODLE_SCP_CDR) +#define POODLE_SCP_REG_CSR POODLE_SCP_REG(POODLE_SCP_CSR) +#define POODLE_SCP_REG_CPR POODLE_SCP_REG(POODLE_SCP_CPR) +#define POODLE_SCP_REG_CCR POODLE_SCP_REG(POODLE_SCP_CCR) +#define POODLE_SCP_REG_IRR POODLE_SCP_REG(POODLE_SCP_IRR) +#define POODLE_SCP_REG_IRM POODLE_SCP_REG(POODLE_SCP_IRM) +#define POODLE_SCP_REG_IMR POODLE_SCP_REG(POODLE_SCP_IMR) +#define POODLE_SCP_REG_ISR POODLE_SCP_REG(POODLE_SCP_ISR) +#define POODLE_SCP_REG_GPCR POODLE_SCP_REG(POODLE_SCP_GPCR) +#define POODLE_SCP_REG_GPWR POODLE_SCP_REG(POODLE_SCP_GPWR) +#define POODLE_SCP_REG_GPRR POODLE_SCP_REG(POODLE_SCP_GPRR) + +#define POODLE_SCP_GPCR_PA22 ( 1 << 12 ) +#define POODLE_SCP_GPCR_PA21 ( 1 << 11 ) +#define POODLE_SCP_GPCR_PA20 ( 1 << 10 ) +#define POODLE_SCP_GPCR_PA19 ( 1 << 9 ) +#define POODLE_SCP_GPCR_PA18 ( 1 << 8 ) +#define POODLE_SCP_GPCR_PA17 ( 1 << 7 ) +#define POODLE_SCP_GPCR_PA16 ( 1 << 6 ) +#define POODLE_SCP_GPCR_PA15 ( 1 << 5 ) +#define POODLE_SCP_GPCR_PA14 ( 1 << 4 ) +#define POODLE_SCP_GPCR_PA13 ( 1 << 3 ) +#define POODLE_SCP_GPCR_PA12 ( 1 << 2 ) +#define POODLE_SCP_GPCR_PA11 ( 1 << 1 ) + + +/* + * GPIOs + */ +#define POODLE_SCP_CHARGE_ON POODLE_SCP_GPCR_PA11 +//#define POODLE_SCP_DIAG_BOOT1 POODLE_SCP_GPCR_PA12 +//#define POODLE_SCP_DIAG_BOOT2 POODLE_SCP_GPCR_PA13 +#define POODLE_SCP_CP401 POODLE_SCP_GPCR_PA13 +//#define POODLE_SCP_MUTE_L POODLE_SCP_GPCR_PA14 +//#define POODLE_SCP_MUTE_R POODLE_SCP_GPCR_PA15 +//#define POODLE_SCP_5VON POODLE_SCP_GPCR_PA16 +//#define POODLE_SCP_AMP_ON POODLE_SCP_GPCR_PA17 +#define POODLE_SCP_VPEN POODLE_SCP_GPCR_PA18 +//#define POODLE_SCP_LB_VOL_CHG POODLE_SCP_GPCR_PA19 +#define POODLE_SCP_L_PCLK POODLE_SCP_GPCR_PA20 +#define POODLE_SCP_L_LCLK POODLE_SCP_GPCR_PA21 +#define POODLE_SCP_HS_OUT POODLE_SCP_GPCR_PA22 + +#if 0 +#define POODLE_SCP_IO_DIR ( POODLE_SCP_CHARGE_ON | POODLE_SCP_MUTE_L | POODLE_SCP_MUTE_R | \ + POODLE_SCP_5VON | POODLE_SCP_AMP_ON | POODLE_SCP_VPEN | \ + POODLE_SCP_LB_VOL_CHG ) +#define POODLE_SCP_IO_OUT ( POODLE_SCP_MUTE_L | POODLE_SCP_MUTE_R ) +#endif +#define POODLE_SCP_IO_DIR ( POODLE_SCP_VPEN | POODLE_SCP_HS_OUT ) +#define POODLE_SCP_IO_OUT ( 0 ) + + +/* + * Flash Memory mappings + * + * We have the following mapping: + * phys virt + * boot ROM 00000000 ef800000 + */ +#define FLASH_MEM_BASE 0xa0000a00 +#define FLASH_DATA(adr) (*(volatile unsigned int*)(FLASH_MEM_BASE+(adr))) +#define FLASH_DATA_F(adr) (*(volatile float32 *)(FLASH_MEM_BASE+(adr))) +#define FLASH_MAGIC_CHG(a,b,c,d) ( ( d << 24 ) | ( c << 16 ) | ( b << 8 ) | a ) + +// COMADJ +#define FLASH_COMADJ_MAJIC FLASH_MAGIC_CHG('C','M','A','D') +#define FLASH_COMADJ_MAGIC_ADR 0x00 +#define FLASH_COMADJ_DATA_ADR 0x04 + +// UUID +#define FLASH_UUID_MAJIC FLASH_MAGIC_CHG('U','U','I','D') +#define FLASH_UUID_MAGIC_ADR 0x08 +#define FLASH_UUID_DATA_ADR 0x0C + +// TOUCH PANEL +#define FLASH_TOUCH_MAJIC FLASH_MAGIC_CHG('T','U','C','H') +#define FLASH_TOUCH_MAGIC_ADR 0x1C +#define FLASH_TOUCH_XP_DATA_ADR 0x20 +#define FLASH_TOUCH_YP_DATA_ADR 0x24 +#define FLASH_TOUCH_XD_DATA_ADR 0x28 +#define FLASH_TOUCH_YD_DATA_ADR 0x2C + +// AD +#define FLASH_AD_MAJIC FLASH_MAGIC_CHG('B','V','A','D') +#define FLASH_AD_MAGIC_ADR 0x30 +#define FLASH_AD_DATA_ADR 0x34 + +// PHAD +#define FLASH_PHAD_MAJIC FLASH_MAGIC_CHG('P','H','A','D') +#define FLASH_PHAD_MAGIC_ADR 0x38 +#define FLASH_PHAD_DATA_ADR 0x3C + + +#endif /* __ASM_ARCH_POODLE_H */ --- linux/include/asm-arm/arch-pxa/irqs.h~poodle_base +++ linux/include/asm-arm/arch-pxa/irqs.h @@ -140,14 +140,41 @@ #define IRQ_S0_BVD1_STSCHG (IRQ_BOARD_END + 53) #define IRQ_S1_BVD1_STSCHG (IRQ_BOARD_END + 54) +#define IRQ_LOCOMO_START (IRQ_BOARD_END) +#define IRQ_LOCOMO_KEY (IRQ_BOARD_END + 0) +#define IRQ_LOCOMO_GPIO0 (IRQ_BOARD_END + 1) +#define IRQ_LOCOMO_GPIO1 (IRQ_BOARD_END + 2) +#define IRQ_LOCOMO_GPIO2 (IRQ_BOARD_END + 3) +#define IRQ_LOCOMO_GPIO3 (IRQ_BOARD_END + 4) +#define IRQ_LOCOMO_GPIO4 (IRQ_BOARD_END + 5) +#define IRQ_LOCOMO_GPIO5 (IRQ_BOARD_END + 6) +#define IRQ_LOCOMO_GPIO6 (IRQ_BOARD_END + 7) +#define IRQ_LOCOMO_GPIO7 (IRQ_BOARD_END + 8) +#define IRQ_LOCOMO_GPIO8 (IRQ_BOARD_END + 9) +#define IRQ_LOCOMO_GPIO9 (IRQ_BOARD_END + 10) +#define IRQ_LOCOMO_GPIO10 (IRQ_BOARD_END + 11) +#define IRQ_LOCOMO_GPIO11 (IRQ_BOARD_END + 12) +#define IRQ_LOCOMO_GPIO12 (IRQ_BOARD_END + 13) +#define IRQ_LOCOMO_GPIO13 (IRQ_BOARD_END + 14) +#define IRQ_LOCOMO_GPIO14 (IRQ_BOARD_END + 15) +#define IRQ_LOCOMO_GPIO15 (IRQ_BOARD_END + 16) +#define IRQ_LOCOMO_LT (IRQ_BOARD_END + 17) +#define IRQ_LOCOMO_SPI_RFR (IRQ_BOARD_END + 18) +#define IRQ_LOCOMO_SPI_RFW (IRQ_BOARD_END + 19) +#define IRQ_LOCOMO_SPI_OVRN (IRQ_BOARD_END + 20) +#define IRQ_LOCOMO_SPI_TEND (IRQ_BOARD_END + 21) + /* * Figure out the MAX IRQ number. * * If we have an SA1111, the max IRQ is S1_BVD1_STSCHG+1. + * If we have an LoCoMo, the max IRQ is IRQ_LOCOMO_SPI_TEND+1 * Otherwise, we have the standard IRQs only. */ #ifdef CONFIG_SA1111 #define NR_IRQS (IRQ_S1_BVD1_STSCHG + 1) +#elif defined(CONFIG_SHARP_LOCOMO) +#define NR_IRQS (IRQ_LOCOMO_SPI_TEND + 1) #elif defined(CONFIG_ARCH_LUBBOCK) || \ defined(CONFIG_MACH_MAINSTONE) #define NR_IRQS (IRQ_BOARD_END) @@ -185,3 +212,8 @@ #define MAINSTONE_S1_STSCHG_IRQ MAINSTONE_IRQ(14) #define MAINSTONE_S1_IRQ MAINSTONE_IRQ(15) +/* LoCoMo Interrupts (CONFIG_SHARP_LOCOMO) */ +#define IRQ_LOCOMO_KEY_BASE (IRQ_BOARD_START + 0) +#define IRQ_LOCOMO_GPIO_BASE (IRQ_BOARD_START + 1) +#define IRQ_LOCOMO_LT_BASE (IRQ_BOARD_START + 2) +#define IRQ_LOCOMO_SPI_BASE (IRQ_BOARD_START + 3) --- linux/arch/arm/boot/compressed/head-xscale.S~poodle_base +++ linux/arch/arm/boot/compressed/head-xscale.S @@ -56,3 +56,6 @@ mov r7, #MACH_TYPE_COTULLA_IDP #endif +#ifdef CONFIG_MACH_POODLE + mov r7, #MACH_TYPE_POODLE +#endif --- linux/arch/arm/common/locomo.c~poodle_base +++ linux/arch/arm/common/locomo.c @@ -584,12 +584,20 @@ locomo_writel(0, lchip->base + LOCOMO_KIC); /* GPIO */ - locomo_writel(0, lchip->base + LOCOMO_GPO); - locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) - , lchip->base + LOCOMO_GPE); - locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) - , lchip->base + LOCOMO_GPD); - locomo_writel(0, lchip->base + LOCOMO_GIE); + if (machine_is_collie()) { + locomo_writel(0, lchip->base + LOCOMO_GPO); + locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) + , lchip->base + LOCOMO_GPE); + locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) + , lchip->base + LOCOMO_GPD); + locomo_writel(0, lchip->base + LOCOMO_GIE); + } + if (machine_is_poodle()) { + locomo_writel(LOCOMO_GPIO(12), lchip->base + LOCOMO_GPO); + locomo_writel(0, lchip->base + LOCOMO_GPE); + locomo_writel(0, lchip->base + LOCOMO_GPD); + locomo_writel(0, lchip->base + LOCOMO_GIE); + } /* FrontLight */ locomo_writel(0, lchip->base + LOCOMO_ALS);