AVR32: Resource management rewrite
authorHaavard Skinnemoen <hskinnemoen@atmel.com>
Sun, 19 Nov 2006 17:06:53 +0000 (18:06 +0100)
committerHaavard Skinnemoen <hskinnemoen@atmel.com>
Sat, 14 Apr 2007 13:20:27 +0000 (15:20 +0200)
Rewrite the resource management code (i.e. I/O memory, clock gating,
gpio) so it doesn't depend on any global state. This is necessary
because this code is heavily used before relocation to RAM, so we
can't write to any global variables.

As an added bonus, this makes u-boot's memory footprint a bit smaller,
although some functionality has been left out; all clocks are enabled
all the time, and there's no checking for gpio line conflicts.

Signed-off-by: Haavard Skinnemoen <hskinnemoen@atmel.com>
26 files changed:
board/atmel/atstk1000/atstk1000.c
cpu/at32ap/Makefile
cpu/at32ap/at32ap7000/Makefile
cpu/at32ap/at32ap7000/devices.c [deleted file]
cpu/at32ap/at32ap7000/gpio.c [new file with mode: 0644]
cpu/at32ap/at32ap7000/hebi.c [deleted file]
cpu/at32ap/cpu.c
cpu/at32ap/device.c [deleted file]
cpu/at32ap/hsdramc.c
cpu/at32ap/hsdramc1.h
cpu/at32ap/hsmc3.h
cpu/at32ap/interrupts.c
cpu/at32ap/pio.c
cpu/at32ap/pio2.h
cpu/at32ap/pm.c
cpu/at32ap/sm.h
drivers/atmel_usart.c
drivers/atmel_usart.h
include/asm-avr32/arch-at32ap7000/clk.h [new file with mode: 0644]
include/asm-avr32/arch-at32ap7000/gpio.h [new file with mode: 0644]
include/asm-avr32/arch-at32ap7000/hmatrix2.h
include/asm-avr32/arch-at32ap7000/platform.h [deleted file]
include/asm-avr32/global_data.h
include/configs/atstk1002.h
lib_avr32/avr32_linux.c
lib_avr32/board.c

index 4d737d293adc540fec06931bf9e03f027d49c141..8210bc60e80a63becf5f59d15162a200cb003d45 100644 (file)
@@ -23,6 +23,8 @@
 
 #include <asm/io.h>
 #include <asm/sdram.h>
+#include <asm/arch/gpio.h>
+#include <asm/arch/hmatrix2.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
@@ -40,6 +42,17 @@ static const struct sdram_info sdram = {
        .txsr           = 5,
 };
 
+int board_early_init_f(void)
+{
+       /* Set the SDRAM_ENABLE bit in the HEBI SFR */
+       hmatrix2_writel(SFR4, 1 << 1);
+
+       gpio_enable_ebi();
+       gpio_enable_usart1();
+
+       return 0;
+}
+
 void board_init_memories(void)
 {
        gd->sdram_size = sdram_init(&sdram);
index f62ec8bc9b2627d8cff712c2ffb51c01da7ec6a5..3f1bb07b3e2c08b80150097e28936a723a1ab19a 100644 (file)
@@ -30,7 +30,7 @@ LIB   := $(obj)lib$(CPU).a
 START  := start.o
 SOBJS  := entry.o
 COBJS  := cpu.o hsdramc.o exception.o cache.o
-COBJS  += interrupts.o device.o pm.o pio.o
+COBJS  += interrupts.o pio.o
 SRCS   := $(START:.o=.S) $(SOBJS:.o=.S) $(COBJS:.o=.c)
 OBJS   := $(addprefix $(obj),$(SOBJS) $(COBJS))
 START  := $(addprefix $(obj),$(START))
index 2ed74d2508cd8f508f5bd839e3d193e4b7ce7e55..d2767121184acbe3b48127452e20695299065a40 100644 (file)
@@ -24,7 +24,7 @@ include $(TOPDIR)/config.mk
 
 LIB    := $(obj)lib$(SOC).a
 
-COBJS  := hebi.o devices.o
+COBJS  := gpio.o
 SRCS   := $(SOBJS:.o=.S) $(COBJS:.o=.c)
 OBJS   := $(addprefix $(obj),$(SOBJS) $(COBJS))
 
diff --git a/cpu/at32ap/at32ap7000/devices.c b/cpu/at32ap/at32ap7000/devices.c
deleted file mode 100644 (file)
index 8b216e9..0000000
+++ /dev/null
@@ -1,448 +0,0 @@
-/*
- * Copyright (C) 2006 Atmel Corporation
- *
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * 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 <common.h>
-
-#include <asm/arch/memory-map.h>
-#include <asm/arch/platform.h>
-
-#include "../sm.h"
-
-#define ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
-
-const struct clock_domain chip_clock[] = {
-       [CLOCK_CPU] = {
-               .reg    = SM_PM_CPU_MASK,
-               .id     = CLOCK_CPU,
-               .bridge = NO_DEVICE,
-       },
-       [CLOCK_HSB] = {
-               .reg    = SM_PM_HSB_MASK,
-               .id     = CLOCK_HSB,
-               .bridge = NO_DEVICE,
-       },
-       [CLOCK_PBA] = {
-               .reg    = SM_PM_PBA_MASK,
-               .id     = CLOCK_PBA,
-               .bridge = DEVICE_PBA_BRIDGE,
-       },
-       [CLOCK_PBB] = {
-               .reg    = SM_PM_PBB_MASK,
-               .id     = CLOCK_PBB,
-               .bridge = DEVICE_PBB_BRIDGE,
-       },
-};
-
-static const struct resource hebi_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 0 },
-               },
-       }, {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBB, 13 },
-               },
-       }, {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBB, 14 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio   = { 27, DEVICE_PIOE, GPIO_FUNC_A, 0 },
-               },
-       },
-};
-static const struct resource pba_bridge_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 1 },
-               }
-       }, {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       /* HSB-HSB Bridge */
-                       .clock  = { CLOCK_HSB, 4 },
-               },
-       },
-};
-static const struct resource pbb_bridge_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 2 },
-               },
-       },
-};
-static const struct resource hramc_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 3 },
-               },
-       },
-};
-static const struct resource pioa_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 10 },
-               },
-       },
-};
-static const struct resource piob_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 11 },
-               },
-       },
-};
-static const struct resource pioc_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 12 },
-               },
-       },
-};
-static const struct resource piod_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 13 },
-               },
-       },
-};
-static const struct resource pioe_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 14 },
-               },
-       },
-};
-static const struct resource sm_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBB, 0 },
-               },
-       },
-};
-static const struct resource intc_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock = { CLOCK_PBB, 1 },
-               },
-       },
-};
-static const struct resource hmatrix_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock = { CLOCK_PBB, 2 },
-               },
-       },
-};
-#if defined(CFG_HPDC)
-static const struct resource hpdc_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 16 },
-               },
-       },
-};
-#endif
-#if defined(CFG_MACB0)
-static const struct resource macb0_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 8 },
-               },
-       }, {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBB, 6 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio   = { 19, DEVICE_PIOC, GPIO_FUNC_A, 0 },
-               },
-       },
-};
-#endif
-#if defined(CFG_MACB1)
-static const struct resource macb1_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 9 },
-               },
-       }, {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBB, 7 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio   = { 12, DEVICE_PIOC, GPIO_FUNC_B, 19 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio   = { 14, DEVICE_PIOD, GPIO_FUNC_B, 2 },
-               },
-       },
-};
-#endif
-#if defined(CFG_LCDC)
-static const struct resource lcdc_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 7 },
-               },
-       },
-};
-#endif
-#if defined(CFG_USART0)
-static const struct resource usart0_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 3 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio = { 2, DEVICE_PIOA, GPIO_FUNC_B, 8 },
-               },
-       },
-};
-#endif
-#if defined(CFG_USART1)
-static const struct resource usart1_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 4 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio = { 2, DEVICE_PIOA, GPIO_FUNC_A, 17 },
-               },
-       },
-};
-#endif
-#if defined(CFG_USART2)
-static const struct resource usart2_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 5 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio = { 2, DEVICE_PIOB, GPIO_FUNC_B, 26 },
-               },
-       },
-};
-#endif
-#if defined(CFG_USART3)
-static const struct resource usart3_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBA, 6 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio = { 2, DEVICE_PIOB, GPIO_FUNC_B, 17 },
-               },
-       },
-};
-#endif
-#if defined(CFG_MMCI)
-static const struct resource mmci_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_PBB, 9 },
-               },
-       }, {
-               .type   = RESOURCE_GPIO,
-               .u      = {
-                       .gpio = { 6, DEVICE_PIOA, GPIO_FUNC_A, 10 },
-               },
-       },
-};
-#endif
-#if defined(CFG_DMAC)
-static const struct resource dmac_resource[] = {
-       {
-               .type   = RESOURCE_CLOCK,
-               .u      = {
-                       .clock  = { CLOCK_HSB, 10 },
-               },
-       },
-};
-#endif
-
-const struct device chip_device[] = {
-       [DEVICE_HEBI] = {
-               .regs           = (void *)HSMC_BASE,
-               .nr_resources   = ARRAY_SIZE(hebi_resource),
-               .resource       = hebi_resource,
-       },
-       [DEVICE_PBA_BRIDGE] = {
-               .nr_resources   = ARRAY_SIZE(pba_bridge_resource),
-               .resource       = pba_bridge_resource,
-       },
-       [DEVICE_PBB_BRIDGE] = {
-               .nr_resources   = ARRAY_SIZE(pbb_bridge_resource),
-               .resource       = pbb_bridge_resource,
-       },
-       [DEVICE_HRAMC] = {
-               .nr_resources   = ARRAY_SIZE(hramc_resource),
-               .resource       = hramc_resource,
-       },
-       [DEVICE_PIOA] = {
-               .regs           = (void *)PIOA_BASE,
-               .nr_resources   = ARRAY_SIZE(pioa_resource),
-               .resource       = pioa_resource,
-       },
-       [DEVICE_PIOB] = {
-               .regs           = (void *)PIOB_BASE,
-               .nr_resources   = ARRAY_SIZE(piob_resource),
-               .resource       = piob_resource,
-       },
-       [DEVICE_PIOC] = {
-               .regs           = (void *)PIOC_BASE,
-               .nr_resources   = ARRAY_SIZE(pioc_resource),
-               .resource       = pioc_resource,
-       },
-       [DEVICE_PIOD] = {
-               .regs           = (void *)PIOD_BASE,
-               .nr_resources   = ARRAY_SIZE(piod_resource),
-               .resource       = piod_resource,
-       },
-       [DEVICE_PIOE] = {
-               .regs           = (void *)PIOE_BASE,
-               .nr_resources   = ARRAY_SIZE(pioe_resource),
-               .resource       = pioe_resource,
-       },
-       [DEVICE_SM] = {
-               .regs           = (void *)SM_BASE,
-               .nr_resources   = ARRAY_SIZE(sm_resource),
-               .resource       = sm_resource,
-       },
-       [DEVICE_INTC] = {
-               .regs           = (void *)INTC_BASE,
-               .nr_resources   = ARRAY_SIZE(intc_resource),
-               .resource       = intc_resource,
-       },
-       [DEVICE_HMATRIX] = {
-               .regs           = (void *)HMATRIX_BASE,
-               .nr_resources   = ARRAY_SIZE(hmatrix_resource),
-               .resource       = hmatrix_resource,
-       },
-#if defined(CFG_HPDC)
-       [DEVICE_HPDC] = {
-               .nr_resources   = ARRAY_SIZE(hpdc_resource),
-               .resource       = hpdc_resource,
-       },
-#endif
-#if defined(CFG_MACB0)
-       [DEVICE_MACB0] = {
-               .regs           = (void *)MACB0_BASE,
-               .nr_resources   = ARRAY_SIZE(macb0_resource),
-               .resource       = macb0_resource,
-       },
-#endif
-#if defined(CFG_MACB1)
-       [DEVICE_MACB1] = {
-               .regs           = (void *)MACB1_BASE,
-               .nr_resources   = ARRAY_SIZE(macb1_resource),
-               .resource       = macb1_resource,
-       },
-#endif
-#if defined(CFG_LCDC)
-       [DEVICE_LCDC] = {
-               .nr_resources   = ARRAY_SIZE(lcdc_resource),
-               .resource       = lcdc_resource,
-       },
-#endif
-#if defined(CFG_USART0)
-       [DEVICE_USART0] = {
-               .regs           = (void *)USART0_BASE,
-               .nr_resources   = ARRAY_SIZE(usart0_resource),
-               .resource       = usart0_resource,
-       },
-#endif
-#if defined(CFG_USART1)
-       [DEVICE_USART1] = {
-               .regs           = (void *)USART1_BASE,
-               .nr_resources   = ARRAY_SIZE(usart1_resource),
-               .resource       = usart1_resource,
-       },
-#endif
-#if defined(CFG_USART2)
-       [DEVICE_USART2] = {
-               .regs           = (void *)USART2_BASE,
-               .nr_resources   = ARRAY_SIZE(usart2_resource),
-               .resource       = usart2_resource,
-       },
-#endif
-#if defined(CFG_USART3)
-       [DEVICE_USART3] = {
-               .regs           = (void *)USART3_BASE,
-               .nr_resources   = ARRAY_SIZE(usart3_resource),
-               .resource       = usart3_resource,
-       },
-#endif
-#if defined(CFG_MMCI)
-       [DEVICE_MMCI] = {
-               .regs           = (void *)MMCI_BASE,
-               .nr_resources   = ARRAY_SIZE(mmci_resource),
-               .resource       = mmci_resource,
-       },
-#endif
-#if defined(CFG_DMAC)
-       [DEVICE_DMAC] = {
-               .regs           = (void *)DMAC_BASE,
-               .nr_resources   = ARRAY_SIZE(dmac_resource),
-               .resource       = dmac_resource,
-       },
-#endif
-};
diff --git a/cpu/at32ap/at32ap7000/gpio.c b/cpu/at32ap/at32ap7000/gpio.c
new file mode 100644 (file)
index 0000000..a5d3ea6
--- /dev/null
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2006 Atmel Corporation
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * 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 <common.h>
+
+#include <asm/arch/gpio.h>
+
+/*
+ * Lots of small functions here. We depend on --gc-sections getting
+ * rid of the ones we don't need.
+ */
+void gpio_enable_ebi(void)
+{
+#ifdef CFG_HSDRAMC
+#ifndef CFG_SDRAM_16BIT
+       gpio_select_periph_A(GPIO_PIN_PE0, 0);
+       gpio_select_periph_A(GPIO_PIN_PE1, 0);
+       gpio_select_periph_A(GPIO_PIN_PE2, 0);
+       gpio_select_periph_A(GPIO_PIN_PE3, 0);
+       gpio_select_periph_A(GPIO_PIN_PE4, 0);
+       gpio_select_periph_A(GPIO_PIN_PE5, 0);
+       gpio_select_periph_A(GPIO_PIN_PE6, 0);
+       gpio_select_periph_A(GPIO_PIN_PE7, 0);
+       gpio_select_periph_A(GPIO_PIN_PE8, 0);
+       gpio_select_periph_A(GPIO_PIN_PE9, 0);
+       gpio_select_periph_A(GPIO_PIN_PE10, 0);
+       gpio_select_periph_A(GPIO_PIN_PE11, 0);
+       gpio_select_periph_A(GPIO_PIN_PE12, 0);
+       gpio_select_periph_A(GPIO_PIN_PE13, 0);
+       gpio_select_periph_A(GPIO_PIN_PE14, 0);
+       gpio_select_periph_A(GPIO_PIN_PE15, 0);
+#endif
+       gpio_select_periph_A(GPIO_PIN_PE26, 0);
+#endif
+}
+
+void gpio_enable_usart0(void)
+{
+       gpio_select_periph_B(GPIO_PIN_PA8, 0);
+       gpio_select_periph_B(GPIO_PIN_PA9, 0);
+}
+
+void gpio_enable_usart1(void)
+{
+       gpio_select_periph_A(GPIO_PIN_PA17, 0);
+       gpio_select_periph_A(GPIO_PIN_PA18, 0);
+}
+
+void gpio_enable_usart2(void)
+{
+       gpio_select_periph_B(GPIO_PIN_PB26, 0);
+       gpio_select_periph_B(GPIO_PIN_PB27, 0);
+}
+
+void gpio_enable_usart3(void)
+{
+       gpio_select_periph_B(GPIO_PIN_PB18, 0);
+       gpio_select_periph_B(GPIO_PIN_PB19, 0);
+}
diff --git a/cpu/at32ap/at32ap7000/hebi.c b/cpu/at32ap/at32ap7000/hebi.c
deleted file mode 100644 (file)
index 3b32adf..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2006 Atmel Corporation
- *
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * 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 <common.h>
-
-#include <asm/io.h>
-
-#include <asm/arch/hmatrix2.h>
-#include <asm/arch/memory-map.h>
-#include <asm/arch/platform.h>
-
-void cpu_enable_sdram(void)
-{
-       const struct device *hmatrix;
-
-       hmatrix = get_device(DEVICE_HMATRIX);
-
-       /* Set the SDRAM_ENABLE bit in the HEBI SFR */
-       hmatrix2_writel(hmatrix, SFR4, 1 << 1);
-}
index 37e3ea040be6a5e898801aefc2e7db3bf95da3e5..311466b781465ac45347bc5abb22f72a5b260c6c 100644 (file)
 #include <asm/sections.h>
 #include <asm/sysreg.h>
 
+#include <asm/arch/clk.h>
 #include <asm/arch/memory-map.h>
-#include <asm/arch/platform.h>
 
 #include "hsmc3.h"
+#include "sm.h"
+
+/* Sanity checks */
+#if (CFG_CLKDIV_CPU > CFG_CLKDIV_HSB)          \
+       || (CFG_CLKDIV_HSB > CFG_CLKDIV_PBA)    \
+       || (CFG_CLKDIV_HSB > CFG_CLKDIV_PBB)
+# error Constraint fCPU >= fHSB >= fPB{A,B} violated
+#endif
+#if defined(CONFIG_PLL) && ((CFG_PLL0_MUL < 1) || (CFG_PLL0_DIV < 1))
+# error Invalid PLL multiplier and/or divider
+#endif
 
 DECLARE_GLOBAL_DATA_PTR;
 
+static void pm_init(void)
+{
+       uint32_t cksel;
+
+#ifdef CONFIG_PLL
+       /* Initialize the PLL */
+       sm_writel(PM_PLL0, (SM_BF(PLLCOUNT, CFG_PLL0_SUPPRESS_CYCLES)
+                           | SM_BF(PLLMUL, CFG_PLL0_MUL - 1)
+                           | SM_BF(PLLDIV, CFG_PLL0_DIV - 1)
+                           | SM_BF(PLLOPT, CFG_PLL0_OPT)
+                           | SM_BF(PLLOSC, 0)
+                           | SM_BIT(PLLEN)));
+
+       /* Wait for lock */
+       while (!(sm_readl(PM_ISR) & SM_BIT(LOCK0))) ;
+#endif
+
+       /* Set up clocks for the CPU and all peripheral buses */
+       cksel = 0;
+       if (CFG_CLKDIV_CPU)
+               cksel |= SM_BIT(CPUDIV) | SM_BF(CPUSEL, CFG_CLKDIV_CPU - 1);
+       if (CFG_CLKDIV_HSB)
+               cksel |= SM_BIT(HSBDIV) | SM_BF(HSBSEL, CFG_CLKDIV_HSB - 1);
+       if (CFG_CLKDIV_PBA)
+               cksel |= SM_BIT(PBADIV) | SM_BF(PBASEL, CFG_CLKDIV_PBA - 1);
+       if (CFG_CLKDIV_PBB)
+               cksel |= SM_BIT(PBBDIV) | SM_BF(PBBSEL, CFG_CLKDIV_PBB - 1);
+       sm_writel(PM_CKSEL, cksel);
+
+       gd->cpu_hz = get_cpu_clk_rate();
+
+#ifdef CONFIG_PLL
+       /* Use PLL0 as main clock */
+       sm_writel(PM_MCCTRL, SM_BIT(PLLSEL));
+#endif
+}
+
 int cpu_init(void)
 {
-       const struct device *hebi;
        extern void _evba(void);
        char *p;
 
        gd->cpu_hz = CFG_OSC0_HZ;
 
-       /* fff03400: 00010001 04030402 00050005 10011103 */
-       hebi = get_device(DEVICE_HEBI);
-       hsmc3_writel(hebi, MODE0, 0x00031103);
-       hsmc3_writel(hebi, CYCLE0, 0x000c000d);
-       hsmc3_writel(hebi, PULSE0, 0x0b0a0906);
-       hsmc3_writel(hebi, SETUP0, 0x00010002);
+       /* TODO: Move somewhere else, but needs to be run before we
+        * increase the clock frequency. */
+       hsmc3_writel(MODE0, 0x00031103);
+       hsmc3_writel(CYCLE0, 0x000c000d);
+       hsmc3_writel(PULSE0, 0x0b0a0906);
+       hsmc3_writel(SETUP0, 0x00010002);
 
        pm_init();
 
        sysreg_write(EVBA, (unsigned long)&_evba);
        asm volatile("csrf      %0" : : "i"(SYSREG_EM_OFFSET));
-       gd->console_uart = get_device(CFG_CONSOLE_UART_DEV);
 
        /* Lock everything that mess with the flash in the icache */
        for (p = __flashprog_start; p <= (__flashprog_end + CFG_ICACHE_LINESZ);
diff --git a/cpu/at32ap/device.c b/cpu/at32ap/device.c
deleted file mode 100644 (file)
index 89914b6..0000000
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright (C) 2006 Atmel Corporation
- *
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * 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 <common.h>
-
-#include <asm/arch/platform.h>
-
-#include "sm.h"
-
-struct device_state {
-       int refcount;
-};
-
-static struct device_state device_state[NR_DEVICES];
-
-static int claim_resource(const struct resource *res)
-{
-       int ret = 0;
-
-       switch (res->type) {
-       case RESOURCE_GPIO:
-               ret = gpio_set_func(res->u.gpio.gpio_dev,
-                                   res->u.gpio.start,
-                                   res->u.gpio.nr_pins,
-                                   res->u.gpio.func);
-               break;
-       case RESOURCE_CLOCK:
-               ret = pm_enable_clock(res->u.clock.id, res->u.clock.index);
-               break;
-       }
-
-       return ret;
-}
-
-static void free_resource(const struct resource *res)
-{
-       switch (res->type) {
-       case RESOURCE_GPIO:
-               gpio_free(res->u.gpio.gpio_dev, res->u.gpio.start,
-                         res->u.gpio.nr_pins);
-               break;
-       case RESOURCE_CLOCK:
-               pm_disable_clock(res->u.clock.id, res->u.clock.index);
-               break;
-       }
-}
-
-static int init_dev(const struct device *dev)
-{
-       unsigned int i;
-       int ret = 0;
-
-       for (i = 0; i < dev->nr_resources; i++) {
-               ret = claim_resource(&dev->resource[i]);
-               if (ret)
-                       goto cleanup;
-       }
-
-       return 0;
-
-cleanup:
-       while (i--)
-               free_resource(&dev->resource[i]);
-
-       return ret;
-}
-
-const struct device *get_device(enum device_id devid)
-{
-       struct device_state *devstate;
-       const struct device *dev;
-       unsigned long flags;
-       int initialized = 0;
-       int ret = 0;
-
-       devstate = &device_state[devid];
-       dev = &chip_device[devid];
-
-       flags = disable_interrupts();
-       if (devstate->refcount++)
-               initialized = 1;
-       if (flags)
-               enable_interrupts();
-
-       if (!initialized)
-               ret = init_dev(dev);
-
-       return ret ? NULL : dev;
-}
-
-void put_device(const struct device *dev)
-{
-       struct device_state *devstate;
-       unsigned long devid, flags;
-
-       devid = (unsigned long)(dev - chip_device) / sizeof(struct device);
-       devstate = &device_state[devid];
-
-       flags = disable_interrupts();
-       devstate--;
-       if (!devstate) {
-               unsigned int i;
-               for (i = 0; i < dev->nr_resources; i++)
-                       free_resource(&dev->resource[i]);
-       }
-       if (flags)
-               enable_interrupts();
-}
index f36da354528daaa6fae939341cecc3126898105b..a936e03166c1d81de52c760962b642c933ee92f5 100644 (file)
 #include <asm/io.h>
 #include <asm/sdram.h>
 
-#include <asm/arch/platform.h>
+#include <asm/arch/clk.h>
+#include <asm/arch/memory-map.h>
 
 #include "hsdramc1.h"
 
-struct hsdramc {
-       const struct device *hebi;
-       void *regs;
-};
-
-static struct hsdramc hsdramc;
-
 unsigned long sdram_init(const struct sdram_info *info)
 {
        unsigned long *sdram = (unsigned long *)uncached(info->phys_addr);
@@ -44,16 +38,6 @@ unsigned long sdram_init(const struct sdram_info *info)
        unsigned long bus_hz;
        unsigned int i;
 
-       hsdramc.hebi = get_device(DEVICE_HEBI);
-       if (!hsdramc.hebi)
-               return 0;
-
-       /* FIXME: Both of these lines are complete hacks */
-       hsdramc.regs = hsdramc.hebi->regs + 0x400;
-       bus_hz = pm_get_clock_freq(hsdramc.hebi->resource[0].u.clock.id);
-
-       cpu_enable_sdram();
-
        tmp = (HSDRAMC1_BF(NC, info->col_bits - 8)
               | HSDRAMC1_BF(NR, info->row_bits - 11)
               | HSDRAMC1_BF(NB, info->bank_bits - 1)
@@ -74,7 +58,7 @@ unsigned long sdram_init(const struct sdram_info *info)
                           + info->bank_bits + 2);
 #endif
 
-       hsdramc1_writel(&hsdramc, CR, tmp);
+       hsdramc1_writel(CR, tmp);
 
        /*
         * Initialization sequence for SDRAM, from the data sheet:
@@ -87,15 +71,15 @@ unsigned long sdram_init(const struct sdram_info *info)
        /*
         * 2. A Precharge All command is issued to the SDRAM
         */
-       hsdramc1_writel(&hsdramc, MR, HSDRAMC1_MODE_BANKS_PRECHARGE);
-       hsdramc1_readl(&hsdramc, MR);
+       hsdramc1_writel(MR, HSDRAMC1_MODE_BANKS_PRECHARGE);
+       hsdramc1_readl(MR);
        writel(0, sdram);
 
        /*
         * 3. Eight auto-refresh (CBR) cycles are provided
         */
-       hsdramc1_writel(&hsdramc, MR, HSDRAMC1_MODE_AUTO_REFRESH);
-       hsdramc1_readl(&hsdramc, MR);
+       hsdramc1_writel(MR, HSDRAMC1_MODE_AUTO_REFRESH);
+       hsdramc1_readl(MR);
        for (i = 0; i < 8; i++)
                writel(0, sdram);
 
@@ -106,8 +90,8 @@ unsigned long sdram_init(const struct sdram_info *info)
         *
         * CAS from info struct, burst length 1, serial burst type
         */
-       hsdramc1_writel(&hsdramc, MR, HSDRAMC1_MODE_LOAD_MODE);
-       hsdramc1_readl(&hsdramc, MR);
+       hsdramc1_writel(MR, HSDRAMC1_MODE_LOAD_MODE);
+       hsdramc1_readl(MR);
        writel(0, sdram + (info->cas << 4));
 
        /*
@@ -117,9 +101,9 @@ unsigned long sdram_init(const struct sdram_info *info)
         * From the timing diagram, it looks like tMRD is 3
         * cycles...try a dummy read from the peripheral bus.
         */
-       hsdramc1_readl(&hsdramc, MR);
-       hsdramc1_writel(&hsdramc, MR, HSDRAMC1_MODE_NORMAL);
-       hsdramc1_readl(&hsdramc, MR);
+       hsdramc1_readl(MR);
+       hsdramc1_writel(MR, HSDRAMC1_MODE_NORMAL);
+       hsdramc1_readl(MR);
        writel(0, sdram);
 
        /*
@@ -128,7 +112,8 @@ unsigned long sdram_init(const struct sdram_info *info)
         *
         * 15.6 us is a typical value for a burst of length one
         */
-       hsdramc1_writel(&hsdramc, TR, (156 * (bus_hz / 1000)) / 10000);
+       bus_hz = get_sdram_clk_rate();
+       hsdramc1_writel(TR, (156 * (bus_hz / 1000)) / 10000);
 
        printf("SDRAM: %u MB at address 0x%08lx\n",
               sdram_size >> 20, info->phys_addr);
index ce229bca1fbb834748734058d571d8c353611980..305d2cb5d39a6b9ebd9ccb1923636a1f533cdb00 100644 (file)
         | HSDRAMC1_BF(name,value))
 
 /* Register access macros */
-#define hsdramc1_readl(port,reg)                               \
-       readl((port)->regs + HSDRAMC1_##reg)
-#define hsdramc1_writel(port,reg,value)                                \
-       writel((value), (port)->regs + HSDRAMC1_##reg)
+#define hsdramc1_readl(reg)                                    \
+       readl((void *)HSDRAMC_BASE + HSDRAMC1_##reg)
+#define hsdramc1_writel(reg,value)                             \
+       writel((value), (void *)HSDRAMC_BASE + HSDRAMC1_##reg)
 
 #endif /* __ASM_AVR32_HSDRAMC1_H__ */
index ec78cee7147a571aa38935dc5eed2405a09da9a0..ca533b922edaa22e4d5bafd3a82f3dfa96d7115e 100644 (file)
         | HSMC3_BF(name,value))
 
 /* Register access macros */
-#define hsmc3_readl(port,reg)                                  \
-       readl((port)->regs + HSMC3_##reg)
-#define hsmc3_writel(port,reg,value)                           \
-       writel((value), (port)->regs + HSMC3_##reg)
+#define hsmc3_readl(reg)                                       \
+       readl((void *)HSMC_BASE + HSMC3_##reg)
+#define hsmc3_writel(reg,value)                                        \
+       writel((value), (void *)HSMC_BASE + HSMC3_##reg)
 
 #endif /* __CPU_AT32AP_HSMC3_H__ */
index d720cfa942b32edc9622326aa7ae5fa8421de009..85420a4248a89c5a3d6074031b346cec6854c98d 100644 (file)
@@ -27,7 +27,7 @@
 #include <asm/processor.h>
 #include <asm/sysreg.h>
 
-#include <asm/arch/platform.h>
+#include <asm/arch/memory-map.h>
 
 #define HANDLER_MASK   0x00ffffff
 #define INTLEV_SHIFT   30
@@ -44,8 +44,6 @@ volatile unsigned long timer_overflow;
  */
 static unsigned long tb_factor;
 
-static const struct device *intc_dev;
-
 unsigned long get_tbclk(void)
 {
        return gd->cpu_hz;
@@ -126,7 +124,7 @@ static int set_interrupt_handler(unsigned int nr, void (*handler)(void),
 
        intpr = (handler_addr & HANDLER_MASK);
        intpr |= (priority & INTLEV_MASK) << INTLEV_SHIFT;
-       writel(intpr, intc_dev->regs + 4 * nr);
+       writel(intpr, (void *)INTC_BASE + 4 * nr);
 
        return 0;
 }
@@ -143,10 +141,7 @@ void timer_init(void)
        do_div(tmp, gd->cpu_hz);
        tb_factor = (u32)tmp;
 
-       intc_dev = get_device(DEVICE_INTC);
-
-       if (!intc_dev
-           || set_interrupt_handler(0, &timer_interrupt_handler, 3))
+       if (set_interrupt_handler(0, &timer_interrupt_handler, 3))
                return;
 
        /* For all practical purposes, this gives us an overflow interrupt */
index 8b6c3a35df505a6510d85445e1bbc74798cee318..9ba0b8ea8b26f189d1c39042908a7939dc570905 100644 (file)
  */
 #include <common.h>
 
-#include <asm/errno.h>
 #include <asm/io.h>
-#include <asm/arch/platform.h>
+#include <asm/arch/gpio.h>
+#include <asm/arch/memory-map.h>
 
 #include "pio2.h"
 
-struct pio_state {
-       const struct device *dev;
-       u32 alloc_mask;
-};
-
-static struct pio_state pio_state[CFG_NR_PIOS];
-
-int gpio_set_func(enum device_id gpio_devid, unsigned int start,
-                 unsigned int nr_pins, enum gpio_func func)
+void gpio_select_periph_A(unsigned int pin, int use_pullup)
 {
-       const struct device *gpio;
-       struct pio_state *state;
-       u32 mask;
-
-       state = &pio_state[gpio_devid - DEVICE_PIOA];
-
-       gpio = get_device(gpio_devid);
-       if (!gpio)
-               return -EBUSY;
-
-       state->dev = gpio;
-       mask = ((1 << nr_pins) - 1) << start;
-
-       if (mask & state->alloc_mask) {
-               put_device(gpio);
-               return -EBUSY;
-       }
-       state->alloc_mask |= mask;
-
-       switch (func) {
-       case GPIO_FUNC_GPIO:
-               /* TODO */
-               return -EINVAL;
-       case GPIO_FUNC_A:
-               pio2_writel(gpio, ASR, mask);
-               pio2_writel(gpio, PDR, mask);
-               pio2_writel(gpio, PUDR, mask);
-               break;
-       case GPIO_FUNC_B:
-               pio2_writel(gpio, BSR, mask);
-               pio2_writel(gpio, PDR, mask);
-               pio2_writel(gpio, PUDR, mask);
-               break;
-       }
-
-       return 0;
+       void *base = gpio_pin_to_addr(pin);
+       uint32_t mask = 1 << (pin & 0x1f);
+
+       if (!base)
+               panic("Invalid GPIO pin %u\n", pin);
+
+       pio2_writel(base, ASR, mask);
+       pio2_writel(base, PDR, mask);
+       if (use_pullup)
+               pio2_writel(base, PUER, mask);
+       else
+               pio2_writel(base, PUDR, mask);
 }
 
-void gpio_free(enum device_id gpio_devid, unsigned int start,
-              unsigned int nr_pins)
+void gpio_select_periph_B(unsigned int pin, int use_pullup)
 {
-       const struct device *gpio;
-       struct pio_state *state;
-       u32 mask;
-
-       state = &pio_state[gpio_devid - DEVICE_PIOA];
-       gpio = state->dev;
-       mask = ((1 << nr_pins) - 1) << start;
-
-       pio2_writel(gpio, ODR, mask);
-       pio2_writel(gpio, PER, mask);
-
-       state->alloc_mask &= ~mask;
-       put_device(gpio);
+       void *base = gpio_pin_to_addr(pin);
+       uint32_t mask = 1 << (pin & 0x1f);
+
+       if (!base)
+               panic("Invalid GPIO pin %u\n", pin);
+
+       pio2_writel(base, BSR, mask);
+       pio2_writel(base, PDR, mask);
+       if (use_pullup)
+               pio2_writel(base, PUER, mask);
+       else
+               pio2_writel(base, PUDR, mask);
 }
index 6b79de3c72bec3fa71f8bbd6599921aff3bff694..9719ea8c433557cb16c9096d4c3fb91912b008e1 100644 (file)
@@ -36,9 +36,9 @@
 #define PIO2_OWSR                              0x00a8
 
 /* Register access macros */
-#define pio2_readl(port,reg)                           \
-       readl((port)->regs + PIO2_##reg)
-#define pio2_writel(port,reg,value)                    \
-       writel((value), (port)->regs + PIO2_##reg)
+#define pio2_readl(base,reg)                           \
+       readl((void *)base + PIO2_##reg)
+#define pio2_writel(base,reg,value)                    \
+       writel((value), (void *)base + PIO2_##reg)
 
 #endif /* __CPU_AT32AP_PIO2_H__ */
index 01ac325ee8f60c372e87eacf24b927e7efa607e0..c78d547f85e00d06758dbdd7a5a819f141bf66b5 100644 (file)
 #include <asm/io.h>
 
 #include <asm/arch/memory-map.h>
-#include <asm/arch/platform.h>
 
 #include "sm.h"
 
-/* Sanity checks */
-#if (CFG_CLKDIV_CPU > CFG_CLKDIV_HSB)          \
-       || (CFG_CLKDIV_HSB > CFG_CLKDIV_PBA)    \
-       || (CFG_CLKDIV_HSB > CFG_CLKDIV_PBB)
-# error Constraint fCPU >= fHSB >= fPB{A,B} violated
-#endif
-#if defined(CONFIG_PLL) && ((CFG_PLL0_MUL < 1) || (CFG_PLL0_DIV < 1))
-# error Invalid PLL multiplier and/or divider
-#endif
-
-DECLARE_GLOBAL_DATA_PTR;
-
-struct clock_domain_state {
-       const struct device *bridge;
-       unsigned long freq;
-       u32 mask;
-};
-static struct clock_domain_state ckd_state[NR_CLOCK_DOMAINS];
-
-int pm_enable_clock(enum clock_domain_id id, unsigned int index)
-{
-       const struct clock_domain *ckd = &chip_clock[id];
-       struct clock_domain_state *state = &ckd_state[id];
-
-       if (ckd->bridge != NO_DEVICE) {
-               state->bridge = get_device(ckd->bridge);
-               if (!state->bridge)
-                       return -EBUSY;
-       }
-
-       state->mask |= 1 << index;
-       if (gd->sm)
-               writel(state->mask, gd->sm->regs + ckd->reg);
-
-       return 0;
-}
-
-void pm_disable_clock(enum clock_domain_id id, unsigned int index)
-{
-       const struct clock_domain *ckd = &chip_clock[id];
-       struct clock_domain_state *state = &ckd_state[id];
-
-       state->mask &= ~(1 << index);
-       if (gd->sm)
-               writel(state->mask, gd->sm->regs + ckd->reg);
-
-       if (ckd->bridge)
-               put_device(state->bridge);
-}
-
-unsigned long pm_get_clock_freq(enum clock_domain_id domain)
-{
-       return ckd_state[domain].freq;
-}
-
-void pm_init(void)
-{
-       uint32_t cksel = 0;
-       unsigned long main_clock;
-
-       /* Make sure we don't disable any device we're already using */
-       get_device(DEVICE_HRAMC);
-       get_device(DEVICE_HEBI);
-
-       /* Enable the PICO as well */
-       ckd_state[CLOCK_CPU].mask |= 1;
-
-       gd->sm = get_device(DEVICE_SM);
-       if (!gd->sm)
-               panic("Unable to claim system manager device!\n");
-
-       /* Disable any devices that haven't been explicitly claimed */
-       sm_writel(gd->sm, PM_PBB_MASK, ckd_state[CLOCK_PBB].mask);
-       sm_writel(gd->sm, PM_PBA_MASK, ckd_state[CLOCK_PBA].mask);
-       sm_writel(gd->sm, PM_HSB_MASK, ckd_state[CLOCK_HSB].mask);
-       sm_writel(gd->sm, PM_CPU_MASK, ckd_state[CLOCK_CPU].mask);
 
 #ifdef CONFIG_PLL
-       /* Initialize the PLL */
-       main_clock = (CFG_OSC0_HZ / CFG_PLL0_DIV) * CFG_PLL0_MUL;
-
-       sm_writel(gd->sm, PM_PLL0, (SM_BF(PLLCOUNT, CFG_PLL0_SUPPRESS_CYCLES)
-                                   | SM_BF(PLLMUL, CFG_PLL0_MUL - 1)
-                                   | SM_BF(PLLDIV, CFG_PLL0_DIV - 1)
-                                   | SM_BF(PLLOPT, CFG_PLL0_OPT)
-                                   | SM_BF(PLLOSC, 0)
-                                   | SM_BIT(PLLEN)));
-
-       /* Wait for lock */
-       while (!(sm_readl(gd->sm, PM_ISR) & SM_BIT(LOCK0))) ;
+#define MAIN_CLK_RATE ((CFG_OSC0_HZ / CFG_PLL0_DIV) * CFG_PLL0_MUL)
 #else
-       main_clock = CFG_OSC0_HZ;
+#define MAIN_CLK_RATE (CFG_OSC0_HZ)
 #endif
 
-       /* Set up clocks for the CPU and all peripheral buses */
-       if (CFG_CLKDIV_CPU) {
-               cksel |= SM_BIT(CPUDIV) | SM_BF(CPUSEL, CFG_CLKDIV_CPU - 1);
-               ckd_state[CLOCK_CPU].freq = main_clock / (1 << CFG_CLKDIV_CPU);
-       } else {
-               ckd_state[CLOCK_CPU].freq = main_clock;
-       }
-       if (CFG_CLKDIV_HSB) {
-               cksel |= SM_BIT(HSBDIV) | SM_BF(HSBSEL, CFG_CLKDIV_HSB - 1);
-               ckd_state[CLOCK_HSB].freq = main_clock / (1 << CFG_CLKDIV_HSB);
-       } else {
-               ckd_state[CLOCK_HSB].freq = main_clock;
-       }
-       if (CFG_CLKDIV_PBA) {
-               cksel |= SM_BIT(PBADIV) | SM_BF(PBASEL, CFG_CLKDIV_PBA - 1);
-               ckd_state[CLOCK_PBA].freq = main_clock / (1 << CFG_CLKDIV_PBA);
-       } else {
-               ckd_state[CLOCK_PBA].freq = main_clock;
-       }
-       if (CFG_CLKDIV_PBB) {
-               cksel |= SM_BIT(PBBDIV) | SM_BF(PBBSEL, CFG_CLKDIV_PBB - 1);
-               ckd_state[CLOCK_PBB].freq = main_clock / (1 << CFG_CLKDIV_PBB);
-       } else {
-               ckd_state[CLOCK_PBB].freq = main_clock;
-       }
-       sm_writel(gd->sm, PM_CKSEL, cksel);
-
-       /* CFG_HZ currently depends on cpu_hz */
-       gd->cpu_hz = ckd_state[CLOCK_CPU].freq;
+DECLARE_GLOBAL_DATA_PTR;
 
-#ifdef CONFIG_PLL
-       /* Use PLL0 as main clock */
-       sm_writel(gd->sm, PM_MCCTRL, SM_BIT(PLLSEL));
-#endif
-}
 
 #endif /* CFG_POWER_MANAGER */
index ce81ef0a4631b0bfc438852d5682f5d3439b96fc..6492c8e81d256c52443ab526fa41476bdd9c5222 100644 (file)
         | SM_BF(name,value))
 
 /* Register access macros */
-#define sm_readl(port,reg)                             \
-       readl((port)->regs + SM_##reg)
-#define sm_writel(port,reg,value)                      \
-       writel((value), (port)->regs + SM_##reg)
+#define sm_readl(reg)                                  \
+       readl((void *)SM_BASE + SM_##reg)
+#define sm_writel(reg,value)                           \
+       writel((value), (void *)SM_BASE + SM_##reg)
 
 #endif /* __CPU_AT32AP_SM_H__ */
index 41c37683d7854fb09a5fbac0d9ec4cfbf65f74fe..f35b99730f786528de863802191a1f11e2cd3846 100644 (file)
 
 #ifdef CONFIG_ATMEL_USART
 #include <asm/io.h>
-#include <asm/arch/platform.h>
+#include <asm/arch/clk.h>
+#include <asm/arch/memory-map.h>
+
+#if defined(CONFIG_USART0)
+# define USART_ID      0
+# define USART_BASE    USART0_BASE
+#elif defined(CONFIG_USART1)
+# define USART_ID      1
+# define USART_BASE    USART1_BASE
+#elif defined(CONFIG_USART2)
+# define USART_ID      2
+# define USART_BASE    USART2_BASE
+#elif defined(CONFIG_USART3)
+# define USART_ID      3
+# define USART_BASE    USART3_BASE
+#endif
 
 #include "atmel_usart.h"
 
@@ -35,26 +50,23 @@ void serial_setbrg(void)
         * Baud Rate = --------------
         *                16 * CD
         */
-       usart_hz = pm_get_clock_freq(gd->console_uart->resource[0].u.clock.id);
+       usart_hz = get_usart_clk_rate(USART_ID);
        divisor = (usart_hz / 16 + gd->baudrate / 2) / gd->baudrate;
-       usart3_writel(gd->console_uart, BRGR, USART3_BF(CD, divisor));
+       usart3_writel(BRGR, USART3_BF(CD, divisor));
 }
 
 int serial_init(void)
 {
-       usart3_writel(gd->console_uart, CR,
-                     USART3_BIT(RSTRX) | USART3_BIT(RSTTX));
+       usart3_writel(CR, USART3_BIT(RSTRX) | USART3_BIT(RSTTX));
 
        serial_setbrg();
 
-       usart3_writel(gd->console_uart, CR,
-                     USART3_BIT(RXEN) | USART3_BIT(TXEN));
-       usart3_writel(gd->console_uart, MR,
-                     USART3_BF(USART_MODE, USART3_USART_MODE_NORMAL)
-                     | USART3_BF(USCLKS, USART3_USCLKS_MCK)
-                     | USART3_BF(CHRL, USART3_CHRL_8)
-                     | USART3_BF(PAR, USART3_PAR_NONE)
-                     | USART3_BF(NBSTOP, USART3_NBSTOP_1));
+       usart3_writel(CR, USART3_BIT(RXEN) | USART3_BIT(TXEN));
+       usart3_writel(MR, (USART3_BF(USART_MODE, USART3_USART_MODE_NORMAL)
+                          | USART3_BF(USCLKS, USART3_USCLKS_MCK)
+                          | USART3_BF(CHRL, USART3_CHRL_8)
+                          | USART3_BF(PAR, USART3_PAR_NONE)
+                          | USART3_BF(NBSTOP, USART3_NBSTOP_1)));
 
        return 0;
 }
@@ -64,8 +76,8 @@ void serial_putc(char c)
        if (c == '\n')
                serial_putc('\r');
 
-       while (!(usart3_readl(gd->console_uart, CSR) & USART3_BIT(TXRDY))) ;
-       usart3_writel(gd->console_uart, THR, c);
+       while (!(usart3_readl(CSR) & USART3_BIT(TXRDY))) ;
+       usart3_writel(THR, c);
 }
 
 void serial_puts(const char *s)
@@ -76,13 +88,13 @@ void serial_puts(const char *s)
 
 int serial_getc(void)
 {
-       while (!(usart3_readl(gd->console_uart, CSR) & USART3_BIT(RXRDY))) ;
-       return usart3_readl(gd->console_uart, RHR);
+       while (!(usart3_readl(CSR) & USART3_BIT(RXRDY))) ;
+       return usart3_readl(RHR);
 }
 
 int serial_tstc(void)
 {
-       return (usart3_readl(gd->console_uart, CSR) & USART3_BIT(RXRDY)) != 0;
+       return (usart3_readl(CSR) & USART3_BIT(RXRDY)) != 0;
 }
 
 #endif /* CONFIG_ATMEL_USART */
index fad90a8116eb69639d7bb9ebd848b8db40b618fa..af3773a99f25fada8a9467c6503ca1ef833e1ba5 100644 (file)
         | USART3_BF(name,value))
 
 /* Register access macros */
-#define usart3_readl(port,reg)                         \
-       readl((port)->regs + USART3_##reg)
-#define usart3_writel(port,reg,value)                  \
-       writel((value), (port)->regs + USART3_##reg)
+#define usart3_readl(reg)                              \
+       readl((void *)USART_BASE + USART3_##reg)
+#define usart3_writel(reg,value)                       \
+       writel((value), (void *)USART_BASE + USART3_##reg)
 
 #endif /* __DRIVERS_ATMEL_USART_H__ */
diff --git a/include/asm-avr32/arch-at32ap7000/clk.h b/include/asm-avr32/arch-at32ap7000/clk.h
new file mode 100644 (file)
index 0000000..4a25b17
--- /dev/null
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2006 Atmel Corporation
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * 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
+ */
+#ifndef __ASM_AVR32_ARCH_CLK_H__
+#define __ASM_AVR32_ARCH_CLK_H__
+
+#ifdef CONFIG_PLL
+#define MAIN_CLK_RATE ((CFG_OSC0_HZ / CFG_PLL0_DIV) * CFG_PLL0_MUL)
+#else
+#define MAIN_CLK_RATE (CFG_OSC0_HZ)
+#endif
+
+static inline unsigned long get_cpu_clk_rate(void)
+{
+       return MAIN_CLK_RATE >> CFG_CLKDIV_CPU;
+}
+static inline unsigned long get_hsb_clk_rate(void)
+{
+       return MAIN_CLK_RATE >> CFG_CLKDIV_HSB;
+}
+static inline unsigned long get_pba_clk_rate(void)
+{
+       return MAIN_CLK_RATE >> CFG_CLKDIV_PBA;
+}
+static inline unsigned long get_pbb_clk_rate(void)
+{
+       return MAIN_CLK_RATE >> CFG_CLKDIV_PBB;
+}
+
+/* Accessors for specific devices. More will be added as needed. */
+static inline unsigned long get_sdram_clk_rate(void)
+{
+       return get_hsb_clk_rate();
+}
+static inline unsigned long get_usart_clk_rate(unsigned int dev_id)
+{
+       return get_pba_clk_rate();
+}
+
+#endif /* __ASM_AVR32_ARCH_CLK_H__ */
diff --git a/include/asm-avr32/arch-at32ap7000/gpio.h b/include/asm-avr32/arch-at32ap7000/gpio.h
new file mode 100644 (file)
index 0000000..adec208
--- /dev/null
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2006 Atmel Corporation
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * 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
+ */
+#ifndef __ASM_AVR32_ARCH_GPIO_H__
+#define __ASM_AVR32_ARCH_GPIO_H__
+
+#include <asm/arch/memory-map.h>
+
+#define NR_GPIO_CONTROLLERS    5
+
+/*
+ * Pin numbers identifying specific GPIO pins on the chip.
+ */
+#define GPIO_PIOA_BASE (0)
+#define GPIO_PIN_PA0   (GPIO_PIOA_BASE +  0)
+#define GPIO_PIN_PA1   (GPIO_PIOA_BASE +  1)
+#define GPIO_PIN_PA2   (GPIO_PIOA_BASE +  2)
+#define GPIO_PIN_PA3   (GPIO_PIOA_BASE +  3)
+#define GPIO_PIN_PA4   (GPIO_PIOA_BASE +  4)
+#define GPIO_PIN_PA5   (GPIO_PIOA_BASE +  5)
+#define GPIO_PIN_PA6   (GPIO_PIOA_BASE +  6)
+#define GPIO_PIN_PA7   (GPIO_PIOA_BASE +  7)
+#define GPIO_PIN_PA8   (GPIO_PIOA_BASE +  8)
+#define GPIO_PIN_PA9   (GPIO_PIOA_BASE +  9)
+#define GPIO_PIN_PA10  (GPIO_PIOA_BASE + 10)
+#define GPIO_PIN_PA11  (GPIO_PIOA_BASE + 11)
+#define GPIO_PIN_PA12  (GPIO_PIOA_BASE + 12)
+#define GPIO_PIN_PA13  (GPIO_PIOA_BASE + 13)
+#define GPIO_PIN_PA14  (GPIO_PIOA_BASE + 14)
+#define GPIO_PIN_PA15  (GPIO_PIOA_BASE + 15)
+#define GPIO_PIN_PA16  (GPIO_PIOA_BASE + 16)
+#define GPIO_PIN_PA17  (GPIO_PIOA_BASE + 17)
+#define GPIO_PIN_PA18  (GPIO_PIOA_BASE + 18)
+#define GPIO_PIN_PA19  (GPIO_PIOA_BASE + 19)
+#define GPIO_PIN_PA20  (GPIO_PIOA_BASE + 20)
+#define GPIO_PIN_PA21  (GPIO_PIOA_BASE + 21)
+#define GPIO_PIN_PA22  (GPIO_PIOA_BASE + 22)
+#define GPIO_PIN_PA23  (GPIO_PIOA_BASE + 23)
+#define GPIO_PIN_PA24  (GPIO_PIOA_BASE + 24)
+#define GPIO_PIN_PA25  (GPIO_PIOA_BASE + 25)
+#define GPIO_PIN_PA26  (GPIO_PIOA_BASE + 26)
+#define GPIO_PIN_PA27  (GPIO_PIOA_BASE + 27)
+#define GPIO_PIN_PA28  (GPIO_PIOA_BASE + 28)
+#define GPIO_PIN_PA29  (GPIO_PIOA_BASE + 29)
+#define GPIO_PIN_PA30  (GPIO_PIOA_BASE + 30)
+#define GPIO_PIN_PA31  (GPIO_PIOA_BASE + 31)
+
+#define GPIO_PIOB_BASE (GPIO_PIOA_BASE + 32)
+#define GPIO_PIN_PB0   (GPIO_PIOB_BASE +  0)
+#define GPIO_PIN_PB1   (GPIO_PIOB_BASE +  1)
+#define GPIO_PIN_PB2   (GPIO_PIOB_BASE +  2)
+#define GPIO_PIN_PB3   (GPIO_PIOB_BASE +  3)
+#define GPIO_PIN_PB4   (GPIO_PIOB_BASE +  4)
+#define GPIO_PIN_PB5   (GPIO_PIOB_BASE +  5)
+#define GPIO_PIN_PB6   (GPIO_PIOB_BASE +  6)
+#define GPIO_PIN_PB7   (GPIO_PIOB_BASE +  7)
+#define GPIO_PIN_PB8   (GPIO_PIOB_BASE +  8)
+#define GPIO_PIN_PB9   (GPIO_PIOB_BASE +  9)
+#define GPIO_PIN_PB10  (GPIO_PIOB_BASE + 10)
+#define GPIO_PIN_PB11  (GPIO_PIOB_BASE + 11)
+#define GPIO_PIN_PB12  (GPIO_PIOB_BASE + 12)
+#define GPIO_PIN_PB13  (GPIO_PIOB_BASE + 13)
+#define GPIO_PIN_PB14  (GPIO_PIOB_BASE + 14)
+#define GPIO_PIN_PB15  (GPIO_PIOB_BASE + 15)
+#define GPIO_PIN_PB16  (GPIO_PIOB_BASE + 16)
+#define GPIO_PIN_PB17  (GPIO_PIOB_BASE + 17)
+#define GPIO_PIN_PB18  (GPIO_PIOB_BASE + 18)
+#define GPIO_PIN_PB19  (GPIO_PIOB_BASE + 19)
+#define GPIO_PIN_PB20  (GPIO_PIOB_BASE + 20)
+#define GPIO_PIN_PB21  (GPIO_PIOB_BASE + 21)
+#define GPIO_PIN_PB22  (GPIO_PIOB_BASE + 22)
+#define GPIO_PIN_PB23  (GPIO_PIOB_BASE + 23)
+#define GPIO_PIN_PB24  (GPIO_PIOB_BASE + 24)
+#define GPIO_PIN_PB25  (GPIO_PIOB_BASE + 25)
+#define GPIO_PIN_PB26  (GPIO_PIOB_BASE + 26)
+#define GPIO_PIN_PB27  (GPIO_PIOB_BASE + 27)
+#define GPIO_PIN_PB28  (GPIO_PIOB_BASE + 28)
+#define GPIO_PIN_PB29  (GPIO_PIOB_BASE + 29)
+#define GPIO_PIN_PB30  (GPIO_PIOB_BASE + 30)
+
+#define GPIO_PIOC_BASE (GPIO_PIOB_BASE + 32)
+#define GPIO_PIN_PC0   (GPIO_PIOC_BASE +  0)
+#define GPIO_PIN_PC1   (GPIO_PIOC_BASE +  1)
+#define GPIO_PIN_PC2   (GPIO_PIOC_BASE +  2)
+#define GPIO_PIN_PC3   (GPIO_PIOC_BASE +  3)
+#define GPIO_PIN_PC4   (GPIO_PIOC_BASE +  4)
+#define GPIO_PIN_PC5   (GPIO_PIOC_BASE +  5)
+#define GPIO_PIN_PC6   (GPIO_PIOC_BASE +  6)
+#define GPIO_PIN_PC7   (GPIO_PIOC_BASE +  7)
+#define GPIO_PIN_PC8   (GPIO_PIOC_BASE +  8)
+#define GPIO_PIN_PC9   (GPIO_PIOC_BASE +  9)
+#define GPIO_PIN_PC10  (GPIO_PIOC_BASE + 10)
+#define GPIO_PIN_PC11  (GPIO_PIOC_BASE + 11)
+#define GPIO_PIN_PC12  (GPIO_PIOC_BASE + 12)
+#define GPIO_PIN_PC13  (GPIO_PIOC_BASE + 13)
+#define GPIO_PIN_PC14  (GPIO_PIOC_BASE + 14)
+#define GPIO_PIN_PC15  (GPIO_PIOC_BASE + 15)
+#define GPIO_PIN_PC16  (GPIO_PIOC_BASE + 16)
+#define GPIO_PIN_PC17  (GPIO_PIOC_BASE + 17)
+#define GPIO_PIN_PC18  (GPIO_PIOC_BASE + 18)
+#define GPIO_PIN_PC19  (GPIO_PIOC_BASE + 19)
+#define GPIO_PIN_PC20  (GPIO_PIOC_BASE + 20)
+#define GPIO_PIN_PC21  (GPIO_PIOC_BASE + 21)
+#define GPIO_PIN_PC22  (GPIO_PIOC_BASE + 22)
+#define GPIO_PIN_PC23  (GPIO_PIOC_BASE + 23)
+#define GPIO_PIN_PC24  (GPIO_PIOC_BASE + 24)
+#define GPIO_PIN_PC25  (GPIO_PIOC_BASE + 25)
+#define GPIO_PIN_PC26  (GPIO_PIOC_BASE + 26)
+#define GPIO_PIN_PC27  (GPIO_PIOC_BASE + 27)
+#define GPIO_PIN_PC28  (GPIO_PIOC_BASE + 28)
+#define GPIO_PIN_PC29  (GPIO_PIOC_BASE + 29)
+#define GPIO_PIN_PC30  (GPIO_PIOC_BASE + 30)
+#define GPIO_PIN_PC31  (GPIO_PIOC_BASE + 31)
+
+#define GPIO_PIOD_BASE (GPIO_PIOC_BASE + 32)
+#define GPIO_PIN_PD0   (GPIO_PIOD_BASE +  0)
+#define GPIO_PIN_PD1   (GPIO_PIOD_BASE +  1)
+#define GPIO_PIN_PD2   (GPIO_PIOD_BASE +  2)
+#define GPIO_PIN_PD3   (GPIO_PIOD_BASE +  3)
+#define GPIO_PIN_PD4   (GPIO_PIOD_BASE +  4)
+#define GPIO_PIN_PD5   (GPIO_PIOD_BASE +  5)
+#define GPIO_PIN_PD6   (GPIO_PIOD_BASE +  6)
+#define GPIO_PIN_PD7   (GPIO_PIOD_BASE +  7)
+#define GPIO_PIN_PD8   (GPIO_PIOD_BASE +  8)
+#define GPIO_PIN_PD9   (GPIO_PIOD_BASE +  9)
+#define GPIO_PIN_PD10  (GPIO_PIOD_BASE + 10)
+#define GPIO_PIN_PD11  (GPIO_PIOD_BASE + 11)
+#define GPIO_PIN_PD12  (GPIO_PIOD_BASE + 12)
+#define GPIO_PIN_PD13  (GPIO_PIOD_BASE + 13)
+#define GPIO_PIN_PD14  (GPIO_PIOD_BASE + 14)
+#define GPIO_PIN_PD15  (GPIO_PIOD_BASE + 15)
+#define GPIO_PIN_PD16  (GPIO_PIOD_BASE + 16)
+#define GPIO_PIN_PD17  (GPIO_PIOD_BASE + 17)
+
+#define GPIO_PIOE_BASE (GPIO_PIOD_BASE + 32)
+#define GPIO_PIN_PE0   (GPIO_PIOE_BASE +  0)
+#define GPIO_PIN_PE1   (GPIO_PIOE_BASE +  1)
+#define GPIO_PIN_PE2   (GPIO_PIOE_BASE +  2)
+#define GPIO_PIN_PE3   (GPIO_PIOE_BASE +  3)
+#define GPIO_PIN_PE4   (GPIO_PIOE_BASE +  4)
+#define GPIO_PIN_PE5   (GPIO_PIOE_BASE +  5)
+#define GPIO_PIN_PE6   (GPIO_PIOE_BASE +  6)
+#define GPIO_PIN_PE7   (GPIO_PIOE_BASE +  7)
+#define GPIO_PIN_PE8   (GPIO_PIOE_BASE +  8)
+#define GPIO_PIN_PE9   (GPIO_PIOE_BASE +  9)
+#define GPIO_PIN_PE10  (GPIO_PIOE_BASE + 10)
+#define GPIO_PIN_PE11  (GPIO_PIOE_BASE + 11)
+#define GPIO_PIN_PE12  (GPIO_PIOE_BASE + 12)
+#define GPIO_PIN_PE13  (GPIO_PIOE_BASE + 13)
+#define GPIO_PIN_PE14  (GPIO_PIOE_BASE + 14)
+#define GPIO_PIN_PE15  (GPIO_PIOE_BASE + 15)
+#define GPIO_PIN_PE16  (GPIO_PIOE_BASE + 16)
+#define GPIO_PIN_PE17  (GPIO_PIOE_BASE + 17)
+#define GPIO_PIN_PE18  (GPIO_PIOE_BASE + 18)
+#define GPIO_PIN_PE19  (GPIO_PIOE_BASE + 19)
+#define GPIO_PIN_PE20  (GPIO_PIOE_BASE + 20)
+#define GPIO_PIN_PE21  (GPIO_PIOE_BASE + 21)
+#define GPIO_PIN_PE22  (GPIO_PIOE_BASE + 22)
+#define GPIO_PIN_PE23  (GPIO_PIOE_BASE + 23)
+#define GPIO_PIN_PE24  (GPIO_PIOE_BASE + 24)
+#define GPIO_PIN_PE25  (GPIO_PIOE_BASE + 25)
+#define GPIO_PIN_PE26  (GPIO_PIOE_BASE + 26)
+
+static inline void *gpio_pin_to_addr(unsigned int pin)
+{
+       switch (pin >> 5) {
+       case 0:
+               return (void *)PIOA_BASE;
+       case 1:
+               return (void *)PIOB_BASE;
+       case 2:
+               return (void *)PIOC_BASE;
+       case 3:
+               return (void *)PIOD_BASE;
+       case 4:
+               return (void *)PIOE_BASE;
+       default:
+               return NULL;
+       }
+}
+
+void gpio_select_periph_A(unsigned int pin, int use_pullup);
+void gpio_select_periph_B(unsigned int pin, int use_pullup);
+
+void gpio_enable_ebi(void);
+void gpio_enable_usart0(void);
+void gpio_enable_usart1(void);
+void gpio_enable_usart2(void);
+void gpio_enable_usart3(void);
+
+#endif /* __ASM_AVR32_ARCH_GPIO_H__ */
+
index e6df4b7fe33a33bcb83787d64fb2235a7ededf30..b0e787a92f9888f4ec50610ae9ad567dedb0cad1 100644 (file)
         | HMATRIX2_BF(name,value))
 
 /* Register access macros */
-#define hmatrix2_readl(port,reg)                               \
-       readl((port)->regs + HMATRIX2_##reg)
-#define hmatrix2_writel(port,reg,value)                                \
-       writel((value), (port)->regs + HMATRIX2_##reg)
+#define hmatrix2_readl(reg)                                    \
+       readl((void *)HMATRIX_BASE + HMATRIX2_##reg)
+#define hmatrix2_writel(reg,value)                             \
+       writel((value), (void *)HMATRIX_BASE + HMATRIX2_##reg)
 
 #endif /* __ASM_AVR32_HMATRIX2_H__ */
diff --git a/include/asm-avr32/arch-at32ap7000/platform.h b/include/asm-avr32/arch-at32ap7000/platform.h
deleted file mode 100644 (file)
index 7590501..0000000
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (C) 2005-2006 Atmel Corporation
- *
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * 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
- */
-#ifndef _ASM_AVR32_ARCH_PM_H
-#define _ASM_AVR32_ARCH_PM_H
-
-#include <config.h>
-
-enum clock_domain_id {
-       CLOCK_CPU,
-       CLOCK_HSB,
-       CLOCK_PBA,
-       CLOCK_PBB,
-       NR_CLOCK_DOMAINS,
-};
-
-enum resource_type {
-       RESOURCE_GPIO,
-       RESOURCE_CLOCK,
-};
-
-enum gpio_func {
-       GPIO_FUNC_GPIO,
-       GPIO_FUNC_A,
-       GPIO_FUNC_B,
-};
-
-enum device_id {
-       DEVICE_HEBI,
-       DEVICE_PBA_BRIDGE,
-       DEVICE_PBB_BRIDGE,
-       DEVICE_HRAMC,
-       /* GPIO controllers must be kept together */
-       DEVICE_PIOA,
-       DEVICE_PIOB,
-       DEVICE_PIOC,
-       DEVICE_PIOD,
-       DEVICE_PIOE,
-       DEVICE_SM,
-       DEVICE_INTC,
-       DEVICE_HMATRIX,
-#if defined(CFG_HPDC)
-       DEVICE_HPDC,
-#endif
-#if defined(CFG_MACB0)
-       DEVICE_MACB0,
-#endif
-#if defined(CFG_MACB1)
-       DEVICE_MACB1,
-#endif
-#if defined(CFG_LCDC)
-       DEVICE_LCDC,
-#endif
-#if defined(CFG_USART0)
-       DEVICE_USART0,
-#endif
-#if defined(CFG_USART1)
-       DEVICE_USART1,
-#endif
-#if defined(CFG_USART2)
-       DEVICE_USART2,
-#endif
-#if defined(CFG_USART3)
-       DEVICE_USART3,
-#endif
-#if defined(CFG_MMCI)
-       DEVICE_MMCI,
-#endif
-#if defined(CFG_DMAC)
-       DEVICE_DMAC,
-#endif
-       NR_DEVICES,
-       NO_DEVICE = -1,
-};
-
-struct resource {
-       enum resource_type type;
-       union {
-               struct {
-                       unsigned long base;
-               } iomem;
-               struct {
-                       unsigned char nr_pins;
-                       enum device_id gpio_dev;
-                       enum gpio_func func;
-                       unsigned short start;
-               } gpio;
-               struct {
-                       enum clock_domain_id id;
-                       unsigned char index;
-               } clock;
-       } u;
-};
-
-struct device {
-       void *regs;
-       unsigned int nr_resources;
-       const struct resource *resource;
-};
-
-struct clock_domain {
-       unsigned short reg;
-       enum clock_domain_id id;
-       enum device_id bridge;
-};
-
-extern const struct device chip_device[NR_DEVICES];
-extern const struct clock_domain chip_clock[NR_CLOCK_DOMAINS];
-
-/**
- * Set up PIO, clock management and I/O memory for a device.
- */
-const struct device *get_device(enum device_id devid);
-void put_device(const struct device *dev);
-
-int gpio_set_func(enum device_id gpio_devid, unsigned int start,
-                 unsigned int nr_pins, enum gpio_func func);
-void gpio_free(enum device_id gpio_devid, unsigned int start,
-              unsigned int nr_pins);
-
-void pm_init(void);
-int pm_enable_clock(enum clock_domain_id id, unsigned int index);
-void pm_disable_clock(enum clock_domain_id id, unsigned int index);
-unsigned long pm_get_clock_freq(enum clock_domain_id domain);
-
-void cpu_enable_sdram(void);
-
-#endif /* _ASM_AVR32_ARCH_PM_H */
index 01d836c6395a07d7922eb44a19b1f0e4dbc0428e..3b6769b2748739e2ae37a3ff8ef569ae125213a0 100644 (file)
@@ -35,8 +35,6 @@
 typedef        struct  global_data {
        bd_t            *bd;
        unsigned long   flags;
-       const struct device     *console_uart;
-       const struct device     *sm;
        unsigned long   baudrate;
        unsigned long   sdram_size;
        unsigned long   have_console;   /* serial_init() was called */
index 458ebabeb9a217946d39d057ed6b84a72a63126a..717f54022c976cb0d153e6df11a0f7ac4782fca8 100644 (file)
  */
 #define CFG_PLL0_OPT                   0x04
 
-#define CFG_USART1                     1
-
-#define CFG_CONSOLE_UART_DEV           DEVICE_USART1
+#undef CONFIG_USART0
+#define CONFIG_USART1                  1
+#undef CONFIG_USART2
+#undef CONFIG_USART3
 
 /* User serviceable stuff */
 #define CONFIG_CMDLINE_TAG             1
index d128dfb53f075b01b8f73616b59a4af6f4553896..6095e2ff214aac67e4741e5a36ee531e2190d157 100644 (file)
@@ -27,7 +27,7 @@
 #include <asm/addrspace.h>
 #include <asm/io.h>
 #include <asm/setup.h>
-#include <asm/arch/platform.h>
+#include <asm/arch/clk.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
@@ -133,7 +133,7 @@ static struct tag *setup_clock_tags(struct tag *params)
        params->hdr.size = tag_size(tag_clock);
        params->u.clock.clock_id = ACLOCK_HSB;
        params->u.clock.clock_flags = 0;
-       params->u.clock.clock_hz = pm_get_clock_freq(CLOCK_HSB);
+       params->u.clock.clock_hz = get_hsb_clk_rate();
 #endif
 
        return tag_next(params);
index c531eef713b464c5d0bd6fcfc0cbec7a4d12ecf9..12d0b973b889e94ffc048595c7552725a2c444cc 100644 (file)
@@ -131,6 +131,7 @@ void board_init_f(ulong unused)
        gd = &gd_data;
 
        /* Perform initialization sequence */
+       board_early_init_f();
        cpu_init();
        timer_init();
        env_init();