upgrade AVR32 to 2.6.22.1
authorImre Kaloz <kaloz@openwrt.org>
Thu, 12 Jul 2007 14:11:31 +0000 (14:11 +0000)
committerImre Kaloz <kaloz@openwrt.org>
Thu, 12 Jul 2007 14:11:31 +0000 (14:11 +0000)
SVN-Revision: 7945

target/linux/avr32-2.6/Makefile
target/linux/avr32-2.6/config/default
target/linux/avr32-2.6/patches/100-git_sync.patch

index 465d96c..f58b9e8 100644 (file)
@@ -11,7 +11,7 @@ BOARD:=avr32
 BOARDNAME:=Atmel AVR32
 FEATURES:=squashfs
 
-LINUX_VERSION:=2.6.21.5
+LINUX_VERSION:=2.6.22.1
 
 define Target/Description
   Build firmware images for ATNGW100 board
index 5bd7078..1c0f964 100644 (file)
@@ -6,11 +6,25 @@ CONFIG_AP7000_16_BIT_SMC=y
 CONFIG_AVR32=y
 CONFIG_BOARD_ATNGW100=y
 # CONFIG_BOARD_ATSTK1000 is not set
+# CONFIG_BROADCOM_PHY is not set
 # CONFIG_BT is not set
 CONFIG_CPU_AT32AP7000=y
+CONFIG_CPU_FREQ=y
+# CONFIG_CPU_FREQ_DEBUG is not set
+# CONFIG_CPU_FREQ_STAT is not set
+CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
+# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set
+CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
+# CONFIG_CPU_FREQ_GOV_POWERSAVE is not set
+# CONFIG_CPU_FREQ_GOV_USERSPACE is not set
+CONFIG_CPU_FREQ_GOV_ONDEMAND=y
+# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set
+CONFIG_CPU_FREQ_AT32AP=y
 CONFIG_DW_DMAC=y
 CONFIG_ENTRY_ADDRESS=0x90000000
+# CONFIG_FIXED_PHY is not set
 # CONFIG_GEN_RTC is not set
+# CONFIG_GPIO_DEV is not set
 # CONFIG_HZ_100 is not set
 CONFIG_HZ=250
 CONFIG_HZ_250=y
@@ -18,6 +32,7 @@ CONFIG_HZ_250=y
 # CONFIG_I2C is not set
 # CONFIG_IDE is not set
 CONFIG_INITRAMFS_SOURCE=""
+CONFIG_LEDS_GPIO=y
 CONFIG_MACB=y
 # CONFIG_MTD_ABSENT is not set
 CONFIG_MTD_BLKDEVS=y
@@ -72,11 +87,13 @@ CONFIG_MTD=y
 # CONFIG_OWNERSHIP_TRACE is not set
 CONFIG_PHYS_OFFSET=0x10000000
 CONFIG_PLATFORM_AT32AP=y
+# CONFIG_QSEMI_PHY is not set
 # CONFIG_RTC is not set
 # CONFIG_SERIAL_8250 is not set
 CONFIG_SERIAL_ATMEL_CONSOLE=y
 # CONFIG_SERIAL_ATMEL_TTYAT is not set
 CONFIG_SERIAL_ATMEL=y
+# CONFIG_SMSC_PHY is not set
 # CONFIG_SPI_AT25 is not set
 CONFIG_SPI_ATMEL=y
 # CONFIG_SPI_BITBANG is not set
index 5c5cc8e..7653c5f 100644 (file)
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c avr32-git/arch/avr32/boards/atngw100/flash.c
---- linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c  1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/boards/atngw100/flash.c       2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,95 @@
-+/*
-+ * ATNGW100 board-specific flash initialization
-+ *
-+ * Copyright (C) 2005-2006 Atmel Corporation
-+ *
-+ * 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.
-+ */
-+#include <linux/init.h>
-+#include <linux/platform_device.h>
-+#include <linux/mtd/mtd.h>
-+#include <linux/mtd/partitions.h>
-+#include <linux/mtd/physmap.h>
-+
-+#include <asm/arch/smc.h>
-+
-+static struct smc_config flash_config __initdata = {
-+      .ncs_read_setup         = 0,
-+      .nrd_setup              = 40,
-+      .ncs_write_setup        = 0,
-+      .nwe_setup              = 10,
-+
-+      .ncs_read_pulse         = 80,
-+      .nrd_pulse              = 40,
-+      .ncs_write_pulse        = 65,
-+      .nwe_pulse              = 55,
-+
-+      .read_cycle             = 120,
-+      .write_cycle            = 120,
-+
-+      .bus_width              = 2,
-+      .nrd_controlled         = 1,
-+      .nwe_controlled         = 1,
-+      .byte_write             = 1,
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/boards/atngw100/setup.c linux-avr32.git/arch/avr32/boards/atngw100/setup.c
+--- linux-2.6.22.1/arch/avr32/boards/atngw100/setup.c  2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/boards/atngw100/setup.c 2007-07-12 13:59:49.000000000 +0200
+@@ -13,6 +13,7 @@
+ #include <linux/linkage.h>
+ #include <linux/platform_device.h>
+ #include <linux/types.h>
++#include <linux/leds.h>
+ #include <linux/spi/spi.h>
+ #include <asm/io.h>
+@@ -21,6 +22,7 @@
+ #include <asm/arch/at32ap7000.h>
+ #include <asm/arch/board.h>
+ #include <asm/arch/init.h>
++#include <asm/arch/portmux.h>
+ /* Initialized by bootloader-specific startup code. */
+ struct tag *bootloader_tags __initdata;
+@@ -39,6 +41,11 @@
+       },
+ };
++static struct mci_platform_data __initdata mci0_data = {
++      .detect_pin     = GPIO_PIN_PC(25),
++      .wp_pin         = GPIO_PIN_PE(0),
 +};
 +
-+static struct mtd_partition flash_parts[] = {
-+      {
-+              .name           = "u-boot",
-+              .offset         = 0x00000000,
-+              .size           = 0x00020000,           /* 128 KiB */
-+              .mask_flags     = MTD_WRITEABLE,
-+      },
-+      {
-+              .name           = "root",
-+              .offset         = 0x00020000,
-+              .size           = 0x007d0000,
-+      },
-+      {
-+              .name           = "env",
-+              .offset         = 0x007f0000,
-+              .size           = 0x00010000,
-+              .mask_flags     = MTD_WRITEABLE,
+ /*
+  * The next two functions should go away as the boot loader is
+  * supposed to initialize the macb address registers with a valid
+@@ -100,8 +107,31 @@
+       at32_setup_serial_console(0);
+ }
++static const struct gpio_led ngw_leds[] = {
++      { .name = "sys", .gpio = GPIO_PIN_PA(16), .active_low = 1,
++              .default_trigger = "heartbeat",
 +      },
++      { .name = "a", .gpio = GPIO_PIN_PA(19), .active_low = 1, },
++      { .name = "b", .gpio = GPIO_PIN_PE(19), .active_low = 1, },
++};
++
++static const struct gpio_led_platform_data ngw_led_data = {
++      .num_leds =     ARRAY_SIZE(ngw_leds),
++      .leds =         (void *) ngw_leds,
++};
++
++static struct platform_device ngw_gpio_leds = {
++      .name =         "leds-gpio",
++      .id =           -1,
++      .dev = {
++              .platform_data = (void *) &ngw_led_data,
++      }
 +};
 +
-+static struct physmap_flash_data flash_data = {
-+      .width          = 2,
-+      .nr_parts       = ARRAY_SIZE(flash_parts),
-+      .parts          = flash_parts,
+ static int __init atngw100_init(void)
+ {
++      unsigned        i;
++
+       /*
+        * ATNGW100 uses 16-bit SDRAM interface, so we don't need to
+        * reserve any pins for it.
+@@ -115,6 +145,14 @@
+       set_hw_addr(at32_add_device_eth(1, &eth_data[1]));
+       at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
++      at32_add_device_mci(0, &mci0_data);
++      at32_add_device_usba(0, NULL);
++
++      for (i = 0; i < ARRAY_SIZE(ngw_leds); i++) {
++              at32_select_gpio(ngw_leds[i].gpio,
++                              AT32_GPIOF_OUTPUT | AT32_GPIOF_HIGH);
++      }
++      platform_device_register(&ngw_gpio_leds);
+       return 0;
+ }
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/boards/atstk1000/atstk1002.c linux-avr32.git/arch/avr32/boards/atstk1000/atstk1002.c
+--- linux-2.6.22.1/arch/avr32/boards/atstk1000/atstk1002.c     2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/boards/atstk1000/atstk1002.c    2007-07-12 13:59:49.000000000 +0200
+@@ -11,6 +11,7 @@
+ #include <linux/etherdevice.h>
+ #include <linux/init.h>
+ #include <linux/kernel.h>
++#include <linux/leds.h>
+ #include <linux/platform_device.h>
+ #include <linux/string.h>
+ #include <linux/types.h>
+@@ -27,7 +28,6 @@
+ #include "atstk1000.h"
+-#define       SW2_DEFAULT             /* MMCI and UART_A available */
+ struct eth_addr {
+       u8 addr[6];
+@@ -36,6 +36,7 @@
+ static struct eth_addr __initdata hw_addr[2];
+ static struct eth_platform_data __initdata eth_data[2];
++#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM
+ static struct spi_board_info spi0_board_info[] __initdata = {
+       {
+               /* QVGA display */
+@@ -45,6 +46,18 @@
+               .mode           = SPI_MODE_3,
+       },
+ };
++#endif
++
++#ifdef CONFIG_BOARD_ATSTK1002_SPI1
++static struct spi_board_info spi1_board_info[] __initdata = { {
++      /* patch in custom entries here */
++} };
++#endif
++
++static struct mci_platform_data __initdata mci0_data = {
++      .detect_pin     = GPIO_PIN_NONE,
++      .wp_pin         = GPIO_PIN_NONE,
++};
+ /*
+  * The next two functions should go away as the boot loader is
+@@ -101,12 +114,71 @@
+       clk_put(pclk);
+ }
+-void __init setup_board(void)
++#ifdef CONFIG_BOARD_ATSTK1002_J2_LED
++
++static struct gpio_led stk_j2_led[] = {
++#ifdef CONFIG_BOARD_ATSTK1002_J2_LED8
++#define LEDSTRING "J2 jumpered to LED8"
++      { .name = "led0:amber", .gpio = GPIO_PIN_PB( 8), },
++      { .name = "led1:amber", .gpio = GPIO_PIN_PB( 9), },
++      { .name = "led2:amber", .gpio = GPIO_PIN_PB(10), },
++      { .name = "led3:amber", .gpio = GPIO_PIN_PB(13), },
++      { .name = "led4:amber", .gpio = GPIO_PIN_PB(14), },
++      { .name = "led5:amber", .gpio = GPIO_PIN_PB(15), },
++      { .name = "led6:amber", .gpio = GPIO_PIN_PB(16), },
++      { .name = "led7:amber", .gpio = GPIO_PIN_PB(30),
++                      .default_trigger = "heartbeat", },
++#else /* RGB */
++#define LEDSTRING "J2 jumpered to RGB LEDs"
++      { .name = "r1:red",     .gpio = GPIO_PIN_PB( 8), },
++      { .name = "g1:green",   .gpio = GPIO_PIN_PB(10), },
++      { .name = "b1:blue",    .gpio = GPIO_PIN_PB(14), },
++
++      { .name = "r2:red",     .gpio = GPIO_PIN_PB( 9),
++                      .default_trigger = "heartbeat", },
++      { .name = "g2:green",   .gpio = GPIO_PIN_PB(13), },
++      { .name = "b2:blue",    .gpio = GPIO_PIN_PB(15),
++                      .default_trigger = "heartbeat", },
++      /* PB16, PB30 unused */
++#endif
 +};
 +
-+static struct resource flash_resource = {
-+      .start          = 0x00000000,
-+      .end            = 0x007fffff,
-+      .flags          = IORESOURCE_MEM,
++static struct gpio_led_platform_data stk_j2_led_data = {
++      .num_leds       = ARRAY_SIZE(stk_j2_led),
++      .leds           = stk_j2_led,
 +};
 +
-+static struct platform_device flash_device = {
-+      .name           = "physmap-flash",
-+      .id             = 0,
-+      .resource       = &flash_resource,
-+      .num_resources  = 1,
++static struct platform_device stk_j2_led_dev = {
++      .name           = "leds-gpio",
++      .id             = 2,    /* gpio block J2 */
 +      .dev            = {
-+              .platform_data = &flash_data,
++              .platform_data  = &stk_j2_led_data,
 +      },
 +};
 +
-+/* This needs to be called after the SMC has been initialized */
-+static int __init atngw100_flash_init(void)
-+{
-+      int ret;
++static void setup_j2_leds(void)
+ {
+-#ifdef        SW2_DEFAULT
+-      at32_map_usart(1, 0);   /* USART 1/A: /dev/ttyS0, DB9 */
++      unsigned        i;
 +
-+      ret = smc_set_configuration(0, &flash_config);
-+      if (ret < 0) {
-+              printk(KERN_ERR "atngw100: failed to set NOR flash timing\n");
-+              return ret;
-+      }
++      for (i = 0; i < ARRAY_SIZE(stk_j2_led); i++)
++              at32_select_gpio(stk_j2_led[i].gpio, AT32_GPIOF_OUTPUT);
 +
-+      platform_device_register(&flash_device);
++      printk("STK1002: " LEDSTRING "\n");
++      platform_device_register(&stk_j2_led_dev);
++}
 +
-+      return 0;
+ #else
++static void setup_j2_leds(void)
++{
 +}
-+device_initcall(atngw100_flash_init);
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/Makefile avr32-git/arch/avr32/boards/atngw100/Makefile
---- linux-2.6.21.3/arch/avr32/boards/atngw100/Makefile 1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/boards/atngw100/Makefile      2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1 @@
-+obj-y                         += setup.o flash.o
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/setup.c avr32-git/arch/avr32/boards/atngw100/setup.c
---- linux-2.6.21.3/arch/avr32/boards/atngw100/setup.c  1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/boards/atngw100/setup.c       2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,131 @@
-+/*
-+ * Board-specific setup code for the ATNGW100 Network Gateway
-+ *
-+ * Copyright (C) 2005-2006 Atmel Corporation
-+ *
-+ * 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.
-+ */
-+#include <linux/clk.h>
-+#include <linux/etherdevice.h>
-+#include <linux/init.h>
-+#include <linux/linkage.h>
-+#include <linux/platform_device.h>
-+#include <linux/types.h>
-+#include <linux/spi/spi.h>
++#endif
 +
-+#include <asm/io.h>
-+#include <asm/setup.h>
++void __init setup_board(void)
++{
++#ifdef        CONFIG_BOARD_ATSTK1002_SW2_CUSTOM
+       at32_map_usart(0, 1);   /* USART 0/B: /dev/ttyS1, IRDA */
++#else
++      at32_map_usart(1, 0);   /* USART 1/A: /dev/ttyS0, DB9 */
+ #endif
+       /* USART 2/unused: expansion connector */
+       at32_map_usart(3, 2);   /* USART 3/C: /dev/ttyS2, DB9 */
+@@ -140,18 +212,40 @@
+       at32_add_system_devices();
+-#ifdef        SW2_DEFAULT
+-      at32_add_device_usart(0);
+-#else
++#ifdef        CONFIG_BOARD_ATSTK1002_SW2_CUSTOM
+       at32_add_device_usart(1);
++#else
++      at32_add_device_usart(0);
+ #endif
+       at32_add_device_usart(2);
++#ifndef CONFIG_BOARD_ATSTK1002_SW6_CUSTOM
+       set_hw_addr(at32_add_device_eth(0, &eth_data[0]));
+-
+-      at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
++#endif
++#ifdef CONFIG_BOARD_ATSTK1002_SW5_CUSTOM
++      set_hw_addr(at32_add_device_eth(1, &eth_data[1]));
++#else
+       at32_add_device_lcdc(0, &atstk1000_lcdc_data,
+                            fbmem_start, fbmem_size);
++#endif
 +
-+#include <asm/arch/at32ap7000.h>
-+#include <asm/arch/board.h>
-+#include <asm/arch/init.h>
++#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM
++      at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
++#endif
++#ifdef CONFIG_BOARD_ATSTK1002_SPI1
++      at32_add_device_spi(1, spi1_board_info, ARRAY_SIZE(spi1_board_info));
++#endif
++      at32_add_device_twi(0);
++#ifndef CONFIG_BOARD_ATSTK1002_SW2_CUSTOM
++      at32_add_device_mci(0, &mci0_data);
++#endif
++      at32_add_device_usba(0, NULL);
++      at32_add_device_abdac(0);
++#ifndef CONFIG_BOARD_ATSTK1002_SW3_CUSTOM
++      at32_add_device_ssc(0, ATMEL_SSC_TX);
++#endif
 +
-+/* Initialized by bootloader-specific startup code. */
-+struct tag *bootloader_tags __initdata;
++      setup_j2_leds();
+       return 0;
+ }
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/boards/atstk1000/Kconfig linux-avr32.git/arch/avr32/boards/atstk1000/Kconfig
+--- linux-2.6.22.1/arch/avr32/boards/atstk1000/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/boards/atstk1000/Kconfig        2007-07-12 13:59:49.000000000 +0200
+@@ -0,0 +1,79 @@
++# STK1000 customization
 +
-+struct eth_addr {
-+      u8 addr[6];
-+};
-+static struct eth_addr __initdata hw_addr[2];
-+static struct eth_platform_data __initdata eth_data[2];
++if BOARD_ATSTK1002
 +
-+static struct spi_board_info spi0_board_info[] __initdata = {
-+      {
-+              .modalias       = "mtd_dataflash",
-+              .max_speed_hz   = 10000000,
-+              .chip_select    = 0,
-+      },
-+};
++config BOARD_ATSTK1002_CUSTOM
++      bool "Non-default STK-1002 jumper settings"
++      help
++        You will normally leave the jumpers on the CPU card at their
++        default settings.  If you need to use certain peripherals,
++        you will need to change some of those jumpers.
 +
-+static struct mci_platform_data __initdata mci0_data = {
-+      .detect_pin     = GPIO_PIN_PC(25),
-+      .wp_pin         = GPIO_PIN_PE(0),
-+};
++if BOARD_ATSTK1002_CUSTOM
 +
-+/*
-+ * The next two functions should go away as the boot loader is
-+ * supposed to initialize the macb address registers with a valid
-+ * ethernet address. But we need to keep it around for a while until
-+ * we can be reasonably sure the boot loader does this.
-+ *
-+ * The phy_id is ignored as the driver will probe for it.
-+ */
-+static int __init parse_tag_ethernet(struct tag *tag)
-+{
-+      int i;
++config BOARD_ATSTK1002_SW1_CUSTOM
++      bool "SW1: use SSC1 (not SPI0)"
++      help
++        This also prevents using the external DAC as an audio interface,
++        and means you can't initialize the on-board QVGA display.
 +
-+      i = tag->u.ethernet.mac_index;
-+      if (i < ARRAY_SIZE(hw_addr))
-+              memcpy(hw_addr[i].addr, tag->u.ethernet.hw_address,
-+                     sizeof(hw_addr[i].addr));
++config BOARD_ATSTK1002_SW2_CUSTOM
++      bool "SW2: use IRDA or TIMER0 (not UART-A, MMC/SD, and PS2-A)"
++      help
++        If you change this you'll want an updated boot loader putting
++        the console on UART-C not UART-A.
 +
-+      return 0;
-+}
-+__tagtable(ATAG_ETHERNET, parse_tag_ethernet);
++config BOARD_ATSTK1002_SW3_CUSTOM
++      bool "SW3: use TIMER1 (not SSC0 and GCLK)"
++      help
++        This also prevents using the external DAC as an audio interface.
 +
-+static void __init set_hw_addr(struct platform_device *pdev)
-+{
-+      struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-+      const u8 *addr;
-+      void __iomem *regs;
-+      struct clk *pclk;
++config BOARD_ATSTK1002_SW4_CUSTOM
++      bool "SW4: use ISI/Camera (not GPIOs, SPI1, and PS2-B)"
++      help
++        To use the camera interface you'll need a custom card (on the
++        PCI-format connector) connect a video sensor.
 +
-+      if (!res)
-+              return;
-+      if (pdev->id >= ARRAY_SIZE(hw_addr))
-+              return;
++config BOARD_ATSTK1002_SW5_CUSTOM
++      bool "SW5: use MACB1 (not LCDC)"
 +
-+      addr = hw_addr[pdev->id].addr;
-+      if (!is_valid_ether_addr(addr))
-+              return;
++config BOARD_ATSTK1002_SW6_CUSTOM
++      bool "SW6: more GPIOs (not MACB0)"
 +
-+      /*
-+       * Since this is board-specific code, we'll cheat and use the
-+       * physical address directly as we happen to know that it's
-+       * the same as the virtual address.
-+       */
-+      regs = (void __iomem __force *)res->start;
-+      pclk = clk_get(&pdev->dev, "pclk");
-+      if (!pclk)
-+              return;
++endif # custom
 +
-+      clk_enable(pclk);
-+      __raw_writel((addr[3] << 24) | (addr[2] << 16)
-+                   | (addr[1] << 8) | addr[0], regs + 0x98);
-+      __raw_writel((addr[5] << 8) | addr[4], regs + 0x9c);
-+      clk_disable(pclk);
-+      clk_put(pclk);
-+}
++config BOARD_ATSTK1002_SPI1
++      bool "Configure SPI1 controller"
++      depends on !BOARD_ATSTK1002_SW4_CUSTOM
++      help
++        All the signals for the second SPI controller are available on
++        GPIO lines and accessed through the J1 jumper block.  Say "y"
++        here to configure that SPI controller.
 +
-+struct platform_device *at32_usart_map[1];
-+unsigned int at32_nr_usarts = 1;
++config BOARD_ATSTK1002_J2_LED
++      bool
++      default BOARD_ATSTK1002_J2_LED8 || BOARD_ATSTK1002_J2_RGB
 +
-+void __init setup_board(void)
-+{
-+      at32_map_usart(1, 0);   /* USART 1: /dev/ttyS0, DB9 */
-+      at32_setup_serial_console(0);
-+}
++choice
++      prompt "LEDs connected to J2:"
++      depends on LEDS_GPIO && !BOARD_ATSTK1002_SW4_CUSTOM
++      optional
++      help
++        Select this if you have jumpered the J2 jumper block to the
++        LED0..LED7 amber leds, or to the RGB leds, using a ten-pin
++        IDC cable.  A default "heartbeat" trigger is provided, but
++        you can of course override this.
 +
-+static int __init atngw100_init(void)
-+{
-+      /*
-+       * ATNGW100 uses 16-bit SDRAM interface, so we don't need to
-+       * reserve any pins for it.
-+       */
++config BOARD_ATSTK1002_J2_LED8
++      bool "LED0..LED7"
++      help
++        Select this if J2 is jumpered to LED0..LED7 amber leds.
 +
-+      at32_add_system_devices();
++config BOARD_ATSTK1002_J2_RGB
++      bool "RGB leds"
++      help
++        Select this if J2 is jumpered to the RGB leds.
 +
-+      at32_add_device_usart(0);
++endchoice
 +
-+      set_hw_addr(at32_add_device_eth(0, &eth_data[0]));
-+      set_hw_addr(at32_add_device_eth(1, &eth_data[1]));
++endif # stk 1002
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/configs/atngw100_defconfig linux-avr32.git/arch/avr32/configs/atngw100_defconfig
+--- linux-2.6.22.1/arch/avr32/configs/atngw100_defconfig       2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/configs/atngw100_defconfig      2007-07-12 13:59:49.000000000 +0200
+@@ -712,7 +712,21 @@
+ #
+ # LED devices
+ #
+-# CONFIG_NEW_LEDS is not set
++CONFIG_NEW_LEDS=y
++CONFIG_LEDS_CLASS=y
 +
-+      at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
-+      at32_add_device_mci(0, &mci0_data);
-+      at32_add_device_usba(0);
++#
++# LED drivers
++#
++CONFIG_LEDS_GPIO=y
 +
-+      return 0;
-+}
-+postcore_initcall(atngw100_init);
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1000.h avr32-git/arch/avr32/boards/atstk1000/atstk1000.h
---- linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1000.h     1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/boards/atstk1000/atstk1000.h  2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,15 @@
++#
++# LED Triggers
++#
++CONFIG_LEDS_TRIGGERS=y
++CONFIG_LEDS_TRIGGER_TIMER=y
++CONFIG_LEDS_TRIGGER_HEARTBEAT=y
++
+ #
+ # LED drivers
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/drivers/dw-dmac.c linux-avr32.git/arch/avr32/drivers/dw-dmac.c
+--- linux-2.6.22.1/arch/avr32/drivers/dw-dmac.c        1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/drivers/dw-dmac.c       2007-06-06 11:33:46.000000000 +0200
+@@ -0,0 +1,761 @@
 +/*
-+ * ATSTK1000 setup code: Daughterboard interface
++ * Driver for the Synopsys DesignWare DMA Controller
 + *
-+ * Copyright (C) 2007 Atmel Corporation
++ * Copyright (C) 2005-2006 Atmel Corporation
 + *
 + * 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.
 + */
-+#ifndef __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H
-+#define __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H
++#include <linux/clk.h>
++#include <linux/device.h>
++#include <linux/dma-mapping.h>
++#include <linux/dmapool.h>
++#include <linux/init.h>
++#include <linux/interrupt.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
 +
-+extern struct atmel_lcdfb_info atstk1000_lcdc_data;
++#include <asm/dma-controller.h>
++#include <asm/io.h>
 +
-+#endif /* __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H */
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1002.c avr32-git/arch/avr32/boards/atstk1000/atstk1002.c
---- linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1002.c     2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/boards/atstk1000/atstk1002.c  2007-06-06 11:33:46.000000000 +0200
-@@ -16,6 +16,8 @@
- #include <linux/types.h>
- #include <linux/spi/spi.h>
-+#include <video/atmel_lcdc.h>
++#include "dw-dmac.h"
 +
- #include <asm/io.h>
- #include <asm/setup.h>
- #include <asm/arch/at32ap7000.h>
-@@ -23,6 +25,7 @@
- #include <asm/arch/init.h>
- #include <asm/arch/portmux.h>
-+#include "atstk1000.h"
- #define       SW2_DEFAULT             /* MMCI and UART_A available */
-@@ -31,9 +34,7 @@
- };
- static struct eth_addr __initdata hw_addr[2];
--
- static struct eth_platform_data __initdata eth_data[2];
--extern struct lcdc_platform_data atstk1000_fb0_data;
- static struct spi_board_info spi0_board_info[] __initdata = {
-       {
-@@ -41,9 +42,15 @@
-               .modalias       = "ltv350qv",
-               .max_speed_hz   = 16000000,
-               .chip_select    = 1,
-+              .mode           = SPI_MODE_3,
-       },
- };
-+static struct mci_platform_data __initdata mci0_data = {
-+      .detect_pin     = GPIO_PIN_NONE,
-+      .wp_pin         = GPIO_PIN_NONE,
-+};
-+
- /*
-  * The next two functions should go away as the boot loader is
-  * supposed to initialize the macb address registers with a valid
-@@ -148,7 +155,12 @@
-       set_hw_addr(at32_add_device_eth(0, &eth_data[0]));
-       at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info));
--      at32_add_device_lcdc(0, &atstk1000_fb0_data);
-+      at32_add_device_twi(0);
-+      at32_add_device_mci(0, &mci0_data);
-+      at32_add_device_lcdc(0, &atstk1000_lcdc_data,
-+                           fbmem_start, fbmem_size);
-+      at32_add_device_usba(0);
-+      at32_add_device_abdac(0);
-       return 0;
- }
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atstk1000/setup.c avr32-git/arch/avr32/boards/atstk1000/setup.c
---- linux-2.6.21.3/arch/avr32/boards/atstk1000/setup.c 2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/boards/atstk1000/setup.c      2007-06-06 11:33:46.000000000 +0200
-@@ -8,43 +8,56 @@
-  * published by the Free Software Foundation.
-  */
- #include <linux/bootmem.h>
-+#include <linux/fb.h>
- #include <linux/init.h>
- #include <linux/types.h>
- #include <linux/linkage.h>
--#include <asm/setup.h>
-+#include <video/atmel_lcdc.h>
-+#include <asm/setup.h>
- #include <asm/arch/board.h>
-+#include "atstk1000.h"
-+
- /* Initialized by bootloader-specific startup code. */
- struct tag *bootloader_tags __initdata;
--struct lcdc_platform_data __initdata atstk1000_fb0_data;
--
--void __init board_setup_fbmem(unsigned long fbmem_start,
--                            unsigned long fbmem_size)
--{
--      if (!fbmem_size)
--              return;
--
--      if (!fbmem_start) {
--              void *fbmem;
--
--              fbmem = alloc_bootmem_low_pages(fbmem_size);
--              fbmem_start = __pa(fbmem);
--      } else {
--              pg_data_t *pgdat;
--
--              for_each_online_pgdat(pgdat) {
--                      if (fbmem_start >= pgdat->bdata->node_boot_start
--                          && fbmem_start <= pgdat->bdata->node_low_pfn)
--                              reserve_bootmem_node(pgdat, fbmem_start,
--                                                   fbmem_size);
--              }
--      }
--
--      printk("%luKiB framebuffer memory at address 0x%08lx\n",
--             fbmem_size >> 10, fbmem_start);
--      atstk1000_fb0_data.fbmem_start = fbmem_start;
--      atstk1000_fb0_data.fbmem_size = fbmem_size;
--}
-+static struct fb_videomode __initdata ltv350qv_modes[] = {
-+      {
-+              .name           = "320x240 @ 75",
-+              .refresh        = 75,
-+              .xres           = 320,          .yres           = 240,
-+              .pixclock       = KHZ2PICOS(6891),
-+
-+              .left_margin    = 17,           .right_margin   = 33,
-+              .upper_margin   = 10,           .lower_margin   = 10,
-+              .hsync_len      = 16,           .vsync_len      = 1,
-+
-+              .sync           = 0,
-+              .vmode          = FB_VMODE_NONINTERLACED,
-+      },
-+};
-+
-+static struct fb_monspecs __initdata atstk1000_default_monspecs = {
-+      .manufacturer           = "SNG",
-+      .monitor                = "LTV350QV",
-+      .modedb                 = ltv350qv_modes,
-+      .modedb_len             = ARRAY_SIZE(ltv350qv_modes),
-+      .hfmin                  = 14820,
-+      .hfmax                  = 22230,
-+      .vfmin                  = 60,
-+      .vfmax                  = 90,
-+      .dclkmax                = 30000000,
-+};
-+
-+struct atmel_lcdfb_info __initdata atstk1000_lcdc_data = {
-+      .default_bpp            = 24,
-+      .default_dmacon         = ATMEL_LCDC_DMAEN | ATMEL_LCDC_DMA2DEN,
-+      .default_lcdcon2        = (ATMEL_LCDC_DISTYPE_TFT
-+                                 | ATMEL_LCDC_INVCLK
-+                                 | ATMEL_LCDC_CLKMOD_ALWAYSACTIVE
-+                                 | ATMEL_LCDC_MEMOR_BIG),
-+      .default_monspecs       = &atstk1000_default_monspecs,
-+      .guard_time             = 2,
-+};
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c avr32-git/arch/avr32/drivers/dw-dmac.c
---- linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c        1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/drivers/dw-dmac.c     2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,761 @@
-+/*
-+ * Driver for the Synopsys DesignWare DMA Controller
-+ *
-+ * Copyright (C) 2005-2006 Atmel Corporation
-+ *
-+ * 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.
-+ */
-+#include <linux/clk.h>
-+#include <linux/device.h>
-+#include <linux/dma-mapping.h>
-+#include <linux/dmapool.h>
-+#include <linux/init.h>
-+#include <linux/interrupt.h>
-+#include <linux/module.h>
-+#include <linux/platform_device.h>
-+
-+#include <asm/dma-controller.h>
-+#include <asm/io.h>
-+
-+#include "dw-dmac.h"
-+
-+#define DMAC_NR_CHANNELS 3
-+#define DMAC_MAX_BLOCKSIZE 4095
-+
-+enum {
-+      CH_STATE_FREE = 0,
-+      CH_STATE_ALLOCATED,
-+      CH_STATE_BUSY,
++#define DMAC_NR_CHANNELS 3
++#define DMAC_MAX_BLOCKSIZE 4095
++
++enum {
++      CH_STATE_FREE = 0,
++      CH_STATE_ALLOCATED,
++      CH_STATE_BUSY,
 +};
 +
 +struct dw_dma_lli {
@@ -1122,7 +1068,7 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c avr3
 +              goto out_free_pool;
 +
 +      ret = request_irq(platform_get_irq(pdev, 0), dmac_interrupt,
-+                        SA_SAMPLE_RANDOM, pdev->name, dmac);
++                        IRQF_SAMPLE_RANDOM, pdev->name, dmac);
 +      if (ret)
 +              goto out_unmap_regs;
 +
@@ -1171,9 +1117,9 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c avr3
 +MODULE_DESCRIPTION("Synopsys DesignWare DMA Controller driver");
 +MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
 +MODULE_LICENSE("GPL");
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.h avr32-git/arch/avr32/drivers/dw-dmac.h
---- linux-2.6.21.3/arch/avr32/drivers/dw-dmac.h        1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/drivers/dw-dmac.h     2007-06-06 11:33:46.000000000 +0200
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/drivers/dw-dmac.h linux-avr32.git/arch/avr32/drivers/dw-dmac.h
+--- linux-2.6.22.1/arch/avr32/drivers/dw-dmac.h        1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/drivers/dw-dmac.h       2007-06-06 11:33:46.000000000 +0200
 @@ -0,0 +1,42 @@
 +/*
 + * Driver for the Synopsys DesignWare DMA Controller
@@ -1217,56 +1163,26 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/dw-dmac.h avr3
 +#define DW_DMAC_CHAN_DSR      0x050
 +
 +#endif /* __AVR32_DW_DMAC_H__ */
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/Makefile avr32-git/arch/avr32/drivers/Makefile
---- linux-2.6.21.3/arch/avr32/drivers/Makefile 1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/drivers/Makefile      2007-06-06 11:33:46.000000000 +0200
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/drivers/Makefile linux-avr32.git/arch/avr32/drivers/Makefile
+--- linux-2.6.22.1/arch/avr32/drivers/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/drivers/Makefile        2007-06-06 11:33:46.000000000 +0200
 @@ -0,0 +1 @@
 +obj-$(CONFIG_DW_DMAC)                 += dw-dmac.o
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Kconfig avr32-git/arch/avr32/Kconfig
---- linux-2.6.21.3/arch/avr32/Kconfig  2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/Kconfig       2007-06-06 11:33:46.000000000 +0200
-@@ -57,9 +57,6 @@
-       bool
-       default n
--config GENERIC_BUST_SPINLOCK
--      bool
--
- config GENERIC_HWEIGHT
-       bool
-       default y
-@@ -68,6 +65,11 @@
-       bool
-       default y
-+config GENERIC_BUG
-+      bool
-+      default y
-+      depends on BUG
-+
- source "init/Kconfig"
- menu "System Type and features"
-@@ -106,6 +108,9 @@
- config BOARD_ATSTK1000
-       bool "ATSTK1000 evaluation board"
-       select BOARD_ATSTK1002 if CPU_AT32AP7000
-+
-+config BOARD_ATNGW100
-+      bool "ATNGW100 Network Gateway"
- endchoice
- choice
-@@ -116,6 +121,8 @@
-       bool "U-Boot (or similar) bootloader"
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/Kconfig linux-avr32.git/arch/avr32/Kconfig
+--- linux-2.6.22.1/arch/avr32/Kconfig  2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/Kconfig 2007-07-12 13:59:49.000000000 +0200
+@@ -113,6 +113,10 @@
+       bool "ATNGW100 Network Gateway"
  endchoice
  
-+source "arch/avr32/mach-at32ap/Kconfig"
++if BOARD_ATSTK1000
++source "arch/avr32/boards/atstk1000/Kconfig"
++endif
 +
- config LOAD_ADDRESS
-       hex
-       default 0x10000000 if LOADER_U_BOOT=y && CPU_AT32AP7000=y
-@@ -164,6 +171,10 @@
+ choice
+       prompt "Boot loader type"
+       default LOADER_U_BOOT
+@@ -171,6 +175,10 @@
          enabling Nexus-compliant debuggers to keep track of the PID of the
          currently executing task.
  
@@ -1277,107 +1193,37 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Kconfig avr32-git/arch
  # FPU emulation goes here
  
  source "kernel/Kconfig.hz"
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/cpu.c avr32-git/arch/avr32/kernel/cpu.c
---- linux-2.6.21.3/arch/avr32/kernel/cpu.c     2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/cpu.c  2007-06-06 11:33:46.000000000 +0200
-@@ -209,16 +209,17 @@
- void __init setup_processor(void)
- {
-       unsigned long config0, config1;
-+      unsigned long features;
-       unsigned cpu_id, cpu_rev, arch_id, arch_rev, mmu_type;
-       unsigned tmp;
--      config0 = sysreg_read(CONFIG0); /* 0x0000013e; */
--      config1 = sysreg_read(CONFIG1); /* 0x01f689a2; */
--      cpu_id = config0 >> 24;
--      cpu_rev = (config0 >> 16) & 0xff;
--      arch_id = (config0 >> 13) & 0x07;
--      arch_rev = (config0 >> 10) & 0x07;
--      mmu_type = (config0 >> 7) & 0x03;
-+      config0 = sysreg_read(CONFIG0);
-+      config1 = sysreg_read(CONFIG1);
-+      cpu_id = SYSREG_BFEXT(PROCESSORID, config0);
-+      cpu_rev = SYSREG_BFEXT(PROCESSORREVISION, config0);
-+      arch_id = SYSREG_BFEXT(AT, config0);
-+      arch_rev = SYSREG_BFEXT(AR, config0);
-+      mmu_type = SYSREG_BFEXT(MMUT, config0);
-       boot_cpu_data.arch_type = arch_id;
-       boot_cpu_data.cpu_type = cpu_id;
-@@ -226,16 +227,16 @@
-       boot_cpu_data.cpu_revision = cpu_rev;
-       boot_cpu_data.tlb_config = mmu_type;
--      tmp = (config1 >> 13) & 0x07;
-+      tmp = SYSREG_BFEXT(ILSZ, config1);
-       if (tmp) {
--              boot_cpu_data.icache.ways = 1 << ((config1 >> 10) & 0x07);
--              boot_cpu_data.icache.sets = 1 << ((config1 >> 16) & 0x0f);
-+              boot_cpu_data.icache.ways = 1 << SYSREG_BFEXT(IASS, config1);
-+              boot_cpu_data.icache.sets = 1 << SYSREG_BFEXT(ISET, config1);
-               boot_cpu_data.icache.linesz = 1 << (tmp + 1);
-       }
--      tmp = (config1 >> 3) & 0x07;
-+      tmp = SYSREG_BFEXT(DLSZ, config1);
-       if (tmp) {
--              boot_cpu_data.dcache.ways = 1 << (config1 & 0x07);
--              boot_cpu_data.dcache.sets = 1 << ((config1 >> 6) & 0x0f);
-+              boot_cpu_data.dcache.ways = 1 << SYSREG_BFEXT(DASS, config1);
-+              boot_cpu_data.dcache.sets = 1 << SYSREG_BFEXT(DSET, config1);
-               boot_cpu_data.dcache.linesz = 1 << (tmp + 1);
-       }
+@@ -185,6 +193,27 @@
  
-@@ -250,16 +251,39 @@
-               cpu_names[cpu_id], cpu_id, cpu_rev,
-               arch_names[arch_id], arch_rev);
-       printk ("CPU: MMU configuration: %s\n", mmu_types[mmu_type]);
-+
-       printk ("CPU: features:");
--      if (config0 & (1 << 6))
--              printk(" fpu");
--      if (config0 & (1 << 5))
--              printk(" java");
--      if (config0 & (1 << 4))
--              printk(" perfctr");
--      if (config0 & (1 << 3))
-+      features = 0;
-+      if (config0 & SYSREG_BIT(CONFIG0_R)) {
-+              features |= AVR32_FEATURE_RMW;
-+              printk(" rmw");
-+      }
-+      if (config0 & SYSREG_BIT(CONFIG0_D)) {
-+              features |= AVR32_FEATURE_DSP;
-+              printk(" dsp");
-+      }
-+      if (config0 & SYSREG_BIT(CONFIG0_S)) {
-+              features |= AVR32_FEATURE_SIMD;
-+              printk(" simd");
-+      }
-+      if (config0 & SYSREG_BIT(CONFIG0_O)) {
-+              features |= AVR32_FEATURE_OCD;
-               printk(" ocd");
-+      }
-+      if (config0 & SYSREG_BIT(CONFIG0_P)) {
-+              features |= AVR32_FEATURE_PCTR;
-+              printk(" perfctr");
-+      }
-+      if (config0 & SYSREG_BIT(CONFIG0_J)) {
-+              features |= AVR32_FEATURE_JAVA;
-+              printk(" java");
-+      }
-+      if (config0 & SYSREG_BIT(CONFIG0_F)) {
-+              features |= AVR32_FEATURE_FPU;
-+              printk(" fpu");
-+      }
-       printk("\n");
-+      boot_cpu_data.features = features;
- }
+ endmenu
++menu "Power managment options"
++
++menu "CPU Frequency scaling"
++
++source "drivers/cpufreq/Kconfig"
++
++config CPU_FREQ_AT32AP
++      bool "CPU frequency driver for AT32AP"
++      depends on CPU_FREQ && PLATFORM_AT32AP
++      default n
++      help
++        This enables the CPU frequency driver for AT32AP processors.
++
++        For details, take a look in <file:Documentation/cpu-freq>.
++
++        If in doubt, say N.
++
++endmenu
++
++endmenu
++
+ menu "Bus options"
  
- #ifdef CONFIG_PROC_FS
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/dma-controller.c avr32-git/arch/avr32/kernel/dma-controller.c
---- linux-2.6.21.3/arch/avr32/kernel/dma-controller.c  1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/kernel/dma-controller.c       2007-06-06 11:33:46.000000000 +0200
+ config PCI
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/kernel/dma-controller.c linux-avr32.git/arch/avr32/kernel/dma-controller.c
+--- linux-2.6.22.1/arch/avr32/kernel/dma-controller.c  1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/kernel/dma-controller.c 2007-06-06 11:33:46.000000000 +0200
 @@ -0,0 +1,34 @@
 +/*
 + * Preliminary DMA controller framework for AVR32
@@ -1413,252 +1259,9 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/dma-controller.
 +      return NULL;
 +}
 +EXPORT_SYMBOL(find_dma_controller);
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/entry-avr32b.S avr32-git/arch/avr32/kernel/entry-avr32b.S
---- linux-2.6.21.3/arch/avr32/kernel/entry-avr32b.S    2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/entry-avr32b.S 2007-06-06 11:33:46.000000000 +0200
-@@ -100,55 +100,49 @@
-       .global tlb_miss_common
- tlb_miss_common:
--      mfsr    r0, SYSREG_PTBR
--      mfsr    r1, SYSREG_TLBEAR
-+      mfsr    r0, SYSREG_TLBEAR
-+      mfsr    r1, SYSREG_PTBR
-       /* Is it the vmalloc space? */
--      bld     r1, 31
-+      bld     r0, 31
-       brcs    handle_vmalloc_miss
-       /* First level lookup */
- pgtbl_lookup:
--      lsr     r2, r1, PGDIR_SHIFT
--      ld.w    r0, r0[r2 << 2]
--      bld     r0, _PAGE_BIT_PRESENT
-+      lsr     r2, r0, PGDIR_SHIFT
-+      ld.w    r3, r1[r2 << 2]
-+      bfextu  r1, r0, PAGE_SHIFT, PGDIR_SHIFT - PAGE_SHIFT
-+      bld     r3, _PAGE_BIT_PRESENT
-       brcc    page_table_not_present
--      /* TODO: Check access rights on page table if necessary */
--
-       /* Translate to virtual address in P1. */
--      andl    r0, 0xf000
--      sbr     r0, 31
-+      andl    r3, 0xf000
-+      sbr     r3, 31
-       /* Second level lookup */
--      lsl     r1, (32 - PGDIR_SHIFT)
--      lsr     r1, (32 - PGDIR_SHIFT) + PAGE_SHIFT
--      add     r2, r0, r1 << 2
--      ld.w    r1, r2[0]
--      bld     r1, _PAGE_BIT_PRESENT
-+      ld.w    r2, r3[r1 << 2]
-+      mfsr    r0, SYSREG_TLBARLO
-+      bld     r2, _PAGE_BIT_PRESENT
-       brcc    page_not_present
-       /* Mark the page as accessed */
--      sbr     r1, _PAGE_BIT_ACCESSED
--      st.w    r2[0], r1
-+      sbr     r2, _PAGE_BIT_ACCESSED
-+      st.w    r3[r1 << 2], r2
-       /* Drop software flags */
--      andl    r1, _PAGE_FLAGS_HARDWARE_MASK & 0xffff
--      mtsr    SYSREG_TLBELO, r1
-+      andl    r2, _PAGE_FLAGS_HARDWARE_MASK & 0xffff
-+      mtsr    SYSREG_TLBELO, r2
-       /* Figure out which entry we want to replace */
--      mfsr    r0, SYSREG_TLBARLO
-+      mfsr    r1, SYSREG_MMUCR
-       clz     r2, r0
-       brcc    1f
--      mov     r1, -1                  /* All entries have been accessed, */
--      mtsr    SYSREG_TLBARLO, r1      /* so reset TLBAR */
--      mov     r2, 0                   /* and start at 0 */
--1:    mfsr    r1, SYSREG_MMUCR
--      lsl     r2, 14
--      andl    r1, 0x3fff, COH
--      or      r1, r2
--      mtsr    SYSREG_MMUCR, r1
-+      mov     r3, -1                  /* All entries have been accessed, */
-+      mov     r2, 0                   /* so start at 0 */
-+      mtsr    SYSREG_TLBARLO, r3      /* and reset TLBAR */
-+1:    bfins   r1, r2, SYSREG_DRP_OFFSET, SYSREG_DRP_SIZE
-+      mtsr    SYSREG_MMUCR, r1
-       tlbw
-       tlbmiss_restore
-@@ -156,8 +150,8 @@
- handle_vmalloc_miss:
-       /* Simply do the lookup in init's page table */
--      mov     r0, lo(swapper_pg_dir)
--      orh     r0, hi(swapper_pg_dir)
-+      mov     r1, lo(swapper_pg_dir)
-+      orh     r1, hi(swapper_pg_dir)
-       rjmp    pgtbl_lookup
-@@ -340,12 +334,34 @@
- do_nmi_ll:
-       sub     sp, 4
-       stmts   --sp, r0-lr
--      /* FIXME: Make sure RAR_NMI and RSR_NMI are pushed instead of *_EX */
--      rcall   save_full_context_ex
-+      mfsr    r9, SYSREG_RSR_NMI
-+      mfsr    r8, SYSREG_RAR_NMI
-+      bfextu  r0, r9, MODE_SHIFT, 3
-+      brne    2f
-+
-+1:    pushm   r8, r9  /* PC and SR */
-       mfsr    r12, SYSREG_ECR
-       mov     r11, sp
-       rcall   do_nmi
--      rjmp    bad_return
-+      popm    r8-r9
-+      mtsr    SYSREG_RAR_NMI, r8
-+      tst     r0, r0
-+      mtsr    SYSREG_RSR_NMI, r9
-+      brne    3f
-+
-+      ldmts   sp++, r0-lr
-+      sub     sp, -4          /* skip r12_orig */
-+      rete
-+
-+2:    sub     r10, sp, -(FRAME_SIZE_FULL - REG_LR)
-+      stdsp   sp[4], r10      /* replace saved SP */
-+      rjmp    1b
-+
-+3:    popm    lr
-+      sub     sp, -4          /* skip sp */
-+      popm    r0-r12
-+      sub     sp, -4          /* skip r12_orig */
-+      rete
- handle_address_fault:
-       sub     sp, 4
-@@ -630,9 +646,12 @@
-       rcall   do_IRQ
-       lddsp   r4, sp[REG_SR]
--      andh    r4, (MODE_MASK >> 16), COH
-+      bfextu  r4, r4, SYSREG_M0_OFFSET, 3
-+      cp.w    r4, MODE_SUPERVISOR >> SYSREG_M0_OFFSET
-+      breq    2f
-+      cp.w    r4, MODE_USER >> SYSREG_M0_OFFSET
- #ifdef CONFIG_PREEMPT
--      brne    2f
-+      brne    3f
- #else
-       brne    1f
- #endif
-@@ -649,9 +668,18 @@
-       sub     sp, -4          /* ignore r12_orig */
-       rete
-+2:    get_thread_info r0
-+      ld.w    r1, r0[TI_flags]
-+      bld     r1, TIF_CPU_GOING_TO_SLEEP
- #ifdef CONFIG_PREEMPT
--2:
--      get_thread_info r0
-+      brcc    3f
-+#else
-+      brcc    1b
-+#endif
-+      sub     r1, pc, . - cpu_idle_skip_sleep
-+      stdsp   sp[REG_PC], r1
-+#ifdef CONFIG_PREEMPT
-+3:    get_thread_info r0
-       ld.w    r2, r0[TI_preempt_count]
-       cp.w    r2, 0
-       brne    1b
-@@ -662,12 +690,32 @@
-       bld     r4, SYSREG_GM_OFFSET
-       brcs    1b
-       rcall   preempt_schedule_irq
--      rjmp    1b
- #endif
-+      rjmp    1b
-       .endm
-       .section .irq.text,"ax",@progbits
-+.global cpu_idle_sleep
-+cpu_idle_sleep:
-+      mask_interrupts
-+      get_thread_info r8
-+      ld.w    r9, r8[TI_flags]
-+      bld     r9, TIF_NEED_RESCHED
-+      brcs    cpu_idle_enable_int_and_exit
-+      sbr     r9, TIF_CPU_GOING_TO_SLEEP
-+      st.w    r8[TI_flags], r9
-+      unmask_interrupts
-+      sleep 0
-+cpu_idle_skip_sleep:
-+      mask_interrupts
-+      ld.w    r9, r8[TI_flags]
-+      cbr     r9, TIF_CPU_GOING_TO_SLEEP
-+      st.w    r8[TI_flags], r9
-+cpu_idle_enable_int_and_exit:
-+      unmask_interrupts
-+      retal   r12
-+
-       .global irq_level0
-       .global irq_level1
-       .global irq_level2
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/irq.c avr32-git/arch/avr32/kernel/irq.c
---- linux-2.6.21.3/arch/avr32/kernel/irq.c     2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/irq.c  2007-06-06 11:33:46.000000000 +0200
-@@ -7,15 +7,6 @@
-  * 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.
-- *
-- * This file contains the code used by various IRQ handling routines:
-- * asking for different IRQ's should be done through these routines
-- * instead of just grabbing them. Thus setups with different IRQ numbers
-- * shouldn't result in any weird surprises, and installing new handlers
-- * should be easier.
-- *
-- * IRQ's are in fact implemented a bit like signal handlers for the kernel.
-- * Naturally it's not a 1:1 relation, but there are similarities.
-  */
- #include <linux/interrupt.h>
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/kprobes.c avr32-git/arch/avr32/kernel/kprobes.c
---- linux-2.6.21.3/arch/avr32/kernel/kprobes.c 2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/kprobes.c      2007-06-06 11:33:46.000000000 +0200
-@@ -179,7 +179,7 @@
-       return 1;
- }
--static int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
-+int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
- {
-       struct kprobe *cur = kprobe_running();
-@@ -216,11 +216,6 @@
-               if (post_kprobe_handler(args->regs))
-                       ret = NOTIFY_STOP;
-               break;
--      case DIE_FAULT:
--              if (kprobe_running()
--                  && kprobe_fault_handler(args->regs, args->trapnr))
--                      ret = NOTIFY_STOP;
--              break;
-       default:
-               break;
-       }
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/Makefile avr32-git/arch/avr32/kernel/Makefile
---- linux-2.6.21.3/arch/avr32/kernel/Makefile  2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/Makefile       2007-06-06 11:33:46.000000000 +0200
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/kernel/Makefile linux-avr32.git/arch/avr32/kernel/Makefile
+--- linux-2.6.22.1/arch/avr32/kernel/Makefile  2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/kernel/Makefile 2007-06-06 11:33:46.000000000 +0200
 @@ -9,6 +9,7 @@
  obj-y                         += setup.o traps.o semaphore.o ptrace.o
  obj-y                         += signal.o sys_avr32.o process.o time.o
@@ -1667,1857 +1270,471 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/Makefile avr32-
  obj-$(CONFIG_MODULES)         += module.o avr32_ksyms.o
  obj-$(CONFIG_KPROBES)         += kprobes.o
  
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/module.c avr32-git/arch/avr32/kernel/module.c
---- linux-2.6.21.3/arch/avr32/kernel/module.c  2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/module.c       2007-06-06 11:33:46.000000000 +0200
-@@ -12,10 +12,11 @@
-  * published by the Free Software Foundation.
-  */
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap7000.c linux-avr32.git/arch/avr32/mach-at32ap/at32ap7000.c
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap7000.c 2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/at32ap7000.c        2007-07-12 13:59:49.000000000 +0200
+@@ -17,14 +17,20 @@
+ #include <asm/arch/at32ap7000.h>
+ #include <asm/arch/board.h>
+ #include <asm/arch/portmux.h>
+-#include <asm/arch/sm.h>
  
--#include <linux/moduleloader.h>
--#include <linux/module.h>
--#include <linux/kernel.h>
-+#include <linux/bug.h>
- #include <linux/elf.h>
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/moduleloader.h>
- #include <linux/vmalloc.h>
+ #include <video/atmel_lcdc.h>
  
- void *module_alloc(unsigned long size)
-@@ -315,10 +316,10 @@
-       vfree(module->arch.syminfo);
-       module->arch.syminfo = NULL;
+ #include "clock.h"
+ #include "hmatrix.h"
+ #include "pio.h"
+-#include "sm.h"
++#include "pm.h"
++
++/*
++ * We can reduce the code size a bit by using a constant here. Since
++ * this file is completely chip-specific, it's safe to not use
++ * ioremap. Generic drivers should of course never do this.
++ */
++#define AT32_PM_BASE  0xfff00000
  
--      return 0;
-+      return module_bug_finalize(hdr, sechdrs, module);
+ #define PBMEM(base)                                   \
+       {                                               \
+@@ -88,6 +94,8 @@
+       .index          = _index,                               \
  }
  
- void module_arch_cleanup(struct module *module)
++static DEFINE_SPINLOCK(pm_lock);
++
+ unsigned long at32ap7000_osc_rates[3] = {
+       [0] = 32768,
+       /* FIXME: these are ATSTK1002-specific */
+@@ -104,11 +112,11 @@
  {
--
-+      module_bug_cleanup(module);
+       unsigned long div, mul, rate;
+-      if (!(control & SM_BIT(PLLEN)))
++      if (!(control & PM_BIT(PLLEN)))
+               return 0;
+-      div = SM_BFEXT(PLLDIV, control) + 1;
+-      mul = SM_BFEXT(PLLMUL, control) + 1;
++      div = PM_BFEXT(PLLDIV, control) + 1;
++      mul = PM_BFEXT(PLLMUL, control) + 1;
+       rate = clk->parent->get_rate(clk->parent);
+       rate = (rate + div / 2) / div;
+@@ -121,7 +129,7 @@
+ {
+       u32 control;
+-      control = sm_readl(&system_manager, PM_PLL0);
++      control = pm_readl(PLL0);
+       return pll_get_rate(clk, control);
  }
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/process.c avr32-git/arch/avr32/kernel/process.c
---- linux-2.6.21.3/arch/avr32/kernel/process.c 2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/process.c      2007-06-06 11:33:46.000000000 +0200
-@@ -11,6 +11,7 @@
- #include <linux/fs.h>
- #include <linux/ptrace.h>
- #include <linux/reboot.h>
-+#include <linux/uaccess.h>
- #include <linux/unistd.h>
+@@ -130,7 +138,7 @@
+ {
+       u32 control;
  
- #include <asm/sysreg.h>
-@@ -19,6 +20,8 @@
- void (*pm_power_off)(void) = NULL;
- EXPORT_SYMBOL(pm_power_off);
+-      control = sm_readl(&system_manager, PM_PLL1);
++      control = pm_readl(PLL1);
  
-+extern void cpu_idle_sleep(void);
-+
- /*
-  * This file handles the architecture-dependent parts of process handling..
-  */
-@@ -27,9 +30,8 @@
+       return pll_get_rate(clk, control);
+ }
+@@ -187,108 +195,139 @@
+ static void cpu_clk_mode(struct clk *clk, int enabled)
  {
-       /* endless idle loop with no priority at all */
-       while (1) {
--              /* TODO: Enter sleep mode */
-               while (!need_resched())
--                      cpu_relax();
-+                      cpu_idle_sleep();
-               preempt_enable_no_resched();
-               schedule();
-               preempt_disable();
-@@ -114,39 +116,178 @@
-       /* do nothing */
+-      struct at32_sm *sm = &system_manager;
+       unsigned long flags;
+       u32 mask;
+-      spin_lock_irqsave(&sm->lock, flags);
+-      mask = sm_readl(sm, PM_CPU_MASK);
++      spin_lock_irqsave(&pm_lock, flags);
++      mask = pm_readl(CPU_MASK);
+       if (enabled)
+               mask |= 1 << clk->index;
+       else
+               mask &= ~(1 << clk->index);
+-      sm_writel(sm, PM_CPU_MASK, mask);
+-      spin_unlock_irqrestore(&sm->lock, flags);
++      pm_writel(CPU_MASK, mask);
++      spin_unlock_irqrestore(&pm_lock, flags);
  }
  
-+static void dump_mem(const char *str, const char *log_lvl,
-+                   unsigned long bottom, unsigned long top)
-+{
-+      unsigned long p;
-+      int i;
-+
-+      printk("%s%s(0x%08lx to 0x%08lx)\n", log_lvl, str, bottom, top);
-+
-+      for (p = bottom & ~31; p < top; ) {
-+              printk("%s%04lx: ", log_lvl, p & 0xffff);
-+
-+              for (i = 0; i < 8; i++, p += 4) {
-+                      unsigned int val;
-+
-+                      if (p < bottom || p >= top)
-+                              printk("         ");
-+                      else {
-+                              if (__get_user(val, (unsigned int __user *)p)) {
-+                                      printk("\n");
-+                                      goto out;
-+                              }
-+                              printk("%08x ", val);
-+                      }
-+              }
-+              printk("\n");
-+      }
-+
-+out:
-+      return;
-+}
-+
-+static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p)
+ static unsigned long cpu_clk_get_rate(struct clk *clk)
+ {
+       unsigned long cksel, shift = 0;
+-      cksel = sm_readl(&system_manager, PM_CKSEL);
+-      if (cksel & SM_BIT(CPUDIV))
+-              shift = SM_BFEXT(CPUSEL, cksel) + 1;
++      cksel = pm_readl(CKSEL);
++      if (cksel & PM_BIT(CPUDIV))
++              shift = PM_BFEXT(CPUSEL, cksel) + 1;
+       return bus_clk_get_rate(clk, shift);
+ }
++static long cpu_clk_set_rate(struct clk *clk, unsigned long rate, int apply)
 +{
-+      return (p > (unsigned long)tinfo)
-+              && (p < (unsigned long)tinfo + THREAD_SIZE - 3);
-+}
++      u32 control;
++      unsigned long parent_rate, child_div, actual_rate, div;
 +
-+#ifdef CONFIG_FRAME_POINTER
-+static void show_trace_log_lvl(struct task_struct *tsk, unsigned long *sp,
-+                             struct pt_regs *regs, const char *log_lvl)
-+{
-+      unsigned long lr, fp;
-+      struct thread_info *tinfo;
++      parent_rate = clk->parent->get_rate(clk->parent);
++      control = pm_readl(CKSEL);
 +
-+      if (regs)
-+              fp = regs->r7;
-+      else if (tsk == current)
-+              asm("mov %0, r7" : "=r"(fp));
++      if (control & PM_BIT(HSBDIV))
++              child_div = 1 << (PM_BFEXT(HSBSEL, control) + 1);
 +      else
-+              fp = tsk->thread.cpu_context.r7;
-+
-+      /*
-+       * Walk the stack as long as the frame pointer (a) is within
-+       * the kernel stack of the task, and (b) it doesn't move
-+       * downwards.
-+       */
-+      tinfo = task_thread_info(tsk);
-+      printk("%sCall trace:\n", log_lvl);
-+      while (valid_stack_ptr(tinfo, fp)) {
-+              unsigned long new_fp;
-+
-+              lr = *(unsigned long *)fp;
-+#ifdef CONFIG_KALLSYMS
-+              printk("%s [<%08lx>] ", log_lvl, lr);
-+#else
-+              printk(" [<%08lx>] ", lr);
-+#endif
-+              print_symbol("%s\n", lr);
-+
-+              new_fp = *(unsigned long *)(fp + 4);
-+              if (new_fp <= fp)
-+                      break;
-+              fp = new_fp;
-+      }
-+      printk("\n");
-+}
-+#else
-+static void show_trace_log_lvl(struct task_struct *tsk, unsigned long *sp,
-+                             struct pt_regs *regs, const char *log_lvl)
-+{
-+      unsigned long addr;
-+
-+      printk("%sCall trace:\n", log_lvl);
++              child_div = 1;
 +
-+      while (!kstack_end(sp)) {
-+              addr = *sp++;
-+              if (kernel_text_address(addr)) {
-+#ifdef CONFIG_KALLSYMS
-+                      printk("%s [<%08lx>] ", log_lvl, addr);
-+#else
-+                      printk(" [<%08lx>] ", addr);
-+#endif
-+                      print_symbol("%s\n", addr);
-+              }
-+      }
-+      printk("\n");
-+}
-+#endif
-+
-+void show_stack_log_lvl(struct task_struct *tsk, unsigned long sp,
-+                      struct pt_regs *regs, const char *log_lvl)
-+{
-+      struct thread_info *tinfo;
-+
-+      if (sp == 0) {
-+              if (tsk)
-+                      sp = tsk->thread.cpu_context.ksp;
-+              else
-+                      sp = (unsigned long)&tinfo;
-+      }
-+      if (!tsk)
-+              tsk = current;
-+
-+      tinfo = task_thread_info(tsk);
-+
-+      if (valid_stack_ptr(tinfo, sp)) {
-+              dump_mem("Stack: ", log_lvl, sp,
-+                       THREAD_SIZE + (unsigned long)tinfo);
-+              show_trace_log_lvl(tsk, (unsigned long *)sp, regs, log_lvl);
++      if (rate > 3 * (parent_rate / 4) || child_div == 1) {
++              actual_rate = parent_rate;
++              control &= ~PM_BIT(CPUDIV);
++      } else {
++              unsigned int cpusel;
++              div = (parent_rate + rate / 2) / rate;
++              if (div > child_div)
++                      div = child_div;
++              cpusel = (div > 1) ? (fls(div) - 2) : 0;
++              control = PM_BIT(CPUDIV) | PM_BFINS(CPUSEL, cpusel, control);
++              actual_rate = parent_rate / (1 << (cpusel + 1));
 +      }
-+}
 +
-+void show_stack(struct task_struct *tsk, unsigned long *stack)
-+{
-+      show_stack_log_lvl(tsk, (unsigned long)stack, NULL, "");
-+}
++      pr_debug("clk %s: new rate %lu (actual rate %lu)\n",
++                      clk->name, rate, actual_rate);
 +
-+void dump_stack(void)
-+{
-+      unsigned long stack;
++      if (apply)
++              pm_writel(CKSEL, control);
 +
-+      show_trace_log_lvl(current, &stack, NULL, "");
++      return actual_rate;
 +}
-+EXPORT_SYMBOL(dump_stack);
 +
- static const char *cpu_modes[] = {
-       "Application", "Supervisor", "Interrupt level 0", "Interrupt level 1",
-       "Interrupt level 2", "Interrupt level 3", "Exception", "NMI"
- };
+ static void hsb_clk_mode(struct clk *clk, int enabled)
+ {
+-      struct at32_sm *sm = &system_manager;
+       unsigned long flags;
+       u32 mask;
+-      spin_lock_irqsave(&sm->lock, flags);
+-      mask = sm_readl(sm, PM_HSB_MASK);
++      spin_lock_irqsave(&pm_lock, flags);
++      mask = pm_readl(HSB_MASK);
+       if (enabled)
+               mask |= 1 << clk->index;
+       else
+               mask &= ~(1 << clk->index);
+-      sm_writel(sm, PM_HSB_MASK, mask);
+-      spin_unlock_irqrestore(&sm->lock, flags);
++      pm_writel(HSB_MASK, mask);
++      spin_unlock_irqrestore(&pm_lock, flags);
+ }
  
--void show_regs(struct pt_regs *regs)
-+void show_regs_log_lvl(struct pt_regs *regs, const char *log_lvl)
+ static unsigned long hsb_clk_get_rate(struct clk *clk)
  {
-       unsigned long sp = regs->sp;
-       unsigned long lr = regs->lr;
-       unsigned long mode = (regs->sr & MODE_MASK) >> MODE_SHIFT;
--      if (!user_mode(regs))
-+      if (!user_mode(regs)) {
-               sp = (unsigned long)regs + FRAME_SIZE_FULL;
--      print_symbol("PC is at %s\n", instruction_pointer(regs));
--      print_symbol("LR is at %s\n", lr);
--      printk("pc : [<%08lx>]    lr : [<%08lx>]    %s\n"
--             "sp : %08lx  r12: %08lx  r11: %08lx\n",
--             instruction_pointer(regs),
--             lr, print_tainted(), sp, regs->r12, regs->r11);
--      printk("r10: %08lx  r9 : %08lx  r8 : %08lx\n",
--             regs->r10, regs->r9, regs->r8);
--      printk("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
--             regs->r7, regs->r6, regs->r5, regs->r4);
--      printk("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
--             regs->r3, regs->r2, regs->r1, regs->r0);
--      printk("Flags: %c%c%c%c%c\n",
-+              printk("%s", log_lvl);
-+              print_symbol("PC is at %s\n", instruction_pointer(regs));
-+              printk("%s", log_lvl);
-+              print_symbol("LR is at %s\n", lr);
-+      }
-+
-+      printk("%spc : [<%08lx>]    lr : [<%08lx>]    %s\n"
-+             "%ssp : %08lx  r12: %08lx  r11: %08lx\n",
-+             log_lvl, instruction_pointer(regs), lr, print_tainted(),
-+             log_lvl, sp, regs->r12, regs->r11);
-+      printk("%sr10: %08lx  r9 : %08lx  r8 : %08lx\n",
-+             log_lvl, regs->r10, regs->r9, regs->r8);
-+      printk("%sr7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
-+             log_lvl, regs->r7, regs->r6, regs->r5, regs->r4);
-+      printk("%sr3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
-+             log_lvl, regs->r3, regs->r2, regs->r1, regs->r0);
-+      printk("%sFlags: %c%c%c%c%c\n", log_lvl,
-              regs->sr & SR_Q ? 'Q' : 'q',
-              regs->sr & SR_V ? 'V' : 'v',
-              regs->sr & SR_N ? 'N' : 'n',
-              regs->sr & SR_Z ? 'Z' : 'z',
-              regs->sr & SR_C ? 'C' : 'c');
--      printk("Mode bits: %c%c%c%c%c%c%c%c%c\n",
-+      printk("%sMode bits: %c%c%c%c%c%c%c%c%c\n", log_lvl,
-              regs->sr & SR_H ? 'H' : 'h',
-              regs->sr & SR_R ? 'R' : 'r',
-              regs->sr & SR_J ? 'J' : 'j',
-@@ -156,9 +297,21 @@
-              regs->sr & SR_I1M ? '1' : '.',
-              regs->sr & SR_I0M ? '0' : '.',
-              regs->sr & SR_GM ? 'G' : 'g');
--      printk("CPU Mode: %s\n", cpu_modes[mode]);
-+      printk("%sCPU Mode: %s\n", log_lvl, cpu_modes[mode]);
-+      printk("%sProcess: %s [%d] (task: %p thread: %p)\n",
-+             log_lvl, current->comm, current->pid, current,
-+             task_thread_info(current));
-+}
-+
-+void show_regs(struct pt_regs *regs)
-+{
-+      unsigned long sp = regs->sp;
-+
-+      if (!user_mode(regs))
-+              sp = (unsigned long)regs + FRAME_SIZE_FULL;
--      show_trace(NULL, (unsigned long *)sp, regs);
-+      show_regs_log_lvl(regs, "");
-+      show_trace_log_lvl(current, (unsigned long *)sp, regs, "");
+       unsigned long cksel, shift = 0;
+-      cksel = sm_readl(&system_manager, PM_CKSEL);
+-      if (cksel & SM_BIT(HSBDIV))
+-              shift = SM_BFEXT(HSBSEL, cksel) + 1;
++      cksel = pm_readl(CKSEL);
++      if (cksel & PM_BIT(HSBDIV))
++              shift = PM_BFEXT(HSBSEL, cksel) + 1;
+       return bus_clk_get_rate(clk, shift);
  }
- EXPORT_SYMBOL(show_regs);
  
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/setup.c avr32-git/arch/avr32/kernel/setup.c
---- linux-2.6.21.3/arch/avr32/kernel/setup.c   2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/setup.c        2007-06-06 11:33:46.000000000 +0200
-@@ -8,12 +8,14 @@
+ static void pba_clk_mode(struct clk *clk, int enabled)
+ {
+-      struct at32_sm *sm = &system_manager;
+       unsigned long flags;
+       u32 mask;
+-      spin_lock_irqsave(&sm->lock, flags);
+-      mask = sm_readl(sm, PM_PBA_MASK);
++      spin_lock_irqsave(&pm_lock, flags);
++      mask = pm_readl(PBA_MASK);
+       if (enabled)
+               mask |= 1 << clk->index;
+       else
+               mask &= ~(1 << clk->index);
+-      sm_writel(sm, PM_PBA_MASK, mask);
+-      spin_unlock_irqrestore(&sm->lock, flags);
++      pm_writel(PBA_MASK, mask);
++      spin_unlock_irqrestore(&pm_lock, flags);
+ }
  
- #include <linux/clk.h>
- #include <linux/init.h>
-+#include <linux/initrd.h>
- #include <linux/sched.h>
- #include <linux/console.h>
- #include <linux/ioport.h>
- #include <linux/bootmem.h>
- #include <linux/fs.h>
- #include <linux/module.h>
-+#include <linux/pfn.h>
- #include <linux/root_dev.h>
- #include <linux/cpu.h>
- #include <linux/kernel.h>
-@@ -30,13 +32,6 @@
- extern int root_mountflags;
+ static unsigned long pba_clk_get_rate(struct clk *clk)
+ {
+       unsigned long cksel, shift = 0;
  
- /*
-- * Bootloader-provided information about physical memory
-- */
--struct tag_mem_range *mem_phys;
--struct tag_mem_range *mem_reserved;
--struct tag_mem_range *mem_ramdisk;
--
--/*
-  * Initialize loops_per_jiffy as 5000000 (500MIPS).
-  * Better make it too large than too small...
-  */
-@@ -48,48 +43,193 @@
- static char __initdata command_line[COMMAND_LINE_SIZE];
+-      cksel = sm_readl(&system_manager, PM_CKSEL);
+-      if (cksel & SM_BIT(PBADIV))
+-              shift = SM_BFEXT(PBASEL, cksel) + 1;
++      cksel = pm_readl(CKSEL);
++      if (cksel & PM_BIT(PBADIV))
++              shift = PM_BFEXT(PBASEL, cksel) + 1;
  
- /*
-- * Should be more than enough, but if you have a _really_ complex
-- * setup, you might need to increase the size of this...
-+ * Standard memory resources
-  */
--static struct tag_mem_range __initdata mem_range_cache[32];
--static unsigned mem_range_next_free;
-+static struct resource __initdata kernel_data = {
-+      .name   = "Kernel data",
-+      .start  = 0,
-+      .end    = 0,
-+      .flags  = IORESOURCE_MEM,
-+};
-+static struct resource __initdata kernel_code = {
-+      .name   = "Kernel code",
-+      .start  = 0,
-+      .end    = 0,
-+      .flags  = IORESOURCE_MEM,
-+      .sibling = &kernel_data,
-+};
+       return bus_clk_get_rate(clk, shift);
+ }
  
- /*
-- * Standard memory resources
-+ * Available system RAM and reserved regions as singly linked
-+ * lists. These lists are traversed using the sibling pointer in
-+ * struct resource and are kept sorted at all times.
-  */
--static struct resource mem_res[] = {
--      {
--              .name   = "Kernel code",
--              .start  = 0,
--              .end    = 0,
--              .flags  = IORESOURCE_MEM
--      },
--      {
--              .name   = "Kernel data",
--              .start  = 0,
--              .end    = 0,
--              .flags  = IORESOURCE_MEM,
--      },
--};
-+static struct resource *__initdata system_ram;
-+static struct resource *__initdata reserved = &kernel_code;
-+
-+/*
-+ * We need to allocate these before the bootmem allocator is up and
-+ * running, so we need this "cache". 32 entries are probably enough
-+ * for all but the most insanely complex systems.
-+ */
-+static struct resource __initdata res_cache[32];
-+static unsigned int __initdata res_cache_next_free;
-+
-+static void __init resource_init(void)
-+{
-+      struct resource *mem, *res;
-+      struct resource *new;
-+
-+      kernel_code.start = __pa(init_mm.start_code);
-+
-+      for (mem = system_ram; mem; mem = mem->sibling) {
-+              new = alloc_bootmem_low(sizeof(struct resource));
-+              memcpy(new, mem, sizeof(struct resource));
-+
-+              new->sibling = NULL;
-+              if (request_resource(&iomem_resource, new))
-+                      printk(KERN_WARNING "Bad RAM resource %08x-%08x\n",
-+                             mem->start, mem->end);
-+      }
-+
-+      for (res = reserved; res; res = res->sibling) {
-+              new = alloc_bootmem_low(sizeof(struct resource));
-+              memcpy(new, res, sizeof(struct resource));
-+
-+              new->sibling = NULL;
-+              if (insert_resource(&iomem_resource, new))
-+                      printk(KERN_WARNING
-+                             "Bad reserved resource %s (%08x-%08x)\n",
-+                             res->name, res->start, res->end);
-+      }
-+}
-+
-+static void __init
-+add_physical_memory(resource_size_t start, resource_size_t end)
-+{
-+      struct resource *new, *next, **pprev;
-+
-+      for (pprev = &system_ram, next = system_ram; next;
-+           pprev = &next->sibling, next = next->sibling) {
-+              if (end < next->start)
-+                      break;
-+              if (start <= next->end) {
-+                      printk(KERN_WARNING
-+                             "Warning: Physical memory map is broken\n");
-+                      printk(KERN_WARNING
-+                             "Warning: %08x-%08x overlaps %08x-%08x\n",
-+                             start, end, next->start, next->end);
-+                      return;
-+              }
-+      }
-+
-+      if (res_cache_next_free >= ARRAY_SIZE(res_cache)) {
-+              printk(KERN_WARNING
-+                     "Warning: Failed to add physical memory %08x-%08x\n",
-+                     start, end);
-+              return;
-+      }
-+
-+      new = &res_cache[res_cache_next_free++];
-+      new->start = start;
-+      new->end = end;
-+      new->name = "System RAM";
-+      new->flags = IORESOURCE_MEM;
-+
-+      *pprev = new;
-+}
-+
-+static int __init
-+add_reserved_region(resource_size_t start, resource_size_t end,
-+                  const char *name)
-+{
-+      struct resource *new, *next, **pprev;
-+
-+      if (end < start)
-+              return -EINVAL;
-+
-+      if (res_cache_next_free >= ARRAY_SIZE(res_cache))
-+              return -ENOMEM;
-+
-+      for (pprev = &reserved, next = reserved; next;
-+           pprev = &next->sibling, next = next->sibling) {
-+              if (end < next->start)
-+                      break;
-+              if (start <= next->end)
-+                      return -EBUSY;
-+      }
-+
-+      new = &res_cache[res_cache_next_free++];
-+      new->start = start;
-+      new->end = end;
-+      new->name = name;
-+      new->flags = IORESOURCE_MEM;
--#define kernel_code   mem_res[0]
--#define kernel_data   mem_res[1]
-+      *pprev = new;
-+
-+      return 0;
-+}
-+
-+static unsigned long __init
-+find_free_region(const struct resource *mem, resource_size_t size,
-+               resource_size_t align)
-+{
-+      struct resource *res;
-+      unsigned long target;
-+
-+      target = ALIGN(mem->start, align);
-+      for (res = reserved; res; res = res->sibling) {
-+              if ((target + size) <= res->start)
-+                      break;
-+              if (target <= res->end)
-+                      target = ALIGN(res->end + 1, align);
-+      }
-+
-+      if ((target + size) > (mem->end + 1))
-+              return mem->end + 1;
-+
-+      return target;
-+}
-+
-+static int __init
-+alloc_reserved_region(resource_size_t *start, resource_size_t size,
-+                    resource_size_t align, const char *name)
-+{
-+      struct resource *mem;
-+      resource_size_t target;
-+      int ret;
-+
-+      for (mem = system_ram; mem; mem = mem->sibling) {
-+              target = find_free_region(mem, size, align);
-+              if (target <= mem->end) {
-+                      ret = add_reserved_region(target, target + size - 1,
-+                                                name);
-+                      if (!ret)
-+                              *start = target;
-+                      return ret;
-+              }
-+      }
-+
-+      return -ENOMEM;
-+}
- /*
-  * Early framebuffer allocation. Works as follows:
-  *   - If fbmem_size is zero, nothing will be allocated or reserved.
-  *   - If fbmem_start is zero when setup_bootmem() is called,
-- *     fbmem_size bytes will be allocated from the bootmem allocator.
-+ *     a block of fbmem_size bytes will be reserved before bootmem
-+ *     initialization. It will be aligned to the largest page size
-+ *     that fbmem_size is a multiple of.
-  *   - If fbmem_start is nonzero, an area of size fbmem_size will be
-- *     reserved at the physical address fbmem_start if necessary. If
-- *     the area isn't in a memory region known to the kernel, it will
-- *     be left alone.
-+ *     reserved at the physical address fbmem_start if possible. If
-+ *     it collides with other reserved memory, a different block of
-+ *     same size will be allocated, just as if fbmem_start was zero.
-  *
-  * Board-specific code may use these variables to set up platform data
-  * for the framebuffer driver if fbmem_size is nonzero.
-  */
--static unsigned long __initdata fbmem_start;
--static unsigned long __initdata fbmem_size;
-+resource_size_t __initdata fbmem_start;
-+resource_size_t __initdata fbmem_size;
- /*
-  * "fbmem=xxx[kKmM]" allocates the specified amount of boot memory for
-@@ -103,48 +243,42 @@
-  */
- static int __init early_parse_fbmem(char *p)
- {
-+      int ret;
-+      unsigned long align;
-+
-       fbmem_size = memparse(p, &p);
--      if (*p == '@')
-+      if (*p == '@') {
-               fbmem_start = memparse(p, &p);
--      return 0;
--}
--early_param("fbmem", early_parse_fbmem);
--
--static inline void __init resource_init(void)
--{
--      struct tag_mem_range *region;
--
--      kernel_code.start = __pa(init_mm.start_code);
--      kernel_code.end = __pa(init_mm.end_code - 1);
--      kernel_data.start = __pa(init_mm.end_code);
--      kernel_data.end = __pa(init_mm.brk - 1);
-+              ret = add_reserved_region(fbmem_start,
-+                                        fbmem_start + fbmem_size - 1,
-+                                        "Framebuffer");
-+              if (ret) {
-+                      printk(KERN_WARNING
-+                             "Failed to reserve framebuffer memory\n");
-+                      fbmem_start = 0;
-+              }
-+      }
--      for (region = mem_phys; region; region = region->next) {
--              struct resource *res;
--              unsigned long phys_start, phys_end;
--
--              if (region->size == 0)
--                      continue;
--
--              phys_start = region->addr;
--              phys_end = phys_start + region->size - 1;
--
--              res = alloc_bootmem_low(sizeof(*res));
--              res->name = "System RAM";
--              res->start = phys_start;
--              res->end = phys_end;
--              res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
--
--              request_resource (&iomem_resource, res);
--
--              if (kernel_code.start >= res->start &&
--                  kernel_code.end <= res->end)
--                      request_resource (res, &kernel_code);
--              if (kernel_data.start >= res->start &&
--                  kernel_data.end <= res->end)
--                      request_resource (res, &kernel_data);
-+      if (!fbmem_start) {
-+              if ((fbmem_size & 0x000fffffUL) == 0)
-+                      align = 0x100000;       /* 1 MiB */
-+              else if ((fbmem_size & 0x0000ffffUL) == 0)
-+                      align = 0x10000;        /* 64 KiB */
-+              else
-+                      align = 0x1000;         /* 4 KiB */
-+
-+              ret = alloc_reserved_region(&fbmem_start, fbmem_size,
-+                                          align, "Framebuffer");
-+              if (ret) {
-+                      printk(KERN_WARNING
-+                             "Failed to allocate framebuffer memory\n");
-+                      fbmem_size = 0;
-+              }
-       }
-+
-+      return 0;
- }
-+early_param("fbmem", early_parse_fbmem);
- static int __init parse_tag_core(struct tag *tag)
+ static void pbb_clk_mode(struct clk *clk, int enabled)
  {
-@@ -157,11 +291,9 @@
+-      struct at32_sm *sm = &system_manager;
+       unsigned long flags;
+       u32 mask;
+-      spin_lock_irqsave(&sm->lock, flags);
+-      mask = sm_readl(sm, PM_PBB_MASK);
++      spin_lock_irqsave(&pm_lock, flags);
++      mask = pm_readl(PBB_MASK);
+       if (enabled)
+               mask |= 1 << clk->index;
+       else
+               mask &= ~(1 << clk->index);
+-      sm_writel(sm, PM_PBB_MASK, mask);
+-      spin_unlock_irqrestore(&sm->lock, flags);
++      pm_writel(PBB_MASK, mask);
++      spin_unlock_irqrestore(&pm_lock, flags);
  }
- __tagtable(ATAG_CORE, parse_tag_core);
  
--static int __init parse_tag_mem_range(struct tag *tag,
--                                    struct tag_mem_range **root)
-+static int __init parse_tag_mem(struct tag *tag)
+ static unsigned long pbb_clk_get_rate(struct clk *clk)
  {
--      struct tag_mem_range *cur, **pprev;
--      struct tag_mem_range *new;
-+      unsigned long start, end;
+       unsigned long cksel, shift = 0;
  
-       /*
-        * Ignore zero-sized entries. If we're running standalone, the
-@@ -171,34 +303,53 @@
-       if (tag->u.mem_range.size == 0)
-               return 0;
--      /*
--       * Copy the data so the bootmem init code doesn't need to care
--       * about it.
--       */
--      if (mem_range_next_free >= ARRAY_SIZE(mem_range_cache))
--              panic("Physical memory map too complex!\n");
-+      start = tag->u.mem_range.addr;
-+      end = tag->u.mem_range.addr + tag->u.mem_range.size - 1;
--      new = &mem_range_cache[mem_range_next_free++];
--      *new = tag->u.mem_range;
-+      add_physical_memory(start, end);
-+      return 0;
-+}
-+__tagtable(ATAG_MEM, parse_tag_mem);
--      pprev = root;
--      cur = *root;
--      while (cur) {
--              pprev = &cur->next;
--              cur = cur->next;
-+static int __init parse_tag_rdimg(struct tag *tag)
-+{
-+#ifdef CONFIG_INITRD
-+      struct tag_mem_range *mem = &tag->u.mem_range;
-+      int ret;
-+
-+      if (initrd_start) {
-+              printk(KERN_WARNING
-+                     "Warning: Only the first initrd image will be used\n");
-+              return 0;
-       }
--      *pprev = new;
--      new->next = NULL;
-+      ret = add_reserved_region(mem->start, mem->start + mem->size - 1,
-+                                "initrd");
-+      if (ret) {
-+              printk(KERN_WARNING
-+                     "Warning: Failed to reserve initrd memory\n");
-+              return ret;
-+      }
-+
-+      initrd_start = (unsigned long)__va(mem->addr);
-+      initrd_end = initrd_start + mem->size;
-+#else
-+      printk(KERN_WARNING "RAM disk image present, but "
-+             "no initrd support in kernel, ignoring\n");
-+#endif
+-      cksel = sm_readl(&system_manager, PM_CKSEL);
+-      if (cksel & SM_BIT(PBBDIV))
+-              shift = SM_BFEXT(PBBSEL, cksel) + 1;
++      cksel = pm_readl(CKSEL);
++      if (cksel & PM_BIT(PBBDIV))
++              shift = PM_BFEXT(PBBSEL, cksel) + 1;
  
-       return 0;
+       return bus_clk_get_rate(clk, shift);
  }
-+__tagtable(ATAG_RDIMG, parse_tag_rdimg);
--static int __init parse_tag_mem(struct tag *tag)
-+static int __init parse_tag_rsvd_mem(struct tag *tag)
+@@ -296,6 +335,7 @@
+ static struct clk cpu_clk = {
+       .name           = "cpu",
+       .get_rate       = cpu_clk_get_rate,
++      .set_rate       = cpu_clk_set_rate,
+       .users          = 1,
+ };
+ static struct clk hsb_clk = {
+@@ -327,12 +367,12 @@
  {
--      return parse_tag_mem_range(tag, &mem_phys);
-+      struct tag_mem_range *mem = &tag->u.mem_range;
-+
-+      return add_reserved_region(mem->addr, mem->addr + mem->size - 1,
-+                                 "Reserved");
- }
--__tagtable(ATAG_MEM, parse_tag_mem);
-+__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem);
+       u32 control;
  
- static int __init parse_tag_cmdline(struct tag *tag)
- {
-@@ -207,12 +358,6 @@
+-      control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index);
++      control = pm_readl(GCCTRL(clk->index));
+       if (enabled)
+-              control |= SM_BIT(CEN);
++              control |= PM_BIT(CEN);
+       else
+-              control &= ~SM_BIT(CEN);
+-      sm_writel(&system_manager, PM_GCCTRL + 4 * clk->index, control);
++              control &= ~PM_BIT(CEN);
++      pm_writel(GCCTRL(clk->index), control);
  }
- __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
  
--static int __init parse_tag_rdimg(struct tag *tag)
--{
--      return parse_tag_mem_range(tag, &mem_ramdisk);
--}
--__tagtable(ATAG_RDIMG, parse_tag_rdimg);
--
- static int __init parse_tag_clock(struct tag *tag)
- {
-       /*
-@@ -223,12 +368,6 @@
- }
- __tagtable(ATAG_CLOCK, parse_tag_clock);
+ static unsigned long genclk_get_rate(struct clk *clk)
+@@ -340,9 +380,9 @@
+       u32 control;
+       unsigned long div = 1;
  
--static int __init parse_tag_rsvd_mem(struct tag *tag)
--{
--      return parse_tag_mem_range(tag, &mem_reserved);
--}
--__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem);
--
- /*
-  * Scan the tag table for this tag, and call its parse function. The
-  * tag table is built by the linker from all the __tagtable
-@@ -260,10 +399,137 @@
-                              t->hdr.tag);
- }
+-      control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index);
+-      if (control & SM_BIT(DIVEN))
+-              div = 2 * (SM_BFEXT(DIV, control) + 1);
++      control = pm_readl(GCCTRL(clk->index));
++      if (control & PM_BIT(DIVEN))
++              div = 2 * (PM_BFEXT(DIV, control) + 1);
  
-+/*
-+ * Find a free memory region large enough for storing the
-+ * bootmem bitmap.
-+ */
-+static unsigned long __init
-+find_bootmap_pfn(const struct resource *mem)
-+{
-+      unsigned long bootmap_pages, bootmap_len;
-+      unsigned long node_pages = PFN_UP(mem->end - mem->start + 1);
-+      unsigned long bootmap_start;
-+
-+      bootmap_pages = bootmem_bootmap_pages(node_pages);
-+      bootmap_len = bootmap_pages << PAGE_SHIFT;
-+
-+      /*
-+       * Find a large enough region without reserved pages for
-+       * storing the bootmem bitmap. We can take advantage of the
-+       * fact that all lists have been sorted.
-+       *
-+       * We have to check that we don't collide with any reserved
-+       * regions, which includes the kernel image and any RAMDISK
-+       * images.
-+       */
-+      bootmap_start = find_free_region(mem, bootmap_len, PAGE_SIZE);
-+
-+      return bootmap_start >> PAGE_SHIFT;
-+}
-+
-+#define MAX_LOWMEM    HIGHMEM_START
-+#define MAX_LOWMEM_PFN        PFN_DOWN(MAX_LOWMEM)
-+
-+static void __init setup_bootmem(void)
-+{
-+      unsigned bootmap_size;
-+      unsigned long first_pfn, bootmap_pfn, pages;
-+      unsigned long max_pfn, max_low_pfn;
-+      unsigned node = 0;
-+      struct resource *res;
-+
-+      printk(KERN_INFO "Physical memory:\n");
-+      for (res = system_ram; res; res = res->sibling)
-+              printk("  %08x-%08x\n", res->start, res->end);
-+      printk(KERN_INFO "Reserved memory:\n");
-+      for (res = reserved; res; res = res->sibling)
-+              printk("  %08x-%08x: %s\n",
-+                     res->start, res->end, res->name);
-+
-+      nodes_clear(node_online_map);
-+
-+      if (system_ram->sibling)
-+              printk(KERN_WARNING "Only using first memory bank\n");
-+
-+      for (res = system_ram; res; res = NULL) {
-+              first_pfn = PFN_UP(res->start);
-+              max_low_pfn = max_pfn = PFN_DOWN(res->end + 1);
-+              bootmap_pfn = find_bootmap_pfn(res);
-+              if (bootmap_pfn > max_pfn)
-+                      panic("No space for bootmem bitmap!\n");
-+
-+              if (max_low_pfn > MAX_LOWMEM_PFN) {
-+                      max_low_pfn = MAX_LOWMEM_PFN;
-+#ifndef CONFIG_HIGHMEM
-+                      /*
-+                       * Lowmem is memory that can be addressed
-+                       * directly through P1/P2
-+                       */
-+                      printk(KERN_WARNING
-+                             "Node %u: Only %ld MiB of memory will be used.\n",
-+                             node, MAX_LOWMEM >> 20);
-+                      printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
-+#else
-+#error HIGHMEM is not supported by AVR32 yet
-+#endif
-+              }
-+
-+              /* Initialize the boot-time allocator with low memory only. */
-+              bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn,
-+                                               first_pfn, max_low_pfn);
-+
-+              /*
-+               * Register fully available RAM pages with the bootmem
-+               * allocator.
-+               */
-+              pages = max_low_pfn - first_pfn;
-+              free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn),
-+                                 PFN_PHYS(pages));
-+
-+              /* Reserve space for the bootmem bitmap... */
-+              reserve_bootmem_node(NODE_DATA(node),
-+                                   PFN_PHYS(bootmap_pfn),
-+                                   bootmap_size);
-+
-+              /* ...and any other reserved regions. */
-+              for (res = reserved; res; res = res->sibling) {
-+                      if (res->start > PFN_PHYS(max_pfn))
-+                              break;
-+
-+                      /*
-+                       * resource_init will complain about partial
-+                       * overlaps, so we'll just ignore such
-+                       * resources for now.
-+                       */
-+                      if (res->start >= PFN_PHYS(first_pfn)
-+                          && res->end < PFN_PHYS(max_pfn))
-+                              reserve_bootmem_node(
-+                                      NODE_DATA(node), res->start,
-+                                      res->end - res->start + 1);
-+              }
-+
-+              node_set_online(node);
-+      }
-+}
-+
- void __init setup_arch (char **cmdline_p)
- {
-       struct clk *cpu_clk;
+       return clk->parent->get_rate(clk->parent) / div;
+ }
+@@ -353,23 +393,22 @@
+       unsigned long parent_rate, actual_rate, div;
  
-+      init_mm.start_code = (unsigned long)_text;
-+      init_mm.end_code = (unsigned long)_etext;
-+      init_mm.end_data = (unsigned long)_edata;
-+      init_mm.brk = (unsigned long)_end;
-+
-+      /*
-+       * Include .init section to make allocations easier. It will
-+       * be removed before the resource is actually requested.
-+       */
-+      kernel_code.start = __pa(__init_begin);
-+      kernel_code.end = __pa(init_mm.end_code - 1);
-+      kernel_data.start = __pa(init_mm.end_code);
-+      kernel_data.end = __pa(init_mm.brk - 1);
-+
-       parse_tags(bootloader_tags);
+       parent_rate = clk->parent->get_rate(clk->parent);
+-      control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index);
++      control = pm_readl(GCCTRL(clk->index));
  
-       setup_processor();
-@@ -289,24 +555,16 @@
-                      ((cpu_hz + 500) / 1000) % 1000);
+       if (rate > 3 * parent_rate / 4) {
+               actual_rate = parent_rate;
+-              control &= ~SM_BIT(DIVEN);
++              control &= ~PM_BIT(DIVEN);
+       } else {
+               div = (parent_rate + rate) / (2 * rate) - 1;
+-              control = SM_BFINS(DIV, div, control) | SM_BIT(DIVEN);
++              control = PM_BFINS(DIV, div, control) | PM_BIT(DIVEN);
+               actual_rate = parent_rate / (2 * (div + 1));
        }
  
--      init_mm.start_code = (unsigned long) &_text;
--      init_mm.end_code = (unsigned long) &_etext;
--      init_mm.end_data = (unsigned long) &_edata;
--      init_mm.brk = (unsigned long) &_end;
--
-       strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
-       *cmdline_p = command_line;
-       parse_early_param();
-       setup_bootmem();
+-      printk("clk %s: new rate %lu (actual rate %lu)\n",
+-             clk->name, rate, actual_rate);
++      dev_dbg(clk->dev, "clk %s: new rate %lu (actual rate %lu)\n",
++              clk->name, rate, actual_rate);
  
--      board_setup_fbmem(fbmem_start, fbmem_size);
--
- #ifdef CONFIG_VT
-       conswitchp = &dummy_con;
- #endif
+       if (apply)
+-              sm_writel(&system_manager, PM_GCCTRL + 4 * clk->index,
+-                        control);
++              pm_writel(GCCTRL(clk->index), control);
  
-       paging_init();
--
-       resource_init();
+       return actual_rate;
  }
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/time.c avr32-git/arch/avr32/kernel/time.c
---- linux-2.6.21.3/arch/avr32/kernel/time.c    2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/time.c 2007-06-06 11:33:46.000000000 +0200
-@@ -1,5 +1,5 @@
- /*
-- * Copyright (C) 2004-2006 Atmel Corporation
-+ * Copyright (C) 2004-2007 Atmel Corporation
-  *
-  * Based on MIPS implementation arch/mips/kernel/time.c
-  *   Copyright 2001 MontaVista Software Inc.
-@@ -20,18 +20,25 @@
- #include <linux/init.h>
- #include <linux/profile.h>
- #include <linux/sysdev.h>
-+#include <linux/err.h>
+@@ -378,24 +417,24 @@
+ {
+       u32 control;
+-      printk("clk %s: new parent %s (was %s)\n",
+-             clk->name, parent->name, clk->parent->name);
++      dev_dbg(clk->dev, "clk %s: new parent %s (was %s)\n",
++              clk->name, parent->name, clk->parent->name);
+-      control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index);
++      control = pm_readl(GCCTRL(clk->index));
+       if (parent == &osc1 || parent == &pll1)
+-              control |= SM_BIT(OSCSEL);
++              control |= PM_BIT(OSCSEL);
+       else if (parent == &osc0 || parent == &pll0)
+-              control &= ~SM_BIT(OSCSEL);
++              control &= ~PM_BIT(OSCSEL);
+       else
+               return -EINVAL;
  
- #include <asm/div64.h>
- #include <asm/sysreg.h>
- #include <asm/io.h>
- #include <asm/sections.h>
+       if (parent == &pll0 || parent == &pll1)
+-              control |= SM_BIT(PLLSEL);
++              control |= PM_BIT(PLLSEL);
+       else
+-              control &= ~SM_BIT(PLLSEL);
++              control &= ~PM_BIT(PLLSEL);
  
--static cycle_t read_cycle_count(void)
-+/* how many counter cycles in a jiffy? */
-+static u32 cycles_per_jiffy;
-+
-+/* the count value for the next timer interrupt */
-+static u32 expirelo;
-+
-+cycle_t __weak read_cycle_count(void)
- {
-       return (cycle_t)sysreg_read(COUNT);
- }
+-      sm_writel(&system_manager, PM_GCCTRL + 4 * clk->index, control);
++      pm_writel(GCCTRL(clk->index), control);
+       clk->parent = parent;
  
--static struct clocksource clocksource_avr32 = {
-+struct clocksource __weak clocksource_avr32 = {
-       .name           = "avr32",
-       .rating         = 350,
-       .read           = read_cycle_count,
-@@ -40,12 +47,20 @@
-       .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
- };
+       return 0;
+@@ -408,11 +447,11 @@
  
-+irqreturn_t __weak timer_interrupt(int irq, void *dev_id);
-+
-+struct irqaction timer_irqaction = {
-+      .handler        = timer_interrupt,
-+      .flags          = IRQF_DISABLED,
-+      .name           = "timer",
-+};
-+
- /*
-  * By default we provide the null RTC ops
-  */
- static unsigned long null_rtc_get_time(void)
- {
--      return mktime(2004, 1, 1, 0, 0, 0);
-+      return mktime(2007, 1, 1, 0, 0, 0);
- }
+       BUG_ON(clk->index > 7);
  
- static int null_rtc_set_time(unsigned long sec)
-@@ -56,23 +71,14 @@
- static unsigned long (*rtc_get_time)(void) = null_rtc_get_time;
- static int (*rtc_set_time)(unsigned long) = null_rtc_set_time;
+-      control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index);
+-      if (control & SM_BIT(OSCSEL))
+-              parent = (control & SM_BIT(PLLSEL)) ? &pll1 : &osc1;
++      control = pm_readl(GCCTRL(clk->index));
++      if (control & PM_BIT(OSCSEL))
++              parent = (control & PM_BIT(PLLSEL)) ? &pll1 : &osc1;
+       else
+-              parent = (control & SM_BIT(PLLSEL)) ? &pll0 : &osc0;
++              parent = (control & PM_BIT(PLLSEL)) ? &pll0 : &osc0;
  
--/* how many counter cycles in a jiffy? */
--static unsigned long cycles_per_jiffy;
--
--/* cycle counter value at the previous timer interrupt */
--static unsigned int timerhi, timerlo;
--
--/* the count value for the next timer interrupt */
--static unsigned int expirelo;
--
- static void avr32_timer_ack(void)
- {
--      unsigned int count;
-+      u32 count;
-       /* Ack this timer interrupt and set the next one */
-       expirelo += cycles_per_jiffy;
-+      /* setting COMPARE to 0 stops the COUNT-COMPARE */
-       if (expirelo == 0) {
--              printk(KERN_DEBUG "expirelo == 0\n");
-               sysreg_write(COMPARE, expirelo + 1);
-       } else {
-               sysreg_write(COMPARE, expirelo);
-@@ -86,27 +92,56 @@
-       }
+       clk->parent = parent;
  }
--static unsigned int avr32_hpt_read(void)
-+int __weak avr32_hpt_init(void)
- {
--      return sysreg_read(COUNT);
-+      int ret;
-+      unsigned long mult, shift, count_hz;
-+
-+      count_hz = clk_get_rate(boot_cpu_data.clk);
-+      shift = clocksource_avr32.shift;
-+      mult = clocksource_hz2mult(count_hz, shift);
-+      clocksource_avr32.mult = mult;
-+
+@@ -420,21 +459,53 @@
+ /* --------------------------------------------------------------------
+  *  System peripherals
+  * -------------------------------------------------------------------- */
+-static struct resource sm_resource[] = {
+-      PBMEM(0xfff00000),
+-      NAMED_IRQ(19, "eim"),
+-      NAMED_IRQ(20, "pm"),
+-      NAMED_IRQ(21, "rtc"),
++static struct resource at32_pm0_resource[] = {
 +      {
-+              u64 tmp;
++              .start  = 0xfff00000,
++              .end    = 0xfff0007f,
++              .flags  = IORESOURCE_MEM,
++      },
++      IRQ(20),
+ };
+-struct platform_device at32_sm_device = {
+-      .name           = "sm",
+-      .id             = 0,
+-      .resource       = sm_resource,
+-      .num_resources  = ARRAY_SIZE(sm_resource),
 +
-+              tmp = TICK_NSEC;
-+              tmp <<= shift;
-+              tmp += mult / 2;
-+              do_div(tmp, mult);
++static struct resource at32ap700x_rtc0_resource[] = {
++      {
++              .start  = 0xfff00080,
++              .end    = 0xfff000af,
++              .flags  = IORESOURCE_MEM,
++      },
++      IRQ(21),
++};
 +
-+              cycles_per_jiffy = tmp;
-+      }
++static struct resource at32_wdt0_resource[] = {
++      {
++              .start  = 0xfff000b0,
++              .end    = 0xfff000bf,
++              .flags  = IORESOURCE_MEM,
++      },
++};
 +
-+      ret = setup_irq(0, &timer_irqaction);
-+      if (ret) {
-+              pr_debug("timer: could not request IRQ 0: %d\n", ret);
-+              return -ENODEV;
-+      }
++static struct resource at32_eic0_resource[] = {
++      {
++              .start  = 0xfff00100,
++              .end    = 0xfff0013f,
++              .flags  = IORESOURCE_MEM,
++      },
++      IRQ(19),
+ };
+-static struct clk at32_sm_pclk = {
 +
-+      printk(KERN_INFO "timer: AT32AP COUNT-COMPARE at irq 0, "
-+                      "%lu.%03lu MHz\n",
-+                      ((count_hz + 500) / 1000) / 1000,
-+                      ((count_hz + 500) / 1000) % 1000);
++DEFINE_DEV(at32_pm, 0);
++DEFINE_DEV(at32ap700x_rtc, 0);
++DEFINE_DEV(at32_wdt, 0);
++DEFINE_DEV(at32_eic, 0);
 +
-+      return 0;
- }
++/*
++ * Peripheral clock for PM, RTC, WDT and EIC. PM will ensure that this
++ * is always running.
++ */
++static struct clk at32_pm_pclk = {
+       .name           = "pclk",
+-      .dev            = &at32_sm_device.dev,
++      .dev            = &at32_pm0_device.dev,
+       .parent         = &pbb_clk,
+       .mode           = pbb_clk_mode,
+       .get_rate       = pbb_clk_get_rate,
+@@ -491,6 +562,17 @@
+       .users          = 1,
+ };
  
- /*
-  * Taken from MIPS c0_hpt_timer_init().
-  *
-- * Why is it so complicated, and what is "count"?  My assumption is
-- * that `count' specifies the "reference cycle", i.e. the cycle since
-- * reset that should mean "zero". The reason COUNT is written twice is
-- * probably to make sure we don't get any timer interrupts while we
-- * are messing with the counter.
-+ * The reason COUNT is written twice is probably to make sure we don't get any
-+ * timer interrupts while we are messing with the counter.
-  */
--static void avr32_hpt_init(unsigned int count)
-+int __weak avr32_hpt_start(void)
- {
--      count = sysreg_read(COUNT) - count;
-+      u32 count = sysreg_read(COUNT);
-       expirelo = (count / cycles_per_jiffy + 1) * cycles_per_jiffy;
-       sysreg_write(COUNT, expirelo - cycles_per_jiffy);
-       sysreg_write(COMPARE, expirelo);
-       sysreg_write(COUNT, count);
++static struct resource dmaca0_resource[] = {
++      {
++              .start  = 0xff200000,
++              .end    = 0xff20ffff,
++              .flags  = IORESOURCE_MEM,
++      },
++      IRQ(2),
++};
++DEFINE_DEV(dmaca, 0);
++DEV_CLK(hclk, dmaca0, hsb, 10);
 +
-+      return 0;
- }
- /*
-@@ -115,26 +150,18 @@
-  *
-  * In UP mode, it is invoked from the (global) timer_interrupt.
-  */
--static void local_timer_interrupt(int irq, void *dev_id)
-+void local_timer_interrupt(int irq, void *dev_id)
- {
-       if (current->pid)
-               profile_tick(CPU_PROFILING);
-       update_process_times(user_mode(get_irq_regs()));
- }
+ /* --------------------------------------------------------------------
+  * HMATRIX
+  * -------------------------------------------------------------------- */
+@@ -583,12 +665,14 @@
  
--static irqreturn_t
--timer_interrupt(int irq, void *dev_id)
-+irqreturn_t __weak timer_interrupt(int irq, void *dev_id)
+ void __init at32_add_system_devices(void)
  {
--      unsigned int count;
+-      system_manager.eim_first_irq = EIM_IRQ_BASE;
 -
-       /* ack timer interrupt and try to set next interrupt */
--      count = avr32_hpt_read();
-       avr32_timer_ack();
+-      platform_device_register(&at32_sm_device);
++      platform_device_register(&at32_pm0_device);
+       platform_device_register(&at32_intc0_device);
++      platform_device_register(&at32ap700x_rtc0_device);
++      platform_device_register(&at32_wdt0_device);
++      platform_device_register(&at32_eic0_device);
+       platform_device_register(&smc0_device);
+       platform_device_register(&pdc_device);
++      platform_device_register(&dmaca0_device);
  
--      /* Update timerhi/timerlo for intra-jiffy calibration */
--      timerhi += count < timerlo;     /* Wrap around */
--      timerlo = count;
--
-       /*
-        * Call the generic timer interrupt handler
-        */
-@@ -153,60 +180,37 @@
-       return IRQ_HANDLED;
- }
+       platform_device_register(&at32_systc0_device);
  
--static struct irqaction timer_irqaction = {
--      .handler        = timer_interrupt,
--      .flags          = IRQF_DISABLED,
--      .name           = "timer",
--};
--
- void __init time_init(void)
- {
--      unsigned long mult, shift, count_hz;
-       int ret;
+@@ -894,6 +978,83 @@
+ }
  
-+      /*
-+       * Make sure we don't get any COMPARE interrupts before we can
-+       * handle them.
-+       */
-+      sysreg_write(COMPARE, 0);
-+
-       xtime.tv_sec = rtc_get_time();
-       xtime.tv_nsec = 0;
-       set_normalized_timespec(&wall_to_monotonic,
-                               -xtime.tv_sec, -xtime.tv_nsec);
--      printk("Before time_init: count=%08lx, compare=%08lx\n",
--             (unsigned long)sysreg_read(COUNT),
--             (unsigned long)sysreg_read(COMPARE));
--
--      count_hz = clk_get_rate(boot_cpu_data.clk);
--      shift = clocksource_avr32.shift;
--      mult = clocksource_hz2mult(count_hz, shift);
--      clocksource_avr32.mult = mult;
--
--      printk("Cycle counter: mult=%lu, shift=%lu\n", mult, shift);
--
--      {
--              u64 tmp;
--
--              tmp = TICK_NSEC;
--              tmp <<= shift;
--              tmp += mult / 2;
--              do_div(tmp, mult);
--
--              cycles_per_jiffy = tmp;
-+      ret = avr32_hpt_init();
-+      if (ret) {
-+              pr_debug("timer: failed setup: %d\n", ret);
-+              return;
-       }
--      /* This sets up the high precision timer for the first interrupt. */
--      avr32_hpt_init(avr32_hpt_read());
--
--      printk("After time_init: count=%08lx, compare=%08lx\n",
--             (unsigned long)sysreg_read(COUNT),
--             (unsigned long)sysreg_read(COMPARE));
--
-       ret = clocksource_register(&clocksource_avr32);
-       if (ret)
--              printk(KERN_ERR
--                     "timer: could not register clocksource: %d\n", ret);
-+              pr_debug("timer: could not register clocksource: %d\n", ret);
--      ret = setup_irq(0, &timer_irqaction);
--      if (ret)
--              printk("timer: could not request IRQ 0: %d\n", ret);
-+      ret = avr32_hpt_start();
-+      if (ret) {
-+              pr_debug("timer: failed starting: %d\n", ret);
-+              return;
-+      }
- }
- static struct sysdev_class timer_class = {
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/traps.c avr32-git/arch/avr32/kernel/traps.c
---- linux-2.6.21.3/arch/avr32/kernel/traps.c   2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/traps.c        2007-06-06 11:33:46.000000000 +0200
-@@ -5,158 +5,25 @@
-  * it under the terms of the GNU General Public License version 2 as
-  * published by the Free Software Foundation.
-  */
--#undef DEBUG
--#include <linux/sched.h>
-+
-+#include <linux/bug.h>
- #include <linux/init.h>
--#include <linux/module.h>
- #include <linux/kallsyms.h>
-+#include <linux/module.h>
- #include <linux/notifier.h>
-+#include <linux/sched.h>
-+#include <linux/uaccess.h>
--#include <asm/traps.h>
--#include <asm/sysreg.h>
- #include <asm/addrspace.h>
--#include <asm/ocd.h>
- #include <asm/mmu_context.h>
--#include <asm/uaccess.h>
--
--static void dump_mem(const char *str, unsigned long bottom, unsigned long top)
--{
--      unsigned long p;
--      int i;
--
--      printk("%s(0x%08lx to 0x%08lx)\n", str, bottom, top);
--
--      for (p = bottom & ~31; p < top; ) {
--              printk("%04lx: ", p & 0xffff);
--
--              for (i = 0; i < 8; i++, p += 4) {
--                      unsigned int val;
--
--                      if (p < bottom || p >= top)
--                              printk("         ");
--                      else {
--                              if (__get_user(val, (unsigned int __user *)p)) {
--                                      printk("\n");
--                                      goto out;
--                              }
--                              printk("%08x ", val);
--                      }
--              }
--              printk("\n");
--      }
--
--out:
--      return;
--}
--
--static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p)
--{
--      return (p > (unsigned long)tinfo)
--              && (p < (unsigned long)tinfo + THREAD_SIZE - 3);
--}
--
--#ifdef CONFIG_FRAME_POINTER
--static inline void __show_trace(struct task_struct *tsk, unsigned long *sp,
--                              struct pt_regs *regs)
--{
--      unsigned long lr, fp;
--      struct thread_info *tinfo;
--
--      tinfo = (struct thread_info *)
--              ((unsigned long)sp & ~(THREAD_SIZE - 1));
--
--      if (regs)
--              fp = regs->r7;
--      else if (tsk == current)
--              asm("mov %0, r7" : "=r"(fp));
--      else
--              fp = tsk->thread.cpu_context.r7;
--
--      /*
--       * Walk the stack as long as the frame pointer (a) is within
--       * the kernel stack of the task, and (b) it doesn't move
--       * downwards.
--       */
--      while (valid_stack_ptr(tinfo, fp)) {
--              unsigned long new_fp;
--
--              lr = *(unsigned long *)fp;
--              printk(" [<%08lx>] ", lr);
--              print_symbol("%s\n", lr);
--
--              new_fp = *(unsigned long *)(fp + 4);
--              if (new_fp <= fp)
--                      break;
--              fp = new_fp;
--      }
--      printk("\n");
--}
--#else
--static inline void __show_trace(struct task_struct *tsk, unsigned long *sp,
--                              struct pt_regs *regs)
--{
--      unsigned long addr;
--
--      while (!kstack_end(sp)) {
--              addr = *sp++;
--              if (kernel_text_address(addr)) {
--                      printk(" [<%08lx>] ", addr);
--                      print_symbol("%s\n", addr);
--              }
--      }
--}
--#endif
--
--void show_trace(struct task_struct *tsk, unsigned long *sp,
--                     struct pt_regs *regs)
--{
--      if (regs &&
--          (((regs->sr & MODE_MASK) == MODE_EXCEPTION) ||
--           ((regs->sr & MODE_MASK) == MODE_USER)))
--              return;
--
--      printk ("Call trace:");
--#ifdef CONFIG_KALLSYMS
--      printk("\n");
--#endif
--
--      __show_trace(tsk, sp, regs);
--      printk("\n");
--}
--
--void show_stack(struct task_struct *tsk, unsigned long *sp)
--{
--      unsigned long stack;
--
--      if (!tsk)
--              tsk = current;
--      if (sp == 0) {
--              if (tsk == current) {
--                      register unsigned long *real_sp __asm__("sp");
--                      sp = real_sp;
--              } else {
--                      sp = (unsigned long *)tsk->thread.cpu_context.ksp;
--              }
--      }
--
--      stack = (unsigned long)sp;
--      dump_mem("Stack: ", stack,
--               THREAD_SIZE + (unsigned long)tsk->thread_info);
--      show_trace(tsk, sp, NULL);
--}
--
--void dump_stack(void)
--{
--      show_stack(NULL, NULL);
--}
--EXPORT_SYMBOL(dump_stack);
-+#include <asm/ocd.h>
-+#include <asm/sysreg.h>
-+#include <asm/traps.h>
- ATOMIC_NOTIFIER_HEAD(avr32_die_chain);
- int register_die_notifier(struct notifier_block *nb)
- {
--      pr_debug("register_die_notifier: %p\n", nb);
--
-       return atomic_notifier_chain_register(&avr32_die_chain, nb);
- }
- EXPORT_SYMBOL(register_die_notifier);
-@@ -169,98 +36,108 @@
- static DEFINE_SPINLOCK(die_lock);
--void __die(const char *str, struct pt_regs *regs, unsigned long err,
--         const char *file, const char *func, unsigned long line)
-+void NORET_TYPE die(const char *str, struct pt_regs *regs, long err)
- {
--      struct task_struct *tsk = current;
-       static int die_counter;
-       console_verbose();
-       spin_lock_irq(&die_lock);
-       bust_spinlocks(1);
--      printk(KERN_ALERT "%s", str);
--      if (file && func)
--              printk(" in %s:%s, line %ld", file, func, line);
--      printk("[#%d]:\n", ++die_counter);
--      print_modules();
--      show_regs(regs);
--      printk("Process %s (pid: %d, stack limit = 0x%p)\n",
--             tsk->comm, tsk->pid, tsk->thread_info + 1);
--
--      if (!user_mode(regs) || in_interrupt()) {
--              dump_mem("Stack: ", regs->sp,
--                       THREAD_SIZE + (unsigned long)tsk->thread_info);
-+      printk(KERN_ALERT "Oops: %s, sig: %ld [#%d]\n" KERN_EMERG,
-+             str, err, ++die_counter);
-+#ifdef CONFIG_PREEMPT
-+      printk("PREEMPT ");
-+#endif
-+#ifdef CONFIG_FRAME_POINTER
-+      printk("FRAME_POINTER ");
-+#endif
-+      if (current_cpu_data.features & AVR32_FEATURE_OCD) {
-+              unsigned long did = __mfdr(DBGREG_DID);
-+              printk("chip: 0x%03lx:0x%04lx rev %lu\n",
-+                     (did >> 1) & 0x7ff,
-+                     (did >> 12) & 0x7fff,
-+                     (did >> 28) & 0xf);
-+      } else {
-+              printk("cpu: arch %u r%u / core %u r%u\n",
-+                     current_cpu_data.arch_type,
-+                     current_cpu_data.arch_revision,
-+                     current_cpu_data.cpu_type,
-+                     current_cpu_data.cpu_revision);
-       }
-+      print_modules();
-+      show_regs_log_lvl(regs, KERN_EMERG);
-+      show_stack_log_lvl(current, regs->sp, regs, KERN_EMERG);
-       bust_spinlocks(0);
-       spin_unlock_irq(&die_lock);
--      do_exit(SIGSEGV);
-+
-+      if (in_interrupt())
-+              panic("Fatal exception in interrupt");
-+
-+      if (panic_on_oops)
-+              panic("Fatal exception");
-+
-+      do_exit(err);
- }
--void __die_if_kernel(const char *str, struct pt_regs *regs, unsigned long err,
--                   const char *file, const char *func, unsigned long line)
-+void _exception(long signr, struct pt_regs *regs, int code,
-+              unsigned long addr)
- {
-+      siginfo_t info;
-+
-       if (!user_mode(regs))
--              __die(str, regs, err, file, func, line);
--}
-+              die("Unhandled exception in kernel mode", regs, signr);
-+
-+      memset(&info, 0, sizeof(info));
-+      info.si_signo = signr;
-+      info.si_code = code;
-+      info.si_addr = (void __user *)addr;
-+      force_sig_info(signr, &info, current);
--asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs)
--{
--#ifdef CONFIG_SUBARCH_AVR32B
-       /*
--       * The exception entry always saves RSR_EX. For NMI, this is
--       * wrong; it should be RSR_NMI
-+       * Init gets no signals that it doesn't have a handler for.
-+       * That's all very well, but if it has caused a synchronous
-+       * exception and we ignore the resulting signal, it will just
-+       * generate the same exception over and over again and we get
-+       * nowhere.  Better to kill it and let the kernel panic.
-        */
--      regs->sr = sysreg_read(RSR_NMI);
--#endif
-+      if (is_init(current)) {
-+              __sighandler_t handler;
--      printk("NMI taken!!!!\n");
--      die("NMI", regs, ecr);
--      BUG();
-+              spin_lock_irq(&current->sighand->siglock);
-+              handler = current->sighand->action[signr-1].sa.sa_handler;
-+              spin_unlock_irq(&current->sighand->siglock);
-+              if (handler == SIG_DFL) {
-+                      /* init has generated a synchronous exception
-+                         and it doesn't have a handler for the signal */
-+                      printk(KERN_CRIT "init has generated signal %ld "
-+                             "but has no handler for it\n", signr);
-+                      do_exit(signr);
-+              }
-+      }
-+}
-+
-+asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs)
-+{
-+      printk(KERN_ALERT "Got Non-Maskable Interrupt, dumping regs\n");
-+      show_regs_log_lvl(regs, KERN_ALERT);
-+      show_stack_log_lvl(current, regs->sp, regs, KERN_ALERT);
- }
- asmlinkage void do_critical_exception(unsigned long ecr, struct pt_regs *regs)
- {
--      printk("Unable to handle critical exception %lu at pc = %08lx!\n",
--             ecr, regs->pc);
--      die("Oops", regs, ecr);
--      BUG();
-+      die("Critical exception", regs, SIGKILL);
- }
- asmlinkage void do_address_exception(unsigned long ecr, struct pt_regs *regs)
- {
--      siginfo_t info;
--
--      die_if_kernel("Oops: Address exception in kernel mode", regs, ecr);
--
--#ifdef DEBUG
--      if (ecr == ECR_ADDR_ALIGN_X)
--              pr_debug("Instruction Address Exception at pc = %08lx\n",
--                       regs->pc);
--      else if (ecr == ECR_ADDR_ALIGN_R)
--              pr_debug("Data Address Exception (Read) at pc = %08lx\n",
--                       regs->pc);
--      else if (ecr == ECR_ADDR_ALIGN_W)
--              pr_debug("Data Address Exception (Write) at pc = %08lx\n",
--                       regs->pc);
--      else
--              BUG();
--
--      show_regs(regs);
--#endif
--
--      info.si_signo = SIGBUS;
--      info.si_errno = 0;
--      info.si_code = BUS_ADRALN;
--      info.si_addr = (void __user *)regs->pc;
--
--      force_sig_info(SIGBUS, &info, current);
-+      _exception(SIGBUS, regs, BUS_ADRALN, regs->pc);
- }
- /* This way of handling undefined instructions is stolen from ARM */
- static LIST_HEAD(undef_hook);
--static spinlock_t undef_lock = SPIN_LOCK_UNLOCKED;
-+static DEFINE_SPINLOCK(undef_lock);
- void register_undef_hook(struct undef_hook *hook)
- {
-@@ -280,7 +157,8 @@
- {
-       int cop_nr;
-       u32 cpucr;
--      if ( (insn & 0xfdf00000) == 0xf1900000 )
-+
-+      if ((insn & 0xfdf00000) == 0xf1900000)
-               /* LDC0 */
-               cop_nr = 0;
-       else
-@@ -292,136 +170,91 @@
-       sysreg_write(CPUCR, cpucr);
-       cpucr = sysreg_read(CPUCR);
--      if ( !(cpucr & (1 << (24 + cop_nr))) ){
--              printk("Coprocessor #%i not found!\n", cop_nr);
--              return -1;
--      }
-+      if (!(cpucr & (1 << (24 + cop_nr))))
-+              return -ENODEV;
-       return 0;
- }
--#ifdef CONFIG_BUG
--#ifdef CONFIG_DEBUG_BUGVERBOSE
--static inline void do_bug_verbose(struct pt_regs *regs, u32 insn)
--{
--      char *file;
--      u16 line;
--      char c;
--
--      if (__get_user(line, (u16 __user *)(regs->pc + 2)))
--              return;
--      if (__get_user(file, (char * __user *)(regs->pc + 4))
--          || (unsigned long)file < PAGE_OFFSET
--          || __get_user(c, file))
--              file = "<bad filename>";
--
--      printk(KERN_ALERT "kernel BUG at %s:%d!\n", file, line);
--}
--#else
--static inline void do_bug_verbose(struct pt_regs *regs, u32 insn)
-+int is_valid_bugaddr(unsigned long pc)
- {
-+      unsigned short opcode;
-+
-+      if (pc < PAGE_OFFSET)
-+              return 0;
-+      if (probe_kernel_address((u16 *)pc, opcode))
-+              return 0;
-+      return opcode == AVR32_BUG_OPCODE;
- }
--#endif
--#endif
- asmlinkage void do_illegal_opcode(unsigned long ecr, struct pt_regs *regs)
- {
-       u32 insn;
-       struct undef_hook *hook;
--      siginfo_t info;
-       void __user *pc;
-+      long code;
--      if (!user_mode(regs))
--              goto kernel_trap;
-+      if (!user_mode(regs) && (ecr == ECR_ILLEGAL_OPCODE)) {
-+              enum bug_trap_type type;
-+
-+              type = report_bug(regs->pc);
-+              switch (type) {
-+              case BUG_TRAP_TYPE_NONE:
-+                      break;
-+              case BUG_TRAP_TYPE_WARN:
-+                      regs->pc += 2;
-+                      return;
-+              case BUG_TRAP_TYPE_BUG:
-+                      die("Kernel BUG", regs, SIGKILL);
-+              }
-+      }
-       local_irq_enable();
--      pc = (void __user *)instruction_pointer(regs);
--      if (__get_user(insn, (u32 __user *)pc))
--              goto invalid_area;
-+      if (user_mode(regs)) {
-+              pc = (void __user *)instruction_pointer(regs);
-+              if (get_user(insn, (u32 __user *)pc))
-+                      goto invalid_area;
--        if (ecr == ECR_COPROC_ABSENT) {
--              if (do_cop_absent(insn) == 0)
-+              if (ecr == ECR_COPROC_ABSENT && !do_cop_absent(insn))
-                       return;
--        }
--      spin_lock_irq(&undef_lock);
--      list_for_each_entry(hook, &undef_hook, node) {
--              if ((insn & hook->insn_mask) == hook->insn_val) {
--                      if (hook->fn(regs, insn) == 0) {
--                              spin_unlock_irq(&undef_lock);
--                              return;
-+              spin_lock_irq(&undef_lock);
-+              list_for_each_entry(hook, &undef_hook, node) {
-+                      if ((insn & hook->insn_mask) == hook->insn_val) {
-+                              if (hook->fn(regs, insn) == 0) {
-+                                      spin_unlock_irq(&undef_lock);
-+                                      return;
-+                              }
-                       }
-               }
-+              spin_unlock_irq(&undef_lock);
-       }
--      spin_unlock_irq(&undef_lock);
--
--invalid_area:
--#ifdef DEBUG
--      printk("Illegal instruction at pc = %08lx\n", regs->pc);
--      if (regs->pc < TASK_SIZE) {
--              unsigned long ptbr, pgd, pte, *p;
--
--              ptbr = sysreg_read(PTBR);
--              p = (unsigned long *)ptbr;
--              pgd = p[regs->pc >> 22];
--              p = (unsigned long *)((pgd & 0x1ffff000) | 0x80000000);
--              pte = p[(regs->pc >> 12) & 0x3ff];
--              printk("page table: 0x%08lx -> 0x%08lx -> 0x%08lx\n", ptbr, pgd, pte);
--      }
--#endif
--
--      info.si_signo = SIGILL;
--      info.si_errno = 0;
--      info.si_addr = (void __user *)regs->pc;
-       switch (ecr) {
--      case ECR_ILLEGAL_OPCODE:
--      case ECR_UNIMPL_INSTRUCTION:
--              info.si_code = ILL_ILLOPC;
--              break;
-       case ECR_PRIVILEGE_VIOLATION:
--              info.si_code = ILL_PRVOPC;
-+              code = ILL_PRVOPC;
-               break;
-       case ECR_COPROC_ABSENT:
--              info.si_code = ILL_COPROC;
-+              code = ILL_COPROC;
-               break;
-       default:
--              BUG();
-+              code = ILL_ILLOPC;
-+              break;
-       }
--      force_sig_info(SIGILL, &info, current);
-+      _exception(SIGILL, regs, code, regs->pc);
-       return;
--kernel_trap:
--#ifdef CONFIG_BUG
--      if (__kernel_text_address(instruction_pointer(regs))) {
--              insn = *(u16 *)instruction_pointer(regs);
--              if (insn == AVR32_BUG_OPCODE) {
--                      do_bug_verbose(regs, insn);
--                      die("Kernel BUG", regs, 0);
--                      return;
--              }
--      }
--#endif
--
--      die("Oops: Illegal instruction in kernel code", regs, ecr);
-+invalid_area:
-+      _exception(SIGSEGV, regs, SEGV_MAPERR, regs->pc);
- }
- asmlinkage void do_fpe(unsigned long ecr, struct pt_regs *regs)
- {
--      siginfo_t info;
--
--      printk("Floating-point exception at pc = %08lx\n", regs->pc);
--
--      /* We have no FPU... */
--      info.si_signo = SIGILL;
--      info.si_errno = 0;
--      info.si_addr = (void __user *)regs->pc;
--      info.si_code = ILL_COPROC;
--
--      force_sig_info(SIGILL, &info, current);
-+      /* We have no FPU yet */
-+      _exception(SIGILL, regs, ILL_COPROC, regs->pc);
- }
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/vmlinux.lds.c avr32-git/arch/avr32/kernel/vmlinux.lds.c
---- linux-2.6.21.3/arch/avr32/kernel/vmlinux.lds.c     2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/kernel/vmlinux.lds.c  2007-06-06 11:33:46.000000000 +0200
-@@ -26,10 +26,16 @@
-                       _sinittext = .;
-                       *(.text.reset)
-                       *(.init.text)
-+                      /*
-+                       * .exit.text is discarded at runtime, not
-+                       * link time, to deal with references from
-+                       * __bug_table
-+                       */
-+                      *(.exit.text)
-                       _einittext = .;
-               . = ALIGN(4);
-               __tagtable_begin = .;
--                      *(.taglist)
-+                      *(.taglist.init)
-               __tagtable_end = .;
-                       *(.init.data)
-               . = ALIGN(16);
-@@ -86,6 +92,8 @@
-               __stop___ex_table = .;
-       }
-+      BUG_TABLE
-+
-       RODATA
-       . = ALIGN(8192);
-@@ -126,7 +134,6 @@
-        * thrown away, as cleanup code is never called unless it's a module.
-        */
-       /DISCARD/               : {
--              *(.exit.text)
-               *(.exit.data)
-               *(.exitcall.exit)
-       }
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000.c avr32-git/arch/avr32/mach-at32ap/at32ap7000.c
---- linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000.c 2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mach-at32ap/at32ap7000.c      2007-06-06 11:33:46.000000000 +0200
-@@ -6,6 +6,7 @@
-  * published by the Free Software Foundation.
-  */
- #include <linux/clk.h>
-+#include <linux/fb.h>
- #include <linux/init.h>
- #include <linux/platform_device.h>
- #include <linux/spi/spi.h>
-@@ -17,7 +18,10 @@
- #include <asm/arch/portmux.h>
- #include <asm/arch/sm.h>
-+#include <video/atmel_lcdc.h>
-+
- #include "clock.h"
-+#include "hmatrix.h"
- #include "pio.h"
- #include "sm.h"
-@@ -416,7 +420,15 @@
-       .resource       = sm_resource,
-       .num_resources  = ARRAY_SIZE(sm_resource),
- };
--DEV_CLK(pclk, at32_sm, pbb, 0);
-+static struct clk at32_sm_pclk = {
-+      .name           = "pclk",
-+      .dev            = &at32_sm_device.dev,
-+      .parent         = &pbb_clk,
-+      .mode           = pbb_clk_mode,
-+      .get_rate       = pbb_clk_get_rate,
-+      .users          = 1,
-+      .index          = 0,
-+};
- static struct resource intc0_resource[] = {
-       PBMEM(0xfff00400),
-@@ -442,6 +454,7 @@
-       .mode           = hsb_clk_mode,
-       .get_rate       = hsb_clk_get_rate,
-       .users          = 1,
-+      .index          = 3,
- };
- static struct resource smc0_resource[] = {
-@@ -466,6 +479,68 @@
-       .users          = 1,
- };
-+static struct resource dmaca0_resource[] = {
-+      {
-+              .start  = 0xff200000,
-+              .end    = 0xff20ffff,
-+              .flags  = IORESOURCE_MEM,
-+      },
-+      IRQ(2),
-+};
-+DEFINE_DEV(dmaca, 0);
-+DEV_CLK(hclk, dmaca0, hsb, 10);
-+
-+/* --------------------------------------------------------------------
-+ * HMATRIX
-+ * -------------------------------------------------------------------- */
-+
-+static struct clk hmatrix_clk = {
-+      .name           = "hmatrix_clk",
-+      .parent         = &pbb_clk,
-+      .mode           = pbb_clk_mode,
-+      .get_rate       = pbb_clk_get_rate,
-+      .index          = 2,
-+      .users          = 1,
-+};
-+#define HMATRIX_BASE  ((void __iomem *)0xfff00800)
-+
-+#define hmatrix_readl(reg)                                    \
-+      __raw_readl((HMATRIX_BASE) + HMATRIX_##reg)
-+#define hmatrix_writel(reg,value)                             \
-+      __raw_writel((value), (HMATRIX_BASE) + HMATRIX_##reg)
-+
-+/*
-+ * Set bits in the HMATRIX Special Function Register (SFR) used by the
-+ * External Bus Interface (EBI). This can be used to enable special
-+ * features like CompactFlash support, NAND Flash support, etc. on
-+ * certain chipselects.
-+ */
-+static inline void set_ebi_sfr_bits(u32 mask)
-+{
-+      u32 sfr;
-+
-+      clk_enable(&hmatrix_clk);
-+      sfr = hmatrix_readl(SFR4);
-+      sfr |= mask;
-+      hmatrix_writel(SFR4, sfr);
-+      clk_disable(&hmatrix_clk);
-+}
-+
-+/* --------------------------------------------------------------------
-+ *  System Timer/Counter (TC)
-+ * -------------------------------------------------------------------- */
-+static struct resource at32_systc0_resource[] = {
-+      PBMEM(0xfff00c00),
-+      IRQ(22),
-+};
-+struct platform_device at32_systc0_device = {
-+      .name           = "systc",
-+      .id             = 0,
-+      .resource       = at32_systc0_resource,
-+      .num_resources  = ARRAY_SIZE(at32_systc0_resource),
-+};
-+DEV_CLK(pclk, at32_systc0, pbb, 3);
-+
- /* --------------------------------------------------------------------
-  *  PIO
-  * -------------------------------------------------------------------- */
-@@ -513,6 +588,9 @@
-       platform_device_register(&at32_intc0_device);
-       platform_device_register(&smc0_device);
-       platform_device_register(&pdc_device);
-+      platform_device_register(&dmaca0_device);
-+
-+      platform_device_register(&at32_systc0_device);
-       platform_device_register(&pio0_device);
-       platform_device_register(&pio1_device);
-@@ -816,22 +894,105 @@
- }
- /* --------------------------------------------------------------------
-+ *  TWI
-+ * -------------------------------------------------------------------- */
+ /* --------------------------------------------------------------------
++ *  TWI
++ * -------------------------------------------------------------------- */
 +
 +static struct resource atmel_twi0_resource[] = {
 +      PBMEM(0xffe00800),
@@ -3595,132 +1812,153 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000
 +/* --------------------------------------------------------------------
   *  LCDC
   * -------------------------------------------------------------------- */
--static struct lcdc_platform_data lcdc0_data;
--static struct resource lcdc0_resource[] = {
-+static struct atmel_lcdfb_info atmel_lcdfb0_data;
-+static struct resource atmel_lcdfb0_resource[] = {
-       {
-               .start          = 0xff000000,
-               .end            = 0xff000fff,
-               .flags          = IORESOURCE_MEM,
-       },
-       IRQ(1),
-+      {
-+              /* Placeholder for pre-allocated fb memory */
-+              .start          = 0x00000000,
-+              .end            = 0x00000000,
-+              .flags          = 0,
-+      },
- };
--DEFINE_DEV_DATA(lcdc, 0);
--DEV_CLK(hclk, lcdc0, hsb, 7);
--static struct clk lcdc0_pixclk = {
--      .name           = "pixclk",
--      .dev            = &lcdc0_device.dev,
-+DEFINE_DEV_DATA(atmel_lcdfb, 0);
-+DEV_CLK(hck1, atmel_lcdfb0, hsb, 7);
-+static struct clk atmel_lcdfb0_pixclk = {
-+      .name           = "lcdc_clk",
-+      .dev            = &atmel_lcdfb0_device.dev,
-       .mode           = genclk_mode,
-       .get_rate       = genclk_get_rate,
-       .set_rate       = genclk_set_rate,
-@@ -840,13 +1001,34 @@
- };
+ static struct atmel_lcdfb_info atmel_lcdfb0_data;
+@@ -1013,6 +1174,228 @@
+ }
  
- struct platform_device *__init
--at32_add_device_lcdc(unsigned int id, struct lcdc_platform_data *data)
-+at32_add_device_lcdc(unsigned int id, struct atmel_lcdfb_info *data,
-+                   unsigned long fbmem_start, unsigned long fbmem_len)
- {
-       struct platform_device *pdev;
-+      struct atmel_lcdfb_info *info;
-+      struct fb_monspecs *monspecs;
-+      struct fb_videomode *modedb;
-+      unsigned int modedb_size;
-+
-+      /*
-+       * Do a deep copy of the fb data, monspecs and modedb. Make
-+       * sure all allocations are done before setting up the
-+       * portmux.
-+       */
-+      monspecs = kmemdup(data->default_monspecs,
-+                         sizeof(struct fb_monspecs), GFP_KERNEL);
-+      if (!monspecs)
+ /* --------------------------------------------------------------------
++ *  USB Device Controller
++ * -------------------------------------------------------------------- */
++static struct resource usba0_resource[] __initdata = {
++      {
++              .name           = "fifo",
++              .start          = 0xff300000,
++              .end            = 0xff3fffff,
++              .flags          = IORESOURCE_MEM,
++      }, {
++              .name           = "regs",
++              .start          = 0xfff03000,
++              .end            = 0xfff033ff,
++              .flags          = IORESOURCE_MEM,
++      },
++      IRQ(31),
++};
++static struct clk usba0_pclk = {
++      .name           = "pclk",
++      .parent         = &pbb_clk,
++      .mode           = pbb_clk_mode,
++      .get_rate       = pbb_clk_get_rate,
++      .index          = 12,
++};
++static struct clk usba0_hclk = {
++      .name           = "hclk",
++      .parent         = &hsb_clk,
++      .mode           = hsb_clk_mode,
++      .get_rate       = hsb_clk_get_rate,
++      .index          = 6,
++};
++
++struct platform_device *__init
++at32_add_device_usba(unsigned int id, struct usba_platform_data *data)
++{
++      struct platform_device *pdev;
++
++      if (id != 0)
 +              return NULL;
 +
-+      modedb_size = sizeof(struct fb_videomode) * monspecs->modedb_len;
-+      modedb = kmemdup(monspecs->modedb, modedb_size, GFP_KERNEL);
-+      if (!modedb)
-+              goto err_dup_modedb;
-+      monspecs->modedb = modedb;
-       switch (id) {
-       case 0:
--              pdev = &lcdc0_device;
-+              pdev = &atmel_lcdfb0_device;
-               select_peripheral(PC(19), PERIPH_A, 0); /* CC     */
-               select_peripheral(PC(20), PERIPH_A, 0); /* HSYNC  */
-               select_peripheral(PC(21), PERIPH_A, 0); /* PCLK   */
-@@ -879,16 +1061,133 @@
-               select_peripheral(PD(16), PERIPH_A, 0); /* DATA22 */
-               select_peripheral(PD(17), PERIPH_A, 0); /* DATA23 */
--              clk_set_parent(&lcdc0_pixclk, &pll0);
--              clk_set_rate(&lcdc0_pixclk, clk_get_rate(&pll0));
-+              clk_set_parent(&atmel_lcdfb0_pixclk, &pll0);
-+              clk_set_rate(&atmel_lcdfb0_pixclk, clk_get_rate(&pll0));
-+              break;
++      pdev = platform_device_alloc("atmel_usba_udc", 0);
++      if (!pdev)
++              return NULL;
 +
-+      default:
-+              goto err_invalid_id;
-+      }
++      if (platform_device_add_resources(pdev, usba0_resource,
++                                        ARRAY_SIZE(usba0_resource)))
++              goto out_free_pdev;
++
++      if (data) {
++              if (platform_device_add_data(pdev, data, sizeof(*data)))
++                      goto out_free_pdev;
 +
-+      if (fbmem_len) {
-+              pdev->resource[2].start = fbmem_start;
-+              pdev->resource[2].end = fbmem_start + fbmem_len - 1;
-+              pdev->resource[2].flags = IORESOURCE_MEM;
++              if (data->vbus_pin != GPIO_PIN_NONE)
++                      at32_select_gpio(data->vbus_pin, 0);
 +      }
 +
-+      info = pdev->dev.platform_data;
-+      memcpy(info, data, sizeof(struct atmel_lcdfb_info));
-+      info->default_monspecs = monspecs;
++      usba0_pclk.dev = &pdev->dev;
++      usba0_hclk.dev = &pdev->dev;
++
++      platform_device_add(pdev);
 +
-+      platform_device_register(pdev);
 +      return pdev;
 +
-+err_invalid_id:
-+      kfree(modedb);
-+err_dup_modedb:
-+      kfree(monspecs);
++out_free_pdev:
++      platform_device_put(pdev);
 +      return NULL;
 +}
 +
 +/* --------------------------------------------------------------------
-+ *  USB Device Controller
++ *  SSC
 + * -------------------------------------------------------------------- */
-+static struct resource usba0_resource[] = {
-+      {
-+              .start          = 0xff300000,
-+              .end            = 0xff3fffff,
-+              .flags          = IORESOURCE_MEM,
-+      },
-+      PBMEM(0xfff03000),
-+      IRQ(31),
++static struct resource ssc0_resource[] = {
++      PBMEM(0xffe01c00),
++      IRQ(10),
++};
++DEFINE_DEV(ssc, 0);
++DEV_CLK(pclk, ssc0, pba, 7);
++
++static struct resource ssc1_resource[] = {
++      PBMEM(0xffe02000),
++      IRQ(11),
 +};
-+DEFINE_DEV(usba, 0);
-+DEV_CLK(pclk, usba0, pbb, 12);
-+DEV_CLK(hclk, usba0, hsb, 6);
++DEFINE_DEV(ssc, 1);
++DEV_CLK(pclk, ssc1, pba, 8);
 +
-+struct platform_device *__init at32_add_device_usba(unsigned int id)
++static struct resource ssc2_resource[] = {
++      PBMEM(0xffe02400),
++      IRQ(12),
++};
++DEFINE_DEV(ssc, 2);
++DEV_CLK(pclk, ssc2, pba, 9);
++
++struct platform_device *__init
++at32_add_device_ssc(unsigned int id, unsigned int flags)
 +{
 +      struct platform_device *pdev;
 +
 +      switch (id) {
 +      case 0:
-+              pdev = &usba0_device;
-+              /* USB pads are not multiplexed */
-               break;
++              pdev = &ssc0_device;
++              if (flags & ATMEL_SSC_RF)
++                      select_peripheral(PA(21), PERIPH_A, 0); /* RF */
++              if (flags & ATMEL_SSC_RK)
++                      select_peripheral(PA(22), PERIPH_A, 0); /* RK */
++              if (flags & ATMEL_SSC_TK)
++                      select_peripheral(PA(23), PERIPH_A, 0); /* TK */
++              if (flags & ATMEL_SSC_TF)
++                      select_peripheral(PA(24), PERIPH_A, 0); /* TF */
++              if (flags & ATMEL_SSC_TD)
++                      select_peripheral(PA(25), PERIPH_A, 0); /* TD */
++              if (flags & ATMEL_SSC_RD)
++                      select_peripheral(PA(26), PERIPH_A, 0); /* RD */
++              break;
++      case 1:
++              pdev = &ssc1_device;
++              if (flags & ATMEL_SSC_RF)
++                      select_peripheral(PA(0), PERIPH_B, 0);  /* RF */
++              if (flags & ATMEL_SSC_RK)
++                      select_peripheral(PA(1), PERIPH_B, 0);  /* RK */
++              if (flags & ATMEL_SSC_TK)
++                      select_peripheral(PA(2), PERIPH_B, 0);  /* TK */
++              if (flags & ATMEL_SSC_TF)
++                      select_peripheral(PA(3), PERIPH_B, 0);  /* TF */
++              if (flags & ATMEL_SSC_TD)
++                      select_peripheral(PA(4), PERIPH_B, 0);  /* TD */
++              if (flags & ATMEL_SSC_RD)
++                      select_peripheral(PA(5), PERIPH_B, 0);  /* RD */
++              break;
++      case 2:
++              pdev = &ssc2_device;
++              if (flags & ATMEL_SSC_TD)
++                      select_peripheral(PB(13), PERIPH_A, 0); /* TD */
++              if (flags & ATMEL_SSC_RD)
++                      select_peripheral(PB(14), PERIPH_A, 0); /* RD */
++              if (flags & ATMEL_SSC_TK)
++                      select_peripheral(PB(15), PERIPH_A, 0); /* TK */
++              if (flags & ATMEL_SSC_TF)
++                      select_peripheral(PB(16), PERIPH_A, 0); /* TF */
++              if (flags & ATMEL_SSC_RF)
++                      select_peripheral(PB(17), PERIPH_A, 0); /* RF */
++              if (flags & ATMEL_SSC_RK)
++                      select_peripheral(PB(18), PERIPH_A, 0); /* RK */
++              break;
 +      default:
 +              return NULL;
 +      }
@@ -3738,7 +1976,7 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000
 +};
 +DEFINE_DEV(atmel_ac97c, 0);
 +DEV_CLK(pclk, atmel_ac97c0, pbb, 10);
++
 +struct platform_device *__init
 +at32_add_device_ac97c(unsigned int id)
 +{
@@ -3752,12 +1990,10 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000
 +              select_peripheral(PB(22), PERIPH_B, 0); /* SDI  */
 +              select_peripheral(PB(23), PERIPH_B, 0); /* SCLK */
 +              break;
-       default:
-               return NULL;
-       }
--      memcpy(pdev->dev.platform_data, data,
--             sizeof(struct lcdc_platform_data));
++      default:
++              return NULL;
++      }
++
 +      platform_device_register(pdev);
 +      return pdev;
 +}
@@ -3797,17 +2033,25 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000
 +      default:
 +              return NULL;
 +      }
-       platform_device_register(pdev);
-       return pdev;
-@@ -950,18 +1249,21 @@
++
++      platform_device_register(pdev);
++      return pdev;
++}
++
++/* --------------------------------------------------------------------
+  *  GCLK
+  * -------------------------------------------------------------------- */
+ static struct clk gclk0 = {
+@@ -1066,7 +1449,7 @@
+       &hsb_clk,
+       &pba_clk,
        &pbb_clk,
-       &at32_sm_pclk,
+-      &at32_sm_pclk,
++      &at32_pm_pclk,
        &at32_intc0_pclk,
-+      &hmatrix_clk,
+       &hmatrix_clk,
        &ebi_clk,
-       &hramc_clk,
-       &smc0_pclk,
+@@ -1075,6 +1458,7 @@
        &smc0_mck,
        &pdc_hclk,
        &pdc_pclk,
@@ -3815,334 +2059,121 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000
        &pico_clk,
        &pio0_mck,
        &pio1_mck,
-       &pio2_mck,
-       &pio3_mck,
-       &pio4_mck,
-+      &at32_systc0_pclk,
-       &atmel_usart0_usart,
-       &atmel_usart1_usart,
-       &atmel_usart2_usart,
-@@ -972,8 +1274,15 @@
+@@ -1092,8 +1476,18 @@
        &macb1_pclk,
        &atmel_spi0_spi_clk,
        &atmel_spi1_spi_clk,
--      &lcdc0_hclk,
--      &lcdc0_pixclk,
 +      &atmel_twi0_pclk,
 +      &atmel_mci0_mci_clk,
-+      &atmel_lcdfb0_hck1,
-+      &atmel_lcdfb0_pixclk,
+       &atmel_lcdfb0_hck1,
+       &atmel_lcdfb0_pixclk,
 +      &usba0_pclk,
 +      &usba0_hclk,
++      &ssc0_pclk,
++      &ssc1_pclk,
++      &ssc2_pclk,
 +      &atmel_ac97c0_pclk,
 +      &abdac0_pclk,
 +      &abdac0_sample_clk,
        &gclk0,
        &gclk1,
        &gclk2,
-@@ -1012,7 +1321,8 @@
-       genclk_init_parent(&gclk2);
+@@ -1113,18 +1507,20 @@
+ void __init at32_clock_init(void)
+ {
+-      struct at32_sm *sm = &system_manager;
+       u32 cpu_mask = 0, hsb_mask = 0, pba_mask = 0, pbb_mask = 0;
+       int i;
+-      if (sm_readl(sm, PM_MCCTRL) & SM_BIT(PLLSEL))
++      if (pm_readl(MCCTRL) & PM_BIT(PLLSEL)) {
+               main_clock = &pll0;
+-      else
++              cpu_clk.parent = &pll0;
++      } else {
+               main_clock = &osc0;
++              cpu_clk.parent = &osc0;
++      }
+-      if (sm_readl(sm, PM_PLL0) & SM_BIT(PLLOSC))
++      if (pm_readl(PLL0) & PM_BIT(PLLOSC))
+               pll0.parent = &osc1;
+-      if (sm_readl(sm, PM_PLL1) & SM_BIT(PLLOSC))
++      if (pm_readl(PLL1) & PM_BIT(PLLOSC))
+               pll1.parent = &osc1;
+       genclk_init_parent(&gclk0);
+@@ -1133,6 +1529,7 @@
        genclk_init_parent(&gclk3);
        genclk_init_parent(&gclk4);
--      genclk_init_parent(&lcdc0_pixclk);
-+      genclk_init_parent(&atmel_lcdfb0_pixclk);
+       genclk_init_parent(&atmel_lcdfb0_pixclk);
 +      genclk_init_parent(&abdac0_sample_clk);
  
        /*
         * Turn on all clocks that have at least one user already, and
-@@ -1024,6 +1334,9 @@
-       for (i = 0; i < ARRAY_SIZE(at32_clock_list); i++) {
-               struct clk *clk = at32_clock_list[i];
-+              if (clk->users == 0)
-+                      continue;
-+
-               if (clk->mode == &cpu_clk_mode)
-                       cpu_mask |= 1 << clk->index;
-               else if (clk->mode == &hsb_clk_mode)
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/clock.c avr32-git/arch/avr32/mach-at32ap/clock.c
---- linux-2.6.21.3/arch/avr32/mach-at32ap/clock.c      2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mach-at32ap/clock.c   2007-06-06 11:33:46.000000000 +0200
-@@ -18,7 +18,7 @@
+@@ -1157,8 +1554,8 @@
+                       pbb_mask |= 1 << clk->index;
+       }
  
- #include "clock.h"
+-      sm_writel(sm, PM_CPU_MASK, cpu_mask);
+-      sm_writel(sm, PM_HSB_MASK, hsb_mask);
+-      sm_writel(sm, PM_PBA_MASK, pba_mask);
+-      sm_writel(sm, PM_PBB_MASK, pbb_mask);
++      pm_writel(CPU_MASK, cpu_mask);
++      pm_writel(HSB_MASK, hsb_mask);
++      pm_writel(PBA_MASK, pba_mask);
++      pm_writel(PBB_MASK, pbb_mask);
+ }
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap.c linux-avr32.git/arch/avr32/mach-at32ap/at32ap.c
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap.c     2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/at32ap.c    2007-07-12 13:59:49.000000000 +0200
+@@ -11,41 +11,10 @@
+ #include <linux/init.h>
+ #include <linux/platform_device.h>
  
--static spinlock_t clk_lock = SPIN_LOCK_UNLOCKED;
-+static DEFINE_SPINLOCK(clk_lock);
+-#include <asm/io.h>
+-
+ #include <asm/arch/init.h>
+-#include <asm/arch/sm.h>
+-
+-struct at32_sm system_manager;
+-
+-static int __init at32_sm_init(void)
+-{
+-      struct resource *regs;
+-      struct at32_sm *sm = &system_manager;
+-      int ret = -ENXIO;
+-
+-      regs = platform_get_resource(&at32_sm_device, IORESOURCE_MEM, 0);
+-      if (!regs)
+-              goto fail;
+-
+-      spin_lock_init(&sm->lock);
+-      sm->pdev = &at32_sm_device;
+-
+-      ret = -ENOMEM;
+-      sm->regs = ioremap(regs->start, regs->end - regs->start + 1);
+-      if (!sm->regs)
+-              goto fail;
+-
+-      return 0;
+-
+-fail:
+-      printk(KERN_ERR "Failed to initialize System Manager: %d\n", ret);
+-      return ret;
+-}
  
struct clk *clk_get(struct device *dev, const char *id)
void __init setup_platform(void)
  {
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/hmatrix.h avr32-git/arch/avr32/mach-at32ap/hmatrix.h
---- linux-2.6.21.3/arch/avr32/mach-at32ap/hmatrix.h    1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/mach-at32ap/hmatrix.h 2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,182 @@
-+/*
-+ * Register definitions for High-Speed Bus Matrix
-+ */
-+#ifndef __HMATRIX_H
-+#define __HMATRIX_H
-+
-+/* HMATRIX register offsets */
-+#define HMATRIX_MCFG0                         0x0000
-+#define HMATRIX_MCFG1                         0x0004
-+#define HMATRIX_MCFG2                         0x0008
-+#define HMATRIX_MCFG3                         0x000c
-+#define HMATRIX_MCFG4                         0x0010
-+#define HMATRIX_MCFG5                         0x0014
-+#define HMATRIX_MCFG6                         0x0018
-+#define HMATRIX_MCFG7                         0x001c
-+#define HMATRIX_MCFG8                         0x0020
-+#define HMATRIX_MCFG9                         0x0024
-+#define HMATRIX_MCFG10                                0x0028
-+#define HMATRIX_MCFG11                                0x002c
-+#define HMATRIX_MCFG12                                0x0030
-+#define HMATRIX_MCFG13                                0x0034
-+#define HMATRIX_MCFG14                                0x0038
-+#define HMATRIX_MCFG15                                0x003c
-+#define HMATRIX_SCFG0                         0x0040
-+#define HMATRIX_SCFG1                         0x0044
-+#define HMATRIX_SCFG2                         0x0048
-+#define HMATRIX_SCFG3                         0x004c
-+#define HMATRIX_SCFG4                         0x0050
-+#define HMATRIX_SCFG5                         0x0054
-+#define HMATRIX_SCFG6                         0x0058
-+#define HMATRIX_SCFG7                         0x005c
-+#define HMATRIX_SCFG8                         0x0060
-+#define HMATRIX_SCFG9                         0x0064
-+#define HMATRIX_SCFG10                                0x0068
-+#define HMATRIX_SCFG11                                0x006c
-+#define HMATRIX_SCFG12                                0x0070
-+#define HMATRIX_SCFG13                                0x0074
-+#define HMATRIX_SCFG14                                0x0078
-+#define HMATRIX_SCFG15                                0x007c
-+#define HMATRIX_PRAS0                         0x0080
-+#define HMATRIX_PRBS0                         0x0084
-+#define HMATRIX_PRAS1                         0x0088
-+#define HMATRIX_PRBS1                         0x008c
-+#define HMATRIX_PRAS2                         0x0090
-+#define HMATRIX_PRBS2                         0x0094
-+#define HMATRIX_PRAS3                         0x0098
-+#define HMATRIX_PRBS3                         0x009c
-+#define HMATRIX_PRAS4                         0x00a0
-+#define HMATRIX_PRBS4                         0x00a4
-+#define HMATRIX_PRAS5                         0x00a8
-+#define HMATRIX_PRBS5                         0x00ac
-+#define HMATRIX_PRAS6                         0x00b0
-+#define HMATRIX_PRBS6                         0x00b4
-+#define HMATRIX_PRAS7                         0x00b8
-+#define HMATRIX_PRBS7                         0x00bc
-+#define HMATRIX_PRAS8                         0x00c0
-+#define HMATRIX_PRBS8                         0x00c4
-+#define HMATRIX_PRAS9                         0x00c8
-+#define HMATRIX_PRBS9                         0x00cc
-+#define HMATRIX_PRAS10                                0x00d0
-+#define HMATRIX_PRBS10                                0x00d4
-+#define HMATRIX_PRAS11                                0x00d8
-+#define HMATRIX_PRBS11                                0x00dc
-+#define HMATRIX_PRAS12                                0x00e0
-+#define HMATRIX_PRBS12                                0x00e4
-+#define HMATRIX_PRAS13                                0x00e8
-+#define HMATRIX_PRBS13                                0x00ec
-+#define HMATRIX_PRAS14                                0x00f0
-+#define HMATRIX_PRBS14                                0x00f4
-+#define HMATRIX_PRAS15                                0x00f8
-+#define HMATRIX_PRBS15                                0x00fc
-+#define HMATRIX_MRCR                          0x0100
-+#define HMATRIX_SFR0                          0x0110
-+#define HMATRIX_SFR1                          0x0114
-+#define HMATRIX_SFR2                          0x0118
-+#define HMATRIX_SFR3                          0x011c
-+#define HMATRIX_SFR4                          0x0120
-+#define HMATRIX_SFR5                          0x0124
-+#define HMATRIX_SFR6                          0x0128
-+#define HMATRIX_SFR7                          0x012c
-+#define HMATRIX_SFR8                          0x0130
-+#define HMATRIX_SFR9                          0x0134
-+#define HMATRIX_SFR10                         0x0138
-+#define HMATRIX_SFR11                         0x013c
-+#define HMATRIX_SFR12                         0x0140
-+#define HMATRIX_SFR13                         0x0144
-+#define HMATRIX_SFR14                         0x0148
-+#define HMATRIX_SFR15                         0x014c
-+
-+/* Bitfields in MCFGx */
-+#define HMATRIX_ULBT_OFFSET                   0
-+#define HMATRIX_ULBT_SIZE                     3
-+
-+/* Bitfields in SCFGx */
-+#define HMATRIX_SLOT_CYCLE_OFFSET             0
-+#define HMATRIX_SLOT_CYCLE_SIZE                       8
-+#define HMATRIX_DEFMSTR_TYPE_OFFSET           16
-+#define HMATRIX_DEFMSTR_TYPE_SIZE             2
-+#define HMATRIX_FIXED_DEFMSTR_OFFSET          18
-+#define HMATRIX_FIXED_DEFMSTR_SIZE            4
-+#define HMATRIX_ARBT_OFFSET                   24
-+#define HMATRIX_ARBT_SIZE                     2
-+
-+/* Bitfields in PRASx */
-+#define HMATRIX_M0PR_OFFSET                   0
-+#define HMATRIX_M0PR_SIZE                     4
-+#define HMATRIX_M1PR_OFFSET                   4
-+#define HMATRIX_M1PR_SIZE                     4
-+#define HMATRIX_M2PR_OFFSET                   8
-+#define HMATRIX_M2PR_SIZE                     4
-+#define HMATRIX_M3PR_OFFSET                   12
-+#define HMATRIX_M3PR_SIZE                     4
-+#define HMATRIX_M4PR_OFFSET                   16
-+#define HMATRIX_M4PR_SIZE                     4
-+#define HMATRIX_M5PR_OFFSET                   20
-+#define HMATRIX_M5PR_SIZE                     4
-+#define HMATRIX_M6PR_OFFSET                   24
-+#define HMATRIX_M6PR_SIZE                     4
-+#define HMATRIX_M7PR_OFFSET                   28
-+#define HMATRIX_M7PR_SIZE                     4
-+
-+/* Bitfields in PRBSx */
-+#define HMATRIX_M8PR_OFFSET                   0
-+#define HMATRIX_M8PR_SIZE                     4
-+#define HMATRIX_M9PR_OFFSET                   4
-+#define HMATRIX_M9PR_SIZE                     4
-+#define HMATRIX_M10PR_OFFSET                  8
-+#define HMATRIX_M10PR_SIZE                    4
-+#define HMATRIX_M11PR_OFFSET                  12
-+#define HMATRIX_M11PR_SIZE                    4
-+#define HMATRIX_M12PR_OFFSET                  16
-+#define HMATRIX_M12PR_SIZE                    4
-+#define HMATRIX_M13PR_OFFSET                  20
-+#define HMATRIX_M13PR_SIZE                    4
-+#define HMATRIX_M14PR_OFFSET                  24
-+#define HMATRIX_M14PR_SIZE                    4
-+#define HMATRIX_M15PR_OFFSET                  28
-+#define HMATRIX_M15PR_SIZE                    4
-+
-+/* Bitfields in SFR4 */
-+#define HMATRIX_CS1A_OFFSET                   1
-+#define HMATRIX_CS1A_SIZE                     1
-+#define HMATRIX_CS3A_OFFSET                   3
-+#define HMATRIX_CS3A_SIZE                     1
-+#define HMATRIX_CS4A_OFFSET                   4
-+#define HMATRIX_CS4A_SIZE                     1
-+#define HMATRIX_CS5A_OFFSET                   5
-+#define HMATRIX_CS5A_SIZE                     1
-+#define HMATRIX_DBPUC_OFFSET                  8
-+#define HMATRIX_DBPUC_SIZE                    1
-+
-+/* Constants for ULBT */
-+#define HMATRIX_ULBT_INFINITE                 0
-+#define HMATRIX_ULBT_SINGLE                   1
-+#define HMATRIX_ULBT_FOUR_BEAT                        2
-+#define HMATRIX_ULBT_EIGHT_BEAT                       3
-+#define HMATRIX_ULBT_SIXTEEN_BEAT             4
-+
-+/* Constants for DEFMSTR_TYPE */
-+#define HMATRIX_DEFMSTR_TYPE_NO_DEFAULT               0
-+#define HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT     1
-+#define HMATRIX_DEFMSTR_TYPE_FIXED_DEFAULT    2
-+
-+/* Constants for ARBT */
-+#define HMATRIX_ARBT_ROUND_ROBIN              0
-+#define HMATRIX_ARBT_FIXED_PRIORITY           1
-+
-+/* Bit manipulation macros */
-+#define HMATRIX_BIT(name)                                     \
-+      (1 << HMATRIX_##name##_OFFSET)
-+#define HMATRIX_BF(name,value)                                        \
-+      (((value) & ((1 << HMATRIX_##name##_SIZE) - 1))         \
-+       << HMATRIX_##name##_OFFSET)
-+#define HMATRIX_BFEXT(name,value)                             \
-+      (((value) >> HMATRIX_##name##_OFFSET)                   \
-+       & ((1 << HMATRIX_##name##_SIZE) - 1))
-+#define HMATRIX_BFINS(name,value,old)                         \
-+      (((old) & ~(((1 << HMATRIX_##name##_SIZE) - 1)          \
-+                  << HMATRIX_##name##_OFFSET))                \
-+       | HMATRIX_BF(name,value))
-+
-+#endif /* __HMATRIX_H */
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/hsmc.c avr32-git/arch/avr32/mach-at32ap/hsmc.c
---- linux-2.6.21.3/arch/avr32/mach-at32ap/hsmc.c       2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mach-at32ap/hsmc.c    2007-06-06 11:33:46.000000000 +0200
-@@ -75,12 +75,35 @@
-               return -EINVAL;
-       }
-+      switch (config->nwait_mode) {
-+      case 0:
-+              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_DISABLED);
-+              break;
-+      case 1:
-+              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_RESERVED);
-+              break;
-+      case 2:
-+              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_FROZEN);
-+              break;
-+      case 3:
-+              mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_READY);
-+              break;
-+      default:
-+              return -EINVAL;
-+      }
-+
-+      if (config->tdf_cycles) {
-+              mode |= HSMC_BF(TDF_CYCLES, config->tdf_cycles);
-+      }
-+
-       if (config->nrd_controlled)
-               mode |= HSMC_BIT(READ_MODE);
-       if (config->nwe_controlled)
-               mode |= HSMC_BIT(WRITE_MODE);
-       if (config->byte_write)
-               mode |= HSMC_BIT(BAT);
-+      if (config->tdf_mode)
-+              mode |= HSMC_BIT(TDF_MODE);
-       pr_debug("smc cs%d: setup/%08x pulse/%08x cycle/%08x mode/%08x\n",
-                cs, setup, pulse, cycle, mode);
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/Kconfig avr32-git/arch/avr32/mach-at32ap/Kconfig
---- linux-2.6.21.3/arch/avr32/mach-at32ap/Kconfig      1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/mach-at32ap/Kconfig   2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,31 @@
-+if PLATFORM_AT32AP
-+
-+menu "Atmel AVR32 AP options"
-+
-+choice
-+      prompt "AT32AP7000 static memory bus width"
-+      depends on CPU_AT32AP7000
-+      default AP7000_16_BIT_SMC
-+      help
-+        Define the width of the AP7000 external static memory interface.
-+        This is used to determine how to mangle the address and/or data
-+        when doing little-endian port access.
-+
-+        The current code can only support a single external memory bus
-+        width for all chip selects, excluding the flash (which is using
-+        raw access and is thus not affected by any of this.)
-+
-+config AP7000_32_BIT_SMC
-+      bool "32 bit"
-+
-+config AP7000_16_BIT_SMC
-+      bool "16 bit"
-+
-+config AP7000_8_BIT_SMC
-+      bool "8 bit"
-+
-+endchoice
-+
-+endmenu
-+
-+endif # PLATFORM_AT32AP
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/Makefile avr32-git/arch/avr32/mach-at32ap/Makefile
---- linux-2.6.21.3/arch/avr32/mach-at32ap/Makefile     2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mach-at32ap/Makefile  2007-06-06 11:33:46.000000000 +0200
-@@ -1,2 +1,3 @@
- obj-y                         += at32ap.o clock.o intc.o extint.o pio.o hsmc.o
- obj-$(CONFIG_CPU_AT32AP7000)  += at32ap7000.o
-+obj-$(CONFIG_CPU_AT32AP7000)  += time-tc.o
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/time-tc.c avr32-git/arch/avr32/mach-at32ap/time-tc.c
---- linux-2.6.21.3/arch/avr32/mach-at32ap/time-tc.c    1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/arch/avr32/mach-at32ap/time-tc.c 2007-06-06 11:33:46.000000000 +0200
-@@ -0,0 +1,218 @@
+-      at32_sm_init();
+       at32_clock_init();
+       at32_portmux_init();
+ }
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/cpufreq.c linux-avr32.git/arch/avr32/mach-at32ap/cpufreq.c
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/cpufreq.c    1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/mach-at32ap/cpufreq.c   2007-07-12 13:59:49.000000000 +0200
+@@ -0,0 +1,112 @@
 +/*
 + * Copyright (C) 2004-2007 Atmel Corporation
 + *
@@ -4154,4012 +2185,8031 @@ diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/time-tc.c
 + * published by the Free Software Foundation.
 + */
 +
-+#include <linux/clk.h>
-+#include <linux/clocksource.h>
-+#include <linux/time.h>
-+#include <linux/module.h>
-+#include <linux/interrupt.h>
-+#include <linux/irq.h>
-+#include <linux/kernel_stat.h>
-+#include <linux/errno.h>
++/*#define DEBUG*/
++
++#include <linux/kernel.h>
++#include <linux/types.h>
 +#include <linux/init.h>
-+#include <linux/profile.h>
-+#include <linux/sysdev.h>
++#include <linux/cpufreq.h>
++#include <linux/io.h>
++#include <linux/clk.h>
 +#include <linux/err.h>
++#include <asm/system.h>
 +
-+#include <asm/div64.h>
-+#include <asm/sysreg.h>
-+#include <asm/io.h>
-+#include <asm/sections.h>
-+
-+#include <asm/arch/time.h>
-+
-+/* how many counter cycles in a jiffy? */
-+static u32 cycles_per_jiffy;
-+
-+/* the count value for the next timer interrupt */
-+static u32 expirelo;
++static struct clk *cpuclk;
 +
-+/* the I/O registers of the TC module */
-+static void __iomem *ioregs;
-+
-+cycle_t read_cycle_count(void)
-+{
-+      return (cycle_t)timer_read(ioregs, 0, CV);
-+}
-+
-+struct clocksource clocksource_avr32 = {
-+      .name           = "avr32",
-+      .rating         = 342,
-+      .read           = read_cycle_count,
-+      .mask           = CLOCKSOURCE_MASK(16),
-+      .shift          = 16,
-+      .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
-+};
-+
-+static void avr32_timer_ack(void)
++static int at32_verify_speed(struct cpufreq_policy *policy)
 +{
-+      u16 count = expirelo;
-+
-+      /* Ack this timer interrupt and set the next one, use a u16
-+       * variable so it will wrap around correctly */
-+      count += cycles_per_jiffy;
-+      expirelo = count;
-+      timer_write(ioregs, 0, RC, expirelo);
++      if (policy->cpu != 0)
++              return -EINVAL;
 +
-+      /* Check to see if we have missed any timer interrupts */
-+      count = timer_read(ioregs, 0, CV);
-+      if ((count - expirelo) < 0x7fff) {
-+              expirelo = count + cycles_per_jiffy;
-+              timer_write(ioregs, 0, RC, expirelo);
-+      }
++      cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
++                      policy->cpuinfo.max_freq);
++      return 0;
 +}
 +
-+u32 avr32_hpt_read(void)
++static unsigned int at32_get_speed(unsigned int cpu)
 +{
-+      return timer_read(ioregs, 0, CV);
++      /* No SMP support */
++      if (cpu)
++              return 0;
++      return (unsigned int)((clk_get_rate(cpuclk) + 500) / 1000);
 +}
 +
-+static int avr32_timer_calc_div_and_set_jiffies(struct clk *pclk)
++static int at32_set_target(struct cpufreq_policy *policy,
++                        unsigned int target_freq,
++                        unsigned int relation)
 +{
-+      unsigned int cycles_max = (clocksource_avr32.mask + 1) / 2;
-+      unsigned int divs[] = { 4, 8, 16, 32 };
-+      int divs_size = sizeof(divs) / sizeof(*divs);
-+      int i = 0;
-+      unsigned long count_hz;
-+      unsigned long shift;
-+      unsigned long mult;
-+      int clock_div = -1;
-+      u64 tmp;
-+
-+      shift = clocksource_avr32.shift;
++      struct cpufreq_freqs freqs;
++      long freq;
 +
-+      do {
-+              count_hz = clk_get_rate(pclk) / divs[i];
-+              mult = clocksource_hz2mult(count_hz, shift);
-+              clocksource_avr32.mult = mult;
++      /* Convert target_freq from kHz to Hz */
++      freq = clk_round_rate(cpuclk, target_freq * 1000);
 +
-+              tmp = TICK_NSEC;
-+              tmp <<= shift;
-+              tmp += mult / 2;
-+              do_div(tmp, mult);
++      /* Check if policy->min <= new_freq <= policy->max */
++      if(freq < (policy->min * 1000) || freq > (policy->max * 1000))
++              return -EINVAL;
 +
-+              cycles_per_jiffy = tmp;
-+      } while (cycles_per_jiffy > cycles_max && ++i < divs_size);
++      pr_debug("cpufreq: requested frequency %u Hz\n", target_freq * 1000);
 +
-+      clock_div = i + 1;
++      freqs.old = at32_get_speed(0);
++      freqs.new = (freq + 500) / 1000;
++      freqs.cpu = 0;
++      freqs.flags = 0;
 +
-+      if (clock_div > divs_size) {
-+              pr_debug("timer: could not calculate clock divider\n");
-+              return -EFAULT;
-+      }
++      cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
++      clk_set_rate(cpuclk, freq);
++      cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
 +
-+      /* Set the clock divider */
-+      timer_write(ioregs, 0, CMR, TIMER_BF(CMR_TCCLKS, clock_div));
++      pr_debug("cpufreq: set frequency %lu Hz\n", freq);
 +
 +      return 0;
 +}
 +
-+int avr32_hpt_init(unsigned int count)
++static int __init at32_cpufreq_driver_init(struct cpufreq_policy *policy)
 +{
-+      struct resource *regs;
-+      struct clk *pclk;
-+      int irq = -1;
-+      int ret = 0;
-+
-+      ret = -ENXIO;
-+
-+      irq = platform_get_irq(&at32_systc0_device, 0);
-+      if (irq < 0) {
-+              pr_debug("timer: could not get irq\n");
-+              goto out_error;
-+      }
-+
-+      pclk = clk_get(&at32_systc0_device.dev, "pclk");
-+      if (IS_ERR(pclk)) {
-+              pr_debug("timer: could not get clk: %ld\n", PTR_ERR(pclk));
-+              goto out_error;
-+      }
-+      clk_enable(pclk);
-+
-+      regs = platform_get_resource(&at32_systc0_device, IORESOURCE_MEM, 0);
-+      if (!regs) {
-+              pr_debug("timer: could not get resource\n");
-+              goto out_error_clk;
-+      }
-+
-+      ioregs = ioremap(regs->start, regs->end - regs->start + 1);
-+      if (!ioregs) {
-+              pr_debug("timer: could not get ioregs\n");
-+              goto out_error_clk;
-+      }
-+
-+      ret = avr32_timer_calc_div_and_set_jiffies(pclk);
-+      if (ret)
-+              goto out_error_io;
++      if (policy->cpu != 0)
++              return -EINVAL;
 +
-+      ret = setup_irq(irq, &timer_irqaction);
-+      if (ret) {
-+              pr_debug("timer: could not request irq %d: %d\n",
-+                              irq, ret);
-+              goto out_error_io;
++      cpuclk = clk_get(NULL, "cpu");
++      if (IS_ERR(cpuclk)) {
++              pr_debug("cpufreq: could not get CPU clk\n");
++              return PTR_ERR(cpuclk);
 +      }
 +
-+      expirelo = (timer_read(ioregs, 0, CV) / cycles_per_jiffy + 1)
-+              * cycles_per_jiffy;
++      policy->cpuinfo.min_freq = (clk_round_rate(cpuclk, 1) + 500) / 1000;
++      policy->cpuinfo.max_freq = (clk_round_rate(cpuclk, ~0UL) + 500) / 1000;
++      policy->cpuinfo.transition_latency = 0;
++      policy->cur = at32_get_speed(0);
++      policy->min = policy->cpuinfo.min_freq;
++      policy->max = policy->cpuinfo.max_freq;
++      policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
 +
-+      /* Enable clock and interrupts on RC compare */
-+      timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_CLKEN));
-+      timer_write(ioregs, 0, IER, TIMER_BIT(IER_CPCS));
-+      /* Set cycles to first interrupt */
-+      timer_write(ioregs, 0,  RC, expirelo);
-+
-+      printk(KERN_INFO "timer: AT32AP system timer/counter at 0x%p irq %d\n",
-+                      ioregs, irq);
++      printk("cpufreq: AT32AP CPU frequency driver\n");
 +
 +      return 0;
-+
-+out_error_io:
-+      iounmap(ioregs);
-+out_error_clk:
-+      clk_put(pclk);
-+out_error:
-+      return ret;
 +}
 +
-+int avr32_hpt_start(void)
-+{
-+      timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_SWTRG));
-+      return 0;
-+}
++static struct cpufreq_driver at32_driver = {
++      .name           = "at32ap",
++      .owner          = THIS_MODULE,
++      .init           = at32_cpufreq_driver_init,
++      .verify         = at32_verify_speed,
++      .target         = at32_set_target,
++      .get            = at32_get_speed,
++      .flags          = CPUFREQ_STICKY,
++};
 +
-+irqreturn_t timer_interrupt(int irq, void *dev_id)
++static int __init at32_cpufreq_init(void)
 +{
-+      unsigned int sr = timer_read(ioregs, 0, SR);
-+
-+      if (sr & TIMER_BIT(SR_CPCS)) {
-+              /* ack timer interrupt and try to set next interrupt */
-+              avr32_timer_ack();
++      return cpufreq_register_driver(&at32_driver);
++}
 +
-+              /*
-+               * Call the generic timer interrupt handler
-+               */
-+              write_seqlock(&xtime_lock);
-+              do_timer(1);
-+              write_sequnlock(&xtime_lock);
++arch_initcall(at32_cpufreq_init);
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/extint.c linux-avr32.git/arch/avr32/mach-at32ap/extint.c
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/extint.c     2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/extint.c    2007-07-12 13:59:49.000000000 +0200
+@@ -17,42 +17,83 @@
+ #include <asm/io.h>
+-#include <asm/arch/sm.h>
+-
+-#include "sm.h"
++/* EIC register offsets */
++#define EIC_IER                                       0x0000
++#define EIC_IDR                                       0x0004
++#define EIC_IMR                                       0x0008
++#define EIC_ISR                                       0x000c
++#define EIC_ICR                                       0x0010
++#define EIC_MODE                              0x0014
++#define EIC_EDGE                              0x0018
++#define EIC_LEVEL                             0x001c
++#define EIC_TEST                              0x0020
++#define EIC_NMIC                              0x0024
++
++/* Bitfields in TEST */
++#define EIC_TESTEN_OFFSET                     31
++#define EIC_TESTEN_SIZE                               1
++
++/* Bitfields in NMIC */
++#define EIC_EN_OFFSET                         0
++#define EIC_EN_SIZE                           1
 +
-+              /*
-+               * In UP mode, we call local_timer_interrupt() to do profiling
-+               * and process accounting.
-+               *
-+               * SMP is not supported yet.
-+               */
-+              local_timer_interrupt(irq, dev_id);
++/* Bit manipulation macros */
++#define EIC_BIT(name)                                 \
++      (1 << EIC_##name##_OFFSET)
++#define EIC_BF(name,value)                            \
++      (((value) & ((1 << EIC_##name##_SIZE) - 1))     \
++       << EIC_##name##_OFFSET)
++#define EIC_BFEXT(name,value)                         \
++      (((value) >> EIC_##name##_OFFSET)               \
++       & ((1 << EIC_##name##_SIZE) - 1))
++#define EIC_BFINS(name,value,old)                     \
++      (((old) & ~(((1 << EIC_##name##_SIZE) - 1)      \
++                  << EIC_##name##_OFFSET))            \
++       | EIC_BF(name,value))
 +
-+              return IRQ_HANDLED;
-+      }
++/* Register access macros */
++#define eic_readl(port,reg)                           \
++      __raw_readl((port)->regs + EIC_##reg)
++#define eic_writel(port,reg,value)                    \
++      __raw_writel((value), (port)->regs + EIC_##reg)
 +
-+      return IRQ_NONE;
-+}
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Makefile avr32-git/arch/avr32/Makefile
---- linux-2.6.21.3/arch/avr32/Makefile 2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/Makefile      2007-06-06 11:33:46.000000000 +0200
-@@ -16,7 +16,7 @@
- CFLAGS_MODULE += -mno-relax
- LDFLAGS_vmlinux       += --relax
--cpuflags-$(CONFIG_CPU_AP7000) += -mcpu=ap7000
-+cpuflags-$(CONFIG_CPU_AT32AP7000)     += -mcpu=ap7000
- CFLAGS                += $(cpuflags-y)
- AFLAGS                += $(cpuflags-y)
-@@ -27,9 +27,11 @@
- head-y                                        += arch/avr32/kernel/head.o
- core-$(CONFIG_PLATFORM_AT32AP)                += arch/avr32/mach-at32ap/
- core-$(CONFIG_BOARD_ATSTK1000)                += arch/avr32/boards/atstk1000/
-+core-$(CONFIG_BOARD_ATNGW100)         += arch/avr32/boards/atngw100/
- core-$(CONFIG_LOADER_U_BOOT)          += arch/avr32/boot/u-boot/
- core-y                                        += arch/avr32/kernel/
- core-y                                        += arch/avr32/mm/
-+drivers-y                             += arch/avr32/drivers/
- libs-y                                        += arch/avr32/lib/
++struct eic {
++      void __iomem *regs;
++      struct irq_chip *chip;
++      unsigned int first_irq;
++};
  
- archincdir-$(CONFIG_PLATFORM_AT32AP)  := arch-at32ap
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mm/dma-coherent.c avr32-git/arch/avr32/mm/dma-coherent.c
---- linux-2.6.21.3/arch/avr32/mm/dma-coherent.c        2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mm/dma-coherent.c     2007-06-06 11:33:46.000000000 +0200
-@@ -112,16 +112,21 @@
+-static void eim_ack_irq(unsigned int irq)
++static void eic_ack_irq(unsigned int irq)
+ {
+-      struct at32_sm *sm = get_irq_chip_data(irq);
+-      sm_writel(sm, EIM_ICR, 1 << (irq - sm->eim_first_irq));
++      struct eic *eic = get_irq_chip_data(irq);
++      eic_writel(eic, ICR, 1 << (irq - eic->first_irq));
  }
- EXPORT_SYMBOL(dma_free_coherent);
  
--#if 0
- void *dma_alloc_writecombine(struct device *dev, size_t size,
-                            dma_addr_t *handle, gfp_t gfp)
+-static void eim_mask_irq(unsigned int irq)
++static void eic_mask_irq(unsigned int irq)
  {
-       struct page *page;
-+      dma_addr_t phys;
-       page = __dma_alloc(dev, size, handle, gfp);
-+      if (!page)
-+              return NULL;
-+
-+      phys = page_to_phys(page);
-+      *handle = phys;
-       /* Now, map the page into P3 with write-combining turned on */
--      return __ioremap(page_to_phys(page), size, _PAGE_BUFFER);
-+      return __ioremap(phys, size, _PAGE_BUFFER);
+-      struct at32_sm *sm = get_irq_chip_data(irq);
+-      sm_writel(sm, EIM_IDR, 1 << (irq - sm->eim_first_irq));
++      struct eic *eic = get_irq_chip_data(irq);
++      eic_writel(eic, IDR, 1 << (irq - eic->first_irq));
  }
- EXPORT_SYMBOL(dma_alloc_writecombine);
-@@ -132,8 +137,7 @@
  
-       iounmap(cpu_addr);
+-static void eim_mask_ack_irq(unsigned int irq)
++static void eic_mask_ack_irq(unsigned int irq)
+ {
+-      struct at32_sm *sm = get_irq_chip_data(irq);
+-      sm_writel(sm, EIM_ICR, 1 << (irq - sm->eim_first_irq));
+-      sm_writel(sm, EIM_IDR, 1 << (irq - sm->eim_first_irq));
++      struct eic *eic = get_irq_chip_data(irq);
++      eic_writel(eic, ICR, 1 << (irq - eic->first_irq));
++      eic_writel(eic, IDR, 1 << (irq - eic->first_irq));
+ }
  
--      page = bus_to_page(handle);
-+      page = phys_to_page(handle);
-       __dma_free(dev, size, page, handle);
+-static void eim_unmask_irq(unsigned int irq)
++static void eic_unmask_irq(unsigned int irq)
+ {
+-      struct at32_sm *sm = get_irq_chip_data(irq);
+-      sm_writel(sm, EIM_IER, 1 << (irq - sm->eim_first_irq));
++      struct eic *eic = get_irq_chip_data(irq);
++      eic_writel(eic, IER, 1 << (irq - eic->first_irq));
  }
- EXPORT_SYMBOL(dma_free_writecombine);
--#endif
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mm/fault.c avr32-git/arch/avr32/mm/fault.c
---- linux-2.6.21.3/arch/avr32/mm/fault.c       2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mm/fault.c    2007-06-06 11:33:46.000000000 +0200
-@@ -12,73 +12,46 @@
- #include <linux/mm.h>
- #include <linux/module.h>
- #include <linux/pagemap.h>
-+#include <linux/kprobes.h>
- #include <asm/kdebug.h>
- #include <asm/mmu_context.h>
- #include <asm/sysreg.h>
--#include <asm/uaccess.h>
- #include <asm/tlb.h>
--
--#ifdef DEBUG
--static void dump_code(unsigned long pc)
--{
--      char *p = (char *)pc;
--      char val;
--      int i;
--
--
--      printk(KERN_DEBUG "Code:");
--      for (i = 0; i < 16; i++) {
--              if (__get_user(val, p + i))
--                      break;
--              printk(" %02x", val);
--      }
--      printk("\n");
--}
--#endif
-+#include <asm/uaccess.h>
  
- #ifdef CONFIG_KPROBES
--ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
--
--/* Hook to register for page fault notifications */
--int register_page_fault_notifier(struct notifier_block *nb)
-+static inline int notify_page_fault(struct pt_regs *regs, int trap)
+-static int eim_set_irq_type(unsigned int irq, unsigned int flow_type)
++static int eic_set_irq_type(unsigned int irq, unsigned int flow_type)
  {
--      return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
--}
-+      int ret = 0;
+-      struct at32_sm *sm = get_irq_chip_data(irq);
++      struct eic *eic = get_irq_chip_data(irq);
+       struct irq_desc *desc;
+-      unsigned int i = irq - sm->eim_first_irq;
++      unsigned int i = irq - eic->first_irq;
+       u32 mode, edge, level;
+-      unsigned long flags;
+       int ret = 0;
+       flow_type &= IRQ_TYPE_SENSE_MASK;
+@@ -60,11 +101,10 @@
+               flow_type = IRQ_TYPE_LEVEL_LOW;
+       desc = &irq_desc[irq];
+-      spin_lock_irqsave(&sm->lock, flags);
+-      mode = sm_readl(sm, EIM_MODE);
+-      edge = sm_readl(sm, EIM_EDGE);
+-      level = sm_readl(sm, EIM_LEVEL);
++      mode = eic_readl(eic, MODE);
++      edge = eic_readl(eic, EDGE);
++      level = eic_readl(eic, LEVEL);
+       switch (flow_type) {
+       case IRQ_TYPE_LEVEL_LOW:
+@@ -89,9 +129,9 @@
+       }
  
--int unregister_page_fault_notifier(struct notifier_block *nb)
--{
--      return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
--}
-+      if (!user_mode(regs)) {
-+              if (kprobe_running() && kprobe_fault_handler(regs, trap))
-+                      ret = 1;
-+      }
+       if (ret == 0) {
+-              sm_writel(sm, EIM_MODE, mode);
+-              sm_writel(sm, EIM_EDGE, edge);
+-              sm_writel(sm, EIM_LEVEL, level);
++              eic_writel(eic, MODE, mode);
++              eic_writel(eic, EDGE, edge);
++              eic_writel(eic, LEVEL, level);
+               if (flow_type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
+                       flow_type |= IRQ_LEVEL;
+@@ -99,35 +139,33 @@
+               desc->status |= flow_type;
+       }
  
--static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
--                                  int trap, int sig)
--{
--      struct die_args args = {
--              .regs = regs,
--              .trapnr = trap,
--      };
--      return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
-+      return ret;
+-      spin_unlock_irqrestore(&sm->lock, flags);
+-
+       return ret;
  }
- #else
--static inline int notify_page_fault(enum die_val val, struct pt_regs *regs,
--                                  int trap, int sig)
-+static inline int notify_page_fault(struct pt_regs *regs, int trap)
+-struct irq_chip eim_chip = {
+-      .name           = "eim",
+-      .ack            = eim_ack_irq,
+-      .mask           = eim_mask_irq,
+-      .mask_ack       = eim_mask_ack_irq,
+-      .unmask         = eim_unmask_irq,
+-      .set_type       = eim_set_irq_type,
++struct irq_chip eic_chip = {
++      .name           = "eic",
++      .ack            = eic_ack_irq,
++      .mask           = eic_mask_irq,
++      .mask_ack       = eic_mask_ack_irq,
++      .unmask         = eic_unmask_irq,
++      .set_type       = eic_set_irq_type,
+ };
+-static void demux_eim_irq(unsigned int irq, struct irq_desc *desc)
++static void demux_eic_irq(unsigned int irq, struct irq_desc *desc)
  {
--      return NOTIFY_DONE;
-+      return 0;
+-      struct at32_sm *sm = desc->handler_data;
++      struct eic *eic = desc->handler_data;
+       struct irq_desc *ext_desc;
+       unsigned long status, pending;
+       unsigned int i, ext_irq;
+-      status = sm_readl(sm, EIM_ISR);
+-      pending = status & sm_readl(sm, EIM_IMR);
++      status = eic_readl(eic, ISR);
++      pending = status & eic_readl(eic, IMR);
+       while (pending) {
+               i = fls(pending) - 1;
+               pending &= ~(1 << i);
+-              ext_irq = i + sm->eim_first_irq;
++              ext_irq = i + eic->first_irq;
+               ext_desc = irq_desc + ext_irq;
+               if (ext_desc->status & IRQ_LEVEL)
+                       handle_level_irq(ext_irq, ext_desc);
+@@ -136,51 +174,85 @@
+       }
  }
- #endif
  
-+int exception_trace = 1;
-+
- /*
-  * This routine handles page faults. It determines the address and the
-  * problem, and then passes it off to one of the appropriate routines.
-  *
-  * ecr is the Exception Cause Register. Possible values are:
-- *   5:  Page not found (instruction access)
-  *   6:  Protection fault (instruction access)
-- *   12: Page not found (read access)
-- *   13: Page not found (write access)
-- *   14: Protection fault (read access)
-- *   15: Protection fault (write access)
-+ *   15: Protection fault (read access)
-+ *   16: Protection fault (write access)
-+ *   20: Page not found (instruction access)
-+ *   24: Page not found (read access)
-+ *   28: Page not found (write access)
-  */
- asmlinkage void do_page_fault(unsigned long ecr, struct pt_regs *regs)
+-static int __init eim_init(void)
++static int __init eic_probe(struct platform_device *pdev)
  {
-@@ -88,10 +61,11 @@
-       const struct exception_table_entry *fixup;
-       unsigned long address;
-       unsigned long page;
--      int writeaccess = 0;
-+      int writeaccess;
-+      long signr;
-+      int code;
--      if (notify_page_fault(DIE_PAGE_FAULT, regs,
--                            ecr, SIGSEGV) == NOTIFY_STOP)
-+      if (notify_page_fault(regs, ecr))
-               return;
-       address = sysreg_read(TLBEAR);
-@@ -99,6 +73,9 @@
-       tsk = current;
-       mm = tsk->mm;
-+      signr = SIGSEGV;
-+      code = SEGV_MAPERR;
-+
-       /*
-        * If we're in an interrupt or have no user context, we must
-        * not take the fault...
-@@ -125,7 +102,9 @@
-        * can handle it...
-        */
- good_area:
--      //pr_debug("good area: vm_flags = 0x%lx\n", vma->vm_flags);
-+      code = SEGV_ACCERR;
-+      writeaccess = 0;
-+
-       switch (ecr) {
-       case ECR_PROTECTION_X:
-       case ECR_TLB_MISS_X:
-@@ -176,46 +155,24 @@
-        * map. Fix it, but check if it's kernel or user first...
-        */
- bad_area:
--      pr_debug("Bad area [%s:%u]: addr %08lx, ecr %lu\n",
--               tsk->comm, tsk->pid, address, ecr);
--
-       up_read(&mm->mmap_sem);
-       if (user_mode(regs)) {
--              /* Hmm...we have to pass address and ecr somehow... */
--              /* tsk->thread.address = address;
--                 tsk->thread.error_code = ecr; */
--#ifdef DEBUG
--              show_regs(regs);
--              dump_code(regs->pc);
--
--              page = sysreg_read(PTBR);
--              printk("ptbr = %08lx", page);
--              if (page) {
--                      page = ((unsigned long *)page)[address >> 22];
--                      printk(" pgd = %08lx", page);
--                      if (page & _PAGE_PRESENT) {
--                              page &= PAGE_MASK;
--                              address &= 0x003ff000;
--                              page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
--                              printk(" pte = %08lx\n", page);
--                      }
--              }
--#endif
--              pr_debug("Sending SIGSEGV to PID %d...\n",
--                      tsk->pid);
--              force_sig(SIGSEGV, tsk);
-+              if (exception_trace && printk_ratelimit())
-+                      printk("%s%s[%d]: segfault at %08lx pc %08lx "
-+                             "sp %08lx ecr %lu\n",
-+                             is_init(tsk) ? KERN_EMERG : KERN_INFO,
-+                             tsk->comm, tsk->pid, address, regs->pc,
-+                             regs->sp, ecr);
-+              _exception(SIGSEGV, regs, code, address);
-               return;
-       }
- no_context:
--      pr_debug("No context\n");
--
-       /* Are we prepared to handle this kernel fault? */
-       fixup = search_exception_tables(regs->pc);
-       if (fixup) {
-               regs->pc = fixup->fixup;
--              pr_debug("Found fixup at %08lx\n", fixup->fixup);
-               return;
-       }
+-      struct at32_sm *sm = &system_manager;
++      struct eic *eic;
++      struct resource *regs;
+       unsigned int i;
+       unsigned int nr_irqs;
+       unsigned int int_irq;
++      int ret;
+       u32 pattern;
  
-@@ -230,7 +187,6 @@
-               printk(KERN_ALERT
-                      "Unable to handle kernel paging request");
-       printk(" at virtual address %08lx\n", address);
--      printk(KERN_ALERT "pc = %08lx\n", regs->pc);
-       page = sysreg_read(PTBR);
-       printk(KERN_ALERT "ptbr = %08lx", page);
-@@ -241,20 +197,20 @@
-                       page &= PAGE_MASK;
-                       address &= 0x003ff000;
-                       page = ((unsigned long *)__va(page))[address >> PAGE_SHIFT];
--                      printk(" pte = %08lx\n", page);
-+                      printk(" pte = %08lx", page);
-               }
-       }
--      die("\nOops", regs, ecr);
--      do_exit(SIGKILL);
-+      printk("\n");
-+      die("Kernel access of bad area", regs, signr);
-+      return;
+-      /*
+-       * The EIM is really the same module as SM, so register
+-       * mapping, etc. has been taken care of already.
+-       */
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      int_irq = platform_get_irq(pdev, 0);
++      if (!regs || !int_irq) {
++              dev_dbg(&pdev->dev, "missing regs and/or irq resource\n");
++              return -ENXIO;
++      }
++
++      ret = -ENOMEM;
++      eic = kzalloc(sizeof(struct eic), GFP_KERNEL);
++      if (!eic) {
++              dev_dbg(&pdev->dev, "no memory for eic structure\n");
++              goto err_kzalloc;
++      }
++
++      eic->first_irq = EIM_IRQ_BASE + 32 * pdev->id;
++      eic->regs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!eic->regs) {
++              dev_dbg(&pdev->dev, "failed to map regs\n");
++              goto err_ioremap;
++      }
  
        /*
-        * We ran out of memory, or some other thing happened to us
-        * that made us unable to handle the page fault gracefully.
+        * Find out how many interrupt lines that are actually
+        * implemented in hardware.
         */
- out_of_memory:
--      printk("Out of memory\n");
-       up_read(&mm->mmap_sem);
--      if (current->pid == 1) {
-+      if (is_init(current)) {
-               yield();
-               down_read(&mm->mmap_sem);
-               goto survive;
-@@ -267,21 +223,20 @@
- do_sigbus:
-       up_read(&mm->mmap_sem);
+-      sm_writel(sm, EIM_IDR, ~0UL);
+-      sm_writel(sm, EIM_MODE, ~0UL);
+-      pattern = sm_readl(sm, EIM_MODE);
++      eic_writel(eic, IDR, ~0UL);
++      eic_writel(eic, MODE, ~0UL);
++      pattern = eic_readl(eic, MODE);
+       nr_irqs = fls(pattern);
+       /* Trigger on falling edge unless overridden by driver */
+-      sm_writel(sm, EIM_MODE, 0UL);
+-      sm_writel(sm, EIM_EDGE, 0UL);
++      eic_writel(eic, MODE, 0UL);
++      eic_writel(eic, EDGE, 0UL);
+-      sm->eim_chip = &eim_chip;
++      eic->chip = &eic_chip;
+       for (i = 0; i < nr_irqs; i++) {
+               /* NOTE the handler we set here is ignored by the demux */
+-              set_irq_chip_and_handler(sm->eim_first_irq + i, &eim_chip,
++              set_irq_chip_and_handler(eic->first_irq + i, &eic_chip,
+                                        handle_level_irq);
+-              set_irq_chip_data(sm->eim_first_irq + i, sm);
++              set_irq_chip_data(eic->first_irq + i, eic);
+       }
  
--      /*
--       * Send a sigbus, regardless of whether we were in kernel or
--       * user mode.
--       */
--      /* address, error_code, trap_no, ... */
--#ifdef DEBUG
--      show_regs(regs);
--      dump_code(regs->pc);
--#endif
--      pr_debug("Sending SIGBUS to PID %d...\n", tsk->pid);
--      force_sig(SIGBUS, tsk);
+-      int_irq = platform_get_irq_byname(sm->pdev, "eim");
 -
-       /* Kernel mode? Handle exceptions or die */
-+      signr = SIGBUS;
-+      code = BUS_ADRERR;
-       if (!user_mode(regs))
-               goto no_context;
-+
-+      if (exception_trace)
-+              printk("%s%s[%d]: bus error at %08lx pc %08lx "
-+                     "sp %08lx ecr %lu\n",
-+                     is_init(tsk) ? KERN_EMERG : KERN_INFO,
-+                     tsk->comm, tsk->pid, address, regs->pc,
-+                     regs->sp, ecr);
-+
-+      _exception(SIGBUS, regs, BUS_ADRERR, address);
- }
+-      set_irq_chained_handler(int_irq, demux_eim_irq);
+-      set_irq_data(int_irq, sm);
++      set_irq_chained_handler(int_irq, demux_eic_irq);
++      set_irq_data(int_irq, eic);
  
- asmlinkage void do_bus_error(unsigned long addr, int write_access,
-@@ -292,8 +247,7 @@
-              addr, write_access ? "write" : "read");
-       printk(KERN_INFO "DTLB dump:\n");
-       dump_dtlb();
--      die("Bus Error", regs, write_access);
--      do_exit(SIGKILL);
-+      die("Bus Error", regs, SIGKILL);
- }
+-      printk("EIM: External Interrupt Module at 0x%p, IRQ %u\n",
+-             sm->regs, int_irq);
+-      printk("EIM: Handling %u external IRQs, starting with IRQ %u\n",
+-             nr_irqs, sm->eim_first_irq);
++      dev_info(&pdev->dev,
++               "External Interrupt Controller at 0x%p, IRQ %u\n",
++               eic->regs, int_irq);
++      dev_info(&pdev->dev,
++               "Handling %u external IRQs, starting with IRQ %u\n",
++               nr_irqs, eic->first_irq);
  
- /*
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mm/init.c avr32-git/arch/avr32/mm/init.c
---- linux-2.6.21.3/arch/avr32/mm/init.c        2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/arch/avr32/mm/init.c     2007-06-06 11:33:46.000000000 +0200
-@@ -10,11 +10,9 @@
- #include <linux/mm.h>
- #include <linux/swap.h>
- #include <linux/init.h>
--#include <linux/initrd.h>
- #include <linux/mmzone.h>
- #include <linux/bootmem.h>
- #include <linux/pagemap.h>
--#include <linux/pfn.h>
- #include <linux/nodemask.h>
- #include <asm/page.h>
-@@ -78,242 +76,6 @@
-       printk ("%d pages swap cached\n", cached);
+       return 0;
++
++err_ioremap:
++      kfree(eic);
++err_kzalloc:
++      return ret;
++}
++
++static struct platform_driver eic_driver = {
++      .driver = {
++              .name = "at32_eic",
++      },
++};
++
++static int __init eic_init(void)
++{
++      return platform_driver_probe(&eic_driver, eic_probe);
  }
--static void __init print_memory_map(const char *what,
--                                  struct tag_mem_range *mem)
--{
--      printk ("%s:\n", what);
--      for (; mem; mem = mem->next) {
--              printk ("  %08lx - %08lx\n",
--                      (unsigned long)mem->addr,
--                      (unsigned long)(mem->addr + mem->size));
--      }
--}
--
--#define MAX_LOWMEM    HIGHMEM_START
--#define MAX_LOWMEM_PFN        PFN_DOWN(MAX_LOWMEM)
--
--/*
-- * Sort a list of memory regions in-place by ascending address.
-- *
-- * We're using bubble sort because we only have singly linked lists
-- * with few elements.
-- */
--static void __init sort_mem_list(struct tag_mem_range **pmem)
--{
--      int done;
--      struct tag_mem_range **a, **b;
--
--      if (!*pmem)
--              return;
--
--      do {
--              done = 1;
--              a = pmem, b = &(*pmem)->next;
--              while (*b) {
--                      if ((*a)->addr > (*b)->addr) {
--                              struct tag_mem_range *tmp;
--                              tmp = (*b)->next;
--                              (*b)->next = *a;
--                              *a = *b;
--                              *b = tmp;
--                              done = 0;
--                      }
--                      a = &(*a)->next;
--                      b = &(*a)->next;
--              }
--      } while (!done);
--}
--
--/*
-- * Find a free memory region large enough for storing the
-- * bootmem bitmap.
-- */
--static unsigned long __init
--find_bootmap_pfn(const struct tag_mem_range *mem)
--{
--      unsigned long bootmap_pages, bootmap_len;
--      unsigned long node_pages = PFN_UP(mem->size);
--      unsigned long bootmap_addr = mem->addr;
--      struct tag_mem_range *reserved = mem_reserved;
--      struct tag_mem_range *ramdisk = mem_ramdisk;
--      unsigned long kern_start = virt_to_phys(_stext);
--      unsigned long kern_end = virt_to_phys(_end);
--
--      bootmap_pages = bootmem_bootmap_pages(node_pages);
--      bootmap_len = bootmap_pages << PAGE_SHIFT;
--
--      /*
--       * Find a large enough region without reserved pages for
--       * storing the bootmem bitmap. We can take advantage of the
--       * fact that all lists have been sorted.
--       *
--       * We have to check explicitly reserved regions as well as the
--       * kernel image and any RAMDISK images...
--       *
--       * Oh, and we have to make sure we don't overwrite the taglist
--       * since we're going to use it until the bootmem allocator is
--       * fully up and running.
--       */
--      while (1) {
--              if ((bootmap_addr < kern_end) &&
--                  ((bootmap_addr + bootmap_len) > kern_start))
--                      bootmap_addr = kern_end;
--
--              while (reserved &&
--                     (bootmap_addr >= (reserved->addr + reserved->size)))
--                      reserved = reserved->next;
--
--              if (reserved &&
--                  ((bootmap_addr + bootmap_len) >= reserved->addr)) {
--                      bootmap_addr = reserved->addr + reserved->size;
--                      continue;
--              }
--
--              while (ramdisk &&
--                     (bootmap_addr >= (ramdisk->addr + ramdisk->size)))
--                      ramdisk = ramdisk->next;
--
--              if (!ramdisk ||
--                  ((bootmap_addr + bootmap_len) < ramdisk->addr))
--                      break;
--
--              bootmap_addr = ramdisk->addr + ramdisk->size;
--      }
--
--      if ((PFN_UP(bootmap_addr) + bootmap_len) >= (mem->addr + mem->size))
--              return ~0UL;
--
--      return PFN_UP(bootmap_addr);
--}
--
--void __init setup_bootmem(void)
--{
--      unsigned bootmap_size;
--      unsigned long first_pfn, bootmap_pfn, pages;
--      unsigned long max_pfn, max_low_pfn;
--      unsigned long kern_start = virt_to_phys(_stext);
--      unsigned long kern_end = virt_to_phys(_end);
--      unsigned node = 0;
--      struct tag_mem_range *bank, *res;
--
--      sort_mem_list(&mem_phys);
--      sort_mem_list(&mem_reserved);
--
--      print_memory_map("Physical memory", mem_phys);
--      print_memory_map("Reserved memory", mem_reserved);
--
--      nodes_clear(node_online_map);
--
--      if (mem_ramdisk) {
--#ifdef CONFIG_BLK_DEV_INITRD
--              initrd_start = (unsigned long)__va(mem_ramdisk->addr);
--              initrd_end = initrd_start + mem_ramdisk->size;
--
--              print_memory_map("RAMDISK images", mem_ramdisk);
--              if (mem_ramdisk->next)
--                      printk(KERN_WARNING
--                             "Warning: Only the first RAMDISK image "
--                             "will be used\n");
--              sort_mem_list(&mem_ramdisk);
--#else
--              printk(KERN_WARNING "RAM disk image present, but "
--                     "no initrd support in kernel!\n");
--#endif
--      }
--
--      if (mem_phys->next)
--              printk(KERN_WARNING "Only using first memory bank\n");
--
--      for (bank = mem_phys; bank; bank = NULL) {
--              first_pfn = PFN_UP(bank->addr);
--              max_low_pfn = max_pfn = PFN_DOWN(bank->addr + bank->size);
--              bootmap_pfn = find_bootmap_pfn(bank);
--              if (bootmap_pfn > max_pfn)
--                      panic("No space for bootmem bitmap!\n");
--
--              if (max_low_pfn > MAX_LOWMEM_PFN) {
--                      max_low_pfn = MAX_LOWMEM_PFN;
--#ifndef CONFIG_HIGHMEM
--                      /*
--                       * Lowmem is memory that can be addressed
--                       * directly through P1/P2
--                       */
--                      printk(KERN_WARNING
--                             "Node %u: Only %ld MiB of memory will be used.\n",
--                             node, MAX_LOWMEM >> 20);
--                      printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
--#else
--#error HIGHMEM is not supported by AVR32 yet
--#endif
--              }
--
--              /* Initialize the boot-time allocator with low memory only. */
--              bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn,
--                                               first_pfn, max_low_pfn);
--
--              printk("Node %u: bdata = %p, bdata->node_bootmem_map = %p\n",
--                     node, NODE_DATA(node)->bdata,
--                     NODE_DATA(node)->bdata->node_bootmem_map);
--
--              /*
--               * Register fully available RAM pages with the bootmem
--               * allocator.
--               */
--              pages = max_low_pfn - first_pfn;
--              free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn),
--                                 PFN_PHYS(pages));
--
--              /*
--               * Reserve space for the kernel image (if present in
--               * this node)...
--               */
--              if ((kern_start >= PFN_PHYS(first_pfn)) &&
--                  (kern_start < PFN_PHYS(max_pfn))) {
--                      printk("Node %u: Kernel image %08lx - %08lx\n",
--                             node, kern_start, kern_end);
--                      reserve_bootmem_node(NODE_DATA(node), kern_start,
--                                           kern_end - kern_start);
--              }
--
--              /* ...the bootmem bitmap... */
--              reserve_bootmem_node(NODE_DATA(node),
--                                   PFN_PHYS(bootmap_pfn),
--                                   bootmap_size);
--
--              /* ...any RAMDISK images... */
--              for (res = mem_ramdisk; res; res = res->next) {
--                      if (res->addr > PFN_PHYS(max_pfn))
--                              break;
--
--                      if (res->addr >= PFN_PHYS(first_pfn)) {
--                              printk("Node %u: RAMDISK %08lx - %08lx\n",
--                                     node,
--                                     (unsigned long)res->addr,
--                                     (unsigned long)(res->addr + res->size));
--                              reserve_bootmem_node(NODE_DATA(node),
--                                                   res->addr, res->size);
--                      }
--              }
--
--              /* ...and any other reserved regions. */
--              for (res = mem_reserved; res; res = res->next) {
--                      if (res->addr > PFN_PHYS(max_pfn))
--                              break;
--
--                      if (res->addr >= PFN_PHYS(first_pfn)) {
--                              printk("Node %u: Reserved %08lx - %08lx\n",
--                                     node,
--                                     (unsigned long)res->addr,
--                                     (unsigned long)(res->addr + res->size));
--                              reserve_bootmem_node(NODE_DATA(node),
--                                                   res->addr, res->size);
--                      }
--              }
--
--              node_set_online(node);
--      }
--}
--
- /*
-  * paging_init() sets up the page tables
-  *
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/atmeltwi.h avr32-git/drivers/i2c/busses/atmeltwi.h
---- linux-2.6.21.3/drivers/i2c/busses/atmeltwi.h       1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/drivers/i2c/busses/atmeltwi.h    2007-06-06 11:33:51.000000000 +0200
-@@ -0,0 +1,117 @@
+-arch_initcall(eim_init);
++arch_initcall(eic_init);
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/gpio-dev.c linux-avr32.git/arch/avr32/mach-at32ap/gpio-dev.c
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/gpio-dev.c   1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/mach-at32ap/gpio-dev.c  2007-07-12 13:59:49.000000000 +0200
+@@ -0,0 +1,570 @@
 +/*
-+ * Register definitions for the Atmel Two-Wire Interface
++ * GPIO /dev and configfs interface
++ *
++ * Copyright (C) 2006-2007 Atmel Corporation
++ *
++ * 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.
 + */
++#include <linux/configfs.h>
++#include <linux/cdev.h>
++#include <linux/fs.h>
++#include <linux/interrupt.h>
++#include <linux/poll.h>
++#include <linux/uaccess.h>
++#include <linux/wait.h>
 +
-+#ifndef __ASM_AVR32_TWI_H__
-+#define __ASM_AVR32_TWI_H__
++#include <asm/gpio.h>
++#include <asm/arch/portmux.h>
 +
-+/* TWI register offsets */
-+#define TWI_CR                                        0x0000
-+#define TWI_MMR                                       0x0004
-+#define TWI_SMR                                       0x0008
-+#define TWI_IADR                              0x000c
-+#define TWI_CWGR                              0x0010
-+#define TWI_SR                                        0x0020
-+#define TWI_IER                                       0x0024
-+#define TWI_IDR                                       0x0028
-+#define TWI_IMR                                       0x002c
-+#define TWI_RHR                                       0x0030
-+#define TWI_THR                                       0x0034
++#define GPIO_DEV_MAX                  8
 +
-+/* Bitfields in CR */
-+#define TWI_START_OFFSET                      0
-+#define TWI_START_SIZE                                1
-+#define TWI_STOP_OFFSET                               1
-+#define TWI_STOP_SIZE                         1
-+#define TWI_MSEN_OFFSET                               2
-+#define TWI_MSEN_SIZE                         1
-+#define TWI_MSDIS_OFFSET                      3
-+#define TWI_MSDIS_SIZE                                1
-+#define TWI_SVEN_OFFSET                               4
-+#define TWI_SVEN_SIZE                         1
-+#define TWI_SVDIS_OFFSET                      5
-+#define TWI_SVDIS_SIZE                                1
-+#define TWI_SWRST_OFFSET                      7
-+#define TWI_SWRST_SIZE                                1
++static struct class *gpio_dev_class;
++static dev_t gpio_devt;
 +
-+/* Bitfields in MMR */
-+#define TWI_IADRSZ_OFFSET                     8
-+#define TWI_IADRSZ_SIZE                               2
-+#define TWI_MREAD_OFFSET                      12
-+#define TWI_MREAD_SIZE                                1
-+#define TWI_DADR_OFFSET                               16
-+#define TWI_DADR_SIZE                         7
++struct gpio_item {
++      spinlock_t lock;
 +
-+/* Bitfields in SMR */
-+#define TWI_SADR_OFFSET                               16
-+#define TWI_SADR_SIZE                         7
++      int enabled;
++      int initialized;
++      int port;
++      u32 pin_mask;
++      u32 oe_mask;
 +
-+/* Bitfields in IADR */
-+#define TWI_IADR_OFFSET                               0
-+#define TWI_IADR_SIZE                         24
++      /* Pin state last time we read it (for blocking reads) */
++      u32 pin_state;
++      int changed;
 +
-+/* Bitfields in CWGR */
-+#define TWI_CLDIV_OFFSET                      0
-+#define TWI_CLDIV_SIZE                                8
-+#define TWI_CHDIV_OFFSET                      8
-+#define TWI_CHDIV_SIZE                                8
-+#define TWI_CKDIV_OFFSET                      16
-+#define TWI_CKDIV_SIZE                                3
++      wait_queue_head_t change_wq;
++      struct fasync_struct *async_queue;
 +
-+/* Bitfields in SR */
-+#define TWI_TXCOMP_OFFSET                     0
-+#define TWI_TXCOMP_SIZE                               1
-+#define TWI_RXRDY_OFFSET                      1
-+#define TWI_RXRDY_SIZE                                1
-+#define TWI_TXRDY_OFFSET                      2
-+#define TWI_TXRDY_SIZE                                1
-+#define TWI_SVDIR_OFFSET                      3
-+#define TWI_SVDIR_SIZE                                1
-+#define TWI_SVACC_OFFSET                      4
-+#define TWI_SVACC_SIZE                                1
-+#define TWI_GCACC_OFFSET                      5
-+#define TWI_GCACC_SIZE                                1
-+#define TWI_OVRE_OFFSET                               6
-+#define TWI_OVRE_SIZE                         1
-+#define TWI_UNRE_OFFSET                               7
-+#define TWI_UNRE_SIZE                         1
-+#define TWI_NACK_OFFSET                               8
-+#define TWI_NACK_SIZE                         1
-+#define TWI_ARBLST_OFFSET                     9
-+#define TWI_ARBLST_SIZE                               1
++      int id;
++      struct class_device *gpio_dev;
++      struct cdev char_dev;
++      struct config_item item;
++};
 +
-+/* Bitfields in RHR */
-+#define TWI_RXDATA_OFFSET                     0
-+#define TWI_RXDATA_SIZE                               8
++struct gpio_attribute {
++      struct configfs_attribute attr;
++      ssize_t (*show)(struct gpio_item *, char *);
++      ssize_t (*store)(struct gpio_item *, const char *, size_t);
++};
 +
-+/* Bitfields in THR */
-+#define TWI_TXDATA_OFFSET                     0
-+#define TWI_TXDATA_SIZE                               8
++static irqreturn_t gpio_dev_interrupt(int irq, void *dev_id)
++{
++      struct gpio_item *gpio = dev_id;
++      u32 old_state, new_state;
 +
-+/* Constants for IADRSZ */
-+#define TWI_IADRSZ_NO_ADDR                    0
-+#define TWI_IADRSZ_ONE_BYTE                   1
-+#define TWI_IADRSZ_TWO_BYTES                  2
-+#define TWI_IADRSZ_THREE_BYTES                        3
++      old_state = gpio->pin_state;
++      new_state = at32_gpio_get_value_multiple(gpio->port, gpio->pin_mask);
++      gpio->pin_state = new_state;
 +
-+/* Bit manipulation macros */
-+#define TWI_BIT(name)                                 \
-+      (1 << TWI_##name##_OFFSET)
-+#define TWI_BF(name,value)                            \
-+      (((value) & ((1 << TWI_##name##_SIZE) - 1))     \
-+       << TWI_##name##_OFFSET)
-+#define TWI_BFEXT(name,value)                         \
-+      (((value) >> TWI_##name##_OFFSET)               \
-+       & ((1 << TWI_##name##_SIZE) - 1))
-+#define TWI_BFINS(name,value,old)                     \
-+      (((old) & ~(((1 << TWI_##name##_SIZE) - 1)      \
-+                  << TWI_##name##_OFFSET))            \
-+       | TWI_BF(name,value))
++      if (new_state != old_state) {
++              gpio->changed = 1;
++              wake_up_interruptible(&gpio->change_wq);
 +
-+/* Register access macros */
-+#define twi_readl(port,reg)                           \
-+      __raw_readl((port)->regs + TWI_##reg)
-+#define twi_writel(port,reg,value)                    \
-+      __raw_writel((value), (port)->regs + TWI_##reg)
++              if (gpio->async_queue)
++                      kill_fasync(&gpio->async_queue, SIGIO, POLL_IN);
++      }
 +
-+#endif /* __ASM_AVR32_TWI_H__ */
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/i2c-atmeltwi.c avr32-git/drivers/i2c/busses/i2c-atmeltwi.c
---- linux-2.6.21.3/drivers/i2c/busses/i2c-atmeltwi.c   1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/drivers/i2c/busses/i2c-atmeltwi.c        2007-06-06 11:33:51.000000000 +0200
-@@ -0,0 +1,348 @@
-+/*
-+ * i2c Support for Atmel's Two-Wire Interface (TWI)
-+ *
-+ * Based on the work of Copyright (C) 2004 Rick Bronson
-+ * Converted to 2.6 by Andrew Victor <andrew at sanpeople.com>
-+ * Ported to AVR32 and heavily modified by Espen Krangnes <ekrangnes at atmel.com>
-+ *
-+ * Copyright (C) 2006 Atmel Corporation
-+ *
-+ * Borrowed heavily from the original work by:
-+ * Copyright (C) 2000 Philip Edelbrock <phil at stimpy.netroedge.com>
-+ *
-+ * 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.
-+ */
++      return IRQ_HANDLED;
++}
 +
++static int gpio_dev_open(struct inode *inode, struct file *file)
++{
++      struct gpio_item *gpio = container_of(inode->i_cdev,
++                                            struct gpio_item,
++                                            char_dev);
++      unsigned int irq;
++      unsigned int i;
++      int ret;
 +
-+#include <linux/err.h>
-+#include <linux/module.h>
-+#include <linux/kernel.h>
-+#include <linux/slab.h>
-+#include <linux/types.h>
-+#include <linux/delay.h>
-+#include <linux/i2c.h>
-+#include <linux/init.h>
-+#include <linux/clk.h>
-+#include <linux/interrupt.h>
-+#include <linux/irq.h>
-+#include <linux/platform_device.h>
-+#include <linux/completion.h>
-+#include <asm/io.h>
-+#include <linux/time.h>
-+#include "atmeltwi.h"
++      nonseekable_open(inode, file);
++      config_item_get(&gpio->item);
++      file->private_data = gpio;
++
++      gpio->pin_state = at32_gpio_get_value_multiple(gpio->port,
++                                                     gpio->pin_mask);
++      gpio->changed = 1;
++
++      for (i = 0; i < 32; i++) {
++              if (gpio->pin_mask & (1 << i)) {
++                      irq = gpio_to_irq(32 * gpio->port + i);
++                      ret = request_irq(irq, gpio_dev_interrupt, 0,
++                                        "gpio-dev", gpio);
++                      if (ret)
++                              goto err_irq;
++              }
++      }
 +
-+static unsigned int baudrate = CONFIG_I2C_ATMELTWI_BAUDRATE;
-+module_param(baudrate, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
-+MODULE_PARM_DESC(baudrate, "The TWI baudrate");
++      return 0;
 +
++err_irq:
++      while (i--) {
++              if (gpio->pin_mask & (1 << i)) {
++                      irq = gpio_to_irq(32 * gpio->port + i);
++                      free_irq(irq, gpio);
++              }
++      }
 +
-+struct atmel_twi {
-+      void __iomem *regs;
-+      struct i2c_adapter adapter;
-+      struct clk *pclk;
-+      spinlock_t lock;
-+      struct completion comp;
-+      u32 intmask;
-+      u8 *buf;
-+      u8 len;
-+      u8 acks_left;
-+      unsigned int irq;
++      config_item_put(&gpio->item);
 +
-+};
-+#define to_atmel_twi(adap) container_of(adap, struct atmel_twi, adapter)
++      return ret;
++}
 +
-+/*
-+ * Initialize the TWI hardware registers.
-+ */
-+static int __devinit twi_hwinit(struct atmel_twi *twi)
++static int gpio_dev_fasync(int fd, struct file *file, int mode)
 +{
-+      unsigned long cdiv, ckdiv=0;
++      struct gpio_item *gpio = file->private_data;
 +
-+      twi_writel(twi, IDR, ~0UL);
-+      twi_writel(twi, CR, TWI_BIT(SWRST));    /*Reset peripheral*/
-+      twi_readl(twi, SR);
++      return fasync_helper(fd, file, mode, &gpio->async_queue);
++}
 +
-+      cdiv = (clk_get_rate(twi->pclk) / (2 * baudrate)) - 4;
++static int gpio_dev_release(struct inode *inode, struct file *file)
++{
++      struct gpio_item *gpio = file->private_data;
++      unsigned int irq;
++      unsigned int i;
 +
-+      while (cdiv > 255) {
-+              ckdiv++;
-+              cdiv = cdiv >> 1;
++      gpio_dev_fasync(-1, file, 0);
++
++      for (i = 0; i < 32; i++) {
++              if (gpio->pin_mask & (1 << i)) {
++                      irq = gpio_to_irq(32 * gpio->port + i);
++                      free_irq(irq, gpio);
++              }
 +      }
 +
-+      if (ckdiv > 7)
-+              return -EINVAL;
-+      else
-+              twi_writel(twi, CWGR, (TWI_BF(CKDIV, ckdiv)
-+                             | TWI_BF(CHDIV, cdiv)
-+                             | TWI_BF(CLDIV, cdiv)));
++      config_item_put(&gpio->item);
++
 +      return 0;
 +}
 +
-+/*
-+ * Waits for the i2c status register to set the specified bitmask
-+ * Returns 0 if timed out (~100ms).
-+ */
-+static short twi_wait_for_completion(struct atmel_twi *twi,
-+              u32 mask)
++static unsigned int gpio_dev_poll(struct file *file, poll_table *wait)
 +{
-+      int timeout = msecs_to_jiffies(100);
-+
-+      twi->intmask = mask;
-+      init_completion(&twi->comp);
-+
-+      twi_writel(twi, IER, mask);
++      struct gpio_item *gpio = file->private_data;
++      unsigned int mask = 0;
 +
-+      if(!wait_for_completion_timeout(&twi->comp, timeout))
-+              return -ETIMEDOUT;
++      poll_wait(file, &gpio->change_wq, wait);
++      if (gpio->changed)
++              mask |= POLLIN | POLLRDNORM;
 +
-+      return 0;
++      return mask;
 +}
 +
-+/*
-+ * Generic i2c master transfer entrypoint.
-+ */
-+static int twi_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
++static ssize_t gpio_dev_read(struct file *file, char __user *buf,
++                           size_t count, loff_t *offset)
 +{
-+      struct atmel_twi *twi = to_atmel_twi(adap);
-+      struct i2c_msg *pmsg;
-+      int i;
++      struct gpio_item *gpio = file->private_data;
++      u32 value;
 +
-+      /* get first message */
-+      pmsg = msgs;
++      spin_lock_irq(&gpio->lock);
++      while (!gpio->changed) {
++              spin_unlock_irq(&gpio->lock);
 +
-+      dev_dbg(&adap->dev, "twi_xfer: processing %d messages:\n", num);
++              if (file->f_flags & O_NONBLOCK)
++                      return -EAGAIN;
 +
-+      for (i = 0; i < num; i++, pmsg++) {
++              if (wait_event_interruptible(gpio->change_wq, gpio->changed))
++                      return -ERESTARTSYS;
 +
-+              twi->len = pmsg->len;
-+              twi->buf = pmsg->buf;
-+              twi->acks_left = pmsg->len;
-+              twi_writel(twi, MMR, TWI_BF(DADR, pmsg->addr) |
-+                      (pmsg->flags & I2C_M_RD ? TWI_BIT(MREAD) : 0));
-+              twi_writel(twi, IADR, TWI_BF(IADR, pmsg->addr));
++              spin_lock_irq(&gpio->lock);
++      }
 +
-+              dev_dbg(&adap->dev,"#%d: internal addr %d %s byte%s %s 0x%02x\n",
-+                      i,pmsg->len, pmsg->flags & I2C_M_RD ? "reading" : "writing",
-+                      pmsg->len > 1 ? "s" : "",
-+                      pmsg->flags & I2C_M_RD ? "from" : "to", pmsg->addr);
++      gpio->changed = 0;
++      value = at32_gpio_get_value_multiple(gpio->port, gpio->pin_mask);
 +
-+              /* enable */
-+              twi_writel(twi, CR, TWI_BIT(MSEN));
++      spin_unlock_irq(&gpio->lock);
 +
-+              if (pmsg->flags & I2C_M_RD) {
-+                      twi_writel(twi, CR, TWI_BIT(START));
-+                      if ( twi_wait_for_completion(twi,TWI_BIT(RXRDY))==-ETIMEDOUT ) {
-+                              dev_dbg(&adap->dev, "RXRDY timeout. Stopped with %d bytes left\n",
-+                                      twi->acks_left);
-+                              return -ETIMEDOUT;
-+                      }
++      count = min(count, (size_t)4);
++      if (copy_to_user(buf, &value, count))
++              return -EFAULT;
 +
-+                      /* Send Stop, and Wait until transfer is finished */
-+                      if ( twi_wait_for_completion(twi,TWI_BIT(TXCOMP))==-ETIMEDOUT ) {
-+                              dev_dbg(&adap->dev, "TXCOMP timeout\n");
-+                              return -ETIMEDOUT;
-+                      }
++      return count;
++}
 +
-+              } else {
-+                      twi_writel(twi, THR, twi->buf[0]);
-+                      if ( twi_wait_for_completion(twi,TWI_BIT(TXRDY))==-ETIMEDOUT ) {
-+                              dev_dbg(&adap->dev, "TXRDY timeout. Stopped with %d bytes left\n",
-+                              twi->acks_left);
-+                              return -ETIMEDOUT;
-+                      }
-+              }
++static ssize_t gpio_dev_write(struct file *file, const char __user *buf,
++                            size_t count, loff_t *offset)
++{
++      struct gpio_item *gpio = file->private_data;
++      u32 value = 0;
++      u32 mask = ~0UL;
 +
-+              /* Disable TWI interface */
-+              twi_writel(twi, CR, TWI_BIT(MSDIS));
++      count = min(count, (size_t)4);
++      if (copy_from_user(&value, buf, count))
++              return -EFAULT;
 +
-+      } /* end cur msg */
++      /* Assuming big endian */
++      mask <<= (4 - count) * 8;
++      mask &= gpio->pin_mask;
 +
-+      return i;
++      at32_gpio_set_value_multiple(gpio->port, value, mask);
++
++      return count;
 +}
 +
++static struct file_operations gpio_dev_fops = {
++      .owner          = THIS_MODULE,
++      .llseek         = no_llseek,
++      .open           = gpio_dev_open,
++      .release        = gpio_dev_release,
++      .fasync         = gpio_dev_fasync,
++      .poll           = gpio_dev_poll,
++      .read           = gpio_dev_read,
++      .write          = gpio_dev_write,
++};
 +
-+static irqreturn_t twi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
++static struct gpio_item *to_gpio_item(struct config_item *item)
 +{
-+      struct atmel_twi *twi = dev_id;
-+      int status = twi_readl(twi, SR);
++      return item ? container_of(item, struct gpio_item, item) : NULL;
++}
 +
-+      if (twi->intmask & status){
-+              if (twi->intmask & TWI_BIT(NACK)) {
-+                      goto nack;
-+              } else if (twi->intmask & TWI_BIT(RXRDY)){
-+                      twi->buf[twi->len - twi->acks_left] = twi_readl(twi,RHR);
-+                      if(--twi->acks_left==1)
-+                              twi_writel(twi, CR, TWI_BIT(STOP));
-+                      if (twi->acks_left==0)
-+                              goto complete;
-+              } else if (twi->intmask & TWI_BIT(TXRDY)) {
-+                      twi->acks_left--;
-+                      if (twi->acks_left==0) {
-+                              twi->intmask = TWI_BIT(TXCOMP);
-+                              twi_writel(twi, IER, TWI_BIT(TXCOMP));
-+                      } else
-+                              twi_writel(twi, THR, twi->buf[twi->len - twi->acks_left]);
-+              } else if (twi->intmask & TWI_BIT(TXCOMP)) {
-+                      goto complete;
++static ssize_t gpio_show_gpio_id(struct gpio_item *gpio, char *page)
++{
++      return sprintf(page, "%d\n", gpio->port);
++}
++
++static ssize_t gpio_store_gpio_id(struct gpio_item *gpio,
++                                const char *page, size_t count)
++{
++      unsigned long id;
++      char *p = (char *)page;
++      ssize_t ret = -EINVAL;
++
++      id = simple_strtoul(p, &p, 0);
++      if (!p || (*p && (*p != '\n')))
++              return -EINVAL;
++
++      /* Switching PIO is not allowed when live... */
++      spin_lock(&gpio->lock);
++      if (!gpio->enabled) {
++              ret = -ENXIO;
++              if (at32_gpio_port_is_valid(id)) {
++                      gpio->port = id;
++                      ret = count;
 +              }
 +      }
++      spin_unlock(&gpio->lock);
 +
-+      return IRQ_HANDLED;
++      return ret;
++}
 +
-+nack:
-+      printk(KERN_INFO "NACK received!\n");
++static ssize_t gpio_show_pin_mask(struct gpio_item *gpio, char *page)
++{
++      return sprintf(page, "0x%08x\n", gpio->pin_mask);
++}
 +
-+complete:
-+      twi_writel(twi, IDR, ~0UL);
-+      complete(&twi->comp);
++static ssize_t gpio_store_pin_mask(struct gpio_item *gpio,
++                                 const char *page, size_t count)
++{
++      u32 new_mask;
++      char *p = (char *)page;
++      ssize_t ret = -EINVAL;
 +
-+      return IRQ_HANDLED;
++      new_mask = simple_strtoul(p, &p, 0);
++      if (!p || (*p && (*p != '\n')))
++              return -EINVAL;
 +
-+}
++      /* Can't update the pin mask while live. */
++      spin_lock(&gpio->lock);
++      if (!gpio->enabled) {
++              gpio->oe_mask &= new_mask;
++              gpio->pin_mask = new_mask;
++              ret = count;
++      }
++      spin_unlock(&gpio->lock);
 +
++      return ret;
++}
 +
-+/*
-+ * Return list of supported functionality.
-+ */
-+static u32 twi_func(struct i2c_adapter *adapter)
++static ssize_t gpio_show_oe_mask(struct gpio_item *gpio, char *page)
 +{
-+      return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
++      return sprintf(page, "0x%08x\n", gpio->oe_mask);
 +}
 +
-+/* For now, we only handle combined mode (smbus) */
-+static struct i2c_algorithm twi_algorithm = {
-+      .master_xfer    = twi_xfer,
-+      .functionality  = twi_func,
-+};
-+
-+/*
-+ * Main initialization routine.
-+ */
-+static int __devinit twi_probe(struct platform_device *pdev)
++static ssize_t gpio_store_oe_mask(struct gpio_item *gpio,
++                                const char *page, size_t count)
 +{
-+      struct atmel_twi *twi;
-+      struct resource *regs;
-+      struct clk *pclk;
-+      struct i2c_adapter *adapter;
-+      int rc, irq;
++      u32 mask;
++      char *p = (char *)page;
++      ssize_t ret = -EINVAL;
 +
-+      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-+      if (!regs)
-+              return -ENXIO;
-+
-+      pclk = clk_get(&pdev->dev, "pclk");
-+      if (IS_ERR(pclk))
-+              return PTR_ERR(pclk);
-+      clk_enable(pclk);
++      mask = simple_strtoul(p, &p, 0);
++      if (!p || (*p && (*p != '\n')))
++              return -EINVAL;
 +
-+      rc = -ENOMEM;
-+      twi = kzalloc(sizeof(struct atmel_twi), GFP_KERNEL);
-+      if (!twi) {
-+              dev_err(&pdev->dev, "can't allocate interface!\n");
-+              goto err_alloc_twi;
++      spin_lock(&gpio->lock);
++      if (!gpio->enabled) {
++              gpio->oe_mask = mask & gpio->pin_mask;
++              ret = count;
 +      }
++      spin_unlock(&gpio->lock);
 +
-+      twi->pclk = pclk;
-+      twi->regs = ioremap(regs->start, regs->end - regs->start + 1);
-+      if (!twi->regs)
-+              goto err_ioremap;
++      return ret;
++}
 +
-+      irq = platform_get_irq(pdev,0);
-+      rc = request_irq(irq, twi_interrupt, 0, "twi", twi);
-+      if (rc) {
-+              dev_err(&pdev->dev, "can't bind irq!\n");
-+              goto err_irq;
-+      }
-+      twi->irq = irq;
++static ssize_t gpio_show_enabled(struct gpio_item *gpio, char *page)
++{
++      return sprintf(page, "%d\n", gpio->enabled);
++}
 +
-+      rc = twi_hwinit(twi);
-+      if (rc) {
-+              dev_err(&pdev->dev, "Unable to set baudrate\n");
-+              goto err_hw_init;
-+      }
++static ssize_t gpio_store_enabled(struct gpio_item *gpio,
++                                const char *page, size_t count)
++{
++      char *p = (char *)page;
++      int enabled;
++      int ret;
 +
-+      adapter = &twi->adapter;
-+      sprintf(adapter->name, "TWI");
-+      adapter->algo = &twi_algorithm;
-+      adapter->class = I2C_CLASS_HWMON;
-+      adapter->dev.parent = &pdev->dev;
++      enabled = simple_strtoul(p, &p, 0);
++      if (!p || (*p && (*p != '\n')))
++              return -EINVAL;
 +
-+      platform_set_drvdata(pdev, twi);
++      /* make it a boolean value */
++      enabled = !!enabled;
 +
-+      rc = i2c_add_adapter(adapter);
-+      if (rc) {
-+              dev_err(&pdev->dev, "Adapter %s registration failed\n",
-+                      adapter->name);
-+              goto err_register;
++      if (gpio->enabled == enabled)
++              /* No change; do nothing. */
++              return count;
++
++      BUG_ON(gpio->id >= GPIO_DEV_MAX);
++
++      if (!enabled) {
++              class_device_unregister(gpio->gpio_dev);
++              cdev_del(&gpio->char_dev);
++              at32_deselect_pins(gpio->port, gpio->pin_mask);
++              gpio->initialized = 0;
++      } else {
++              if (gpio->port < 0 || !gpio->pin_mask)
++                      return -ENODEV;
 +      }
 +
-+      dev_info(&pdev->dev, "Atmel TWI i2c bus device (baudrate %dk) at 0x%08lx.\n",
-+               baudrate/1000, (unsigned long)regs->start);
++      /* Disallow any updates to gpio_id or pin_mask */
++      spin_lock(&gpio->lock);
++      gpio->enabled = enabled;
++      spin_unlock(&gpio->lock);
 +
-+      return 0;
++      if (!enabled)
++              return count;
 +
++      /* Now, try to allocate the pins */
++      ret = at32_select_gpio_pins(gpio->port, gpio->pin_mask, gpio->oe_mask);
++      if (ret)
++              goto err_alloc_pins;
 +
-+err_register:
-+      platform_set_drvdata(pdev, NULL);
++      gpio->initialized = 1;
 +
-+err_hw_init:
-+      free_irq(irq, twi);
++      cdev_init(&gpio->char_dev, &gpio_dev_fops);
++      gpio->char_dev.owner = THIS_MODULE;
++      ret = cdev_add(&gpio->char_dev, MKDEV(MAJOR(gpio_devt), gpio->id), 1);
++      if (ret < 0)
++              goto err_cdev_add;
++      gpio->gpio_dev = class_device_create(gpio_dev_class, NULL,
++                                           MKDEV(MAJOR(gpio_devt), gpio->id),
++                                           NULL,
++                                           "gpio%d", gpio->id);
++      if (IS_ERR(gpio->gpio_dev)) {
++              printk(KERN_ERR "failed to create gpio%d\n", gpio->id);
++              ret = PTR_ERR(gpio->gpio_dev);
++              goto err_class_dev;
++      }
 +
-+err_irq:
-+      iounmap(twi->regs);
++      printk(KERN_INFO "created gpio%d (port%d/0x%08x) as (%d:%d)\n",
++             gpio->id, gpio->port, gpio->pin_mask,
++             MAJOR(gpio->gpio_dev->devt), MINOR(gpio->gpio_dev->devt));
 +
-+err_ioremap:
-+      kfree(twi);
++      return 0;
 +
-+err_alloc_twi:
-+      clk_disable(pclk);
-+      clk_put(pclk);
++err_class_dev:
++      cdev_del(&gpio->char_dev);
++err_cdev_add:
++      at32_deselect_pins(gpio->port, gpio->pin_mask);
++      gpio->initialized = 0;
++err_alloc_pins:
++      spin_lock(&gpio->lock);
++      gpio->enabled = 0;
++      spin_unlock(&gpio->lock);
 +
-+      return rc;
++      return ret;
 +}
 +
-+static int __devexit twi_remove(struct platform_device *pdev)
++static struct gpio_attribute gpio_item_attr_gpio_id = {
++      .attr = {
++              .ca_owner = THIS_MODULE,
++              .ca_name = "gpio_id",
++              .ca_mode = S_IRUGO | S_IWUSR,
++      },
++      .show = gpio_show_gpio_id,
++      .store = gpio_store_gpio_id,
++};
++static struct gpio_attribute gpio_item_attr_pin_mask = {
++      .attr = {
++              .ca_owner = THIS_MODULE,
++              .ca_name = "pin_mask",
++              .ca_mode = S_IRUGO | S_IWUSR,
++      },
++      .show = gpio_show_pin_mask,
++      .store = gpio_store_pin_mask,
++};
++static struct gpio_attribute gpio_item_attr_oe_mask = {
++      .attr = {
++              .ca_owner = THIS_MODULE,
++              .ca_name = "oe_mask",
++              .ca_mode = S_IRUGO | S_IWUSR,
++      },
++      .show = gpio_show_oe_mask,
++      .store = gpio_store_oe_mask,
++};
++static struct gpio_attribute gpio_item_attr_enabled = {
++      .attr = {
++              .ca_owner = THIS_MODULE,
++              .ca_name = "enabled",
++              .ca_mode = S_IRUGO | S_IWUSR,
++      },
++      .show = gpio_show_enabled,
++      .store = gpio_store_enabled,
++};
++
++static struct configfs_attribute *gpio_item_attrs[] = {
++      &gpio_item_attr_gpio_id.attr,
++      &gpio_item_attr_pin_mask.attr,
++      &gpio_item_attr_oe_mask.attr,
++      &gpio_item_attr_enabled.attr,
++      NULL,
++};
++
++static ssize_t gpio_show_attr(struct config_item *item,
++                            struct configfs_attribute *attr,
++                            char *page)
 +{
-+      struct atmel_twi *twi = platform_get_drvdata(pdev);
-+      int res;
++      struct gpio_item *gpio_item = to_gpio_item(item);
++      struct gpio_attribute *gpio_attr
++              = container_of(attr, struct gpio_attribute, attr);
++      ssize_t ret = 0;
 +
-+      platform_set_drvdata(pdev, NULL);
-+      res = i2c_del_adapter(&twi->adapter);
-+      twi_writel(twi, CR, TWI_BIT(MSDIS));
-+      iounmap(twi->regs);
-+      clk_disable(twi->pclk);
-+      clk_put(twi->pclk);
-+      free_irq(twi->irq, twi);
-+      kfree(twi);
++      if (gpio_attr->show)
++              ret = gpio_attr->show(gpio_item, page);
++      return ret;
++}
 +
-+      return res;
++static ssize_t gpio_store_attr(struct config_item *item,
++                             struct configfs_attribute *attr,
++                             const char *page, size_t count)
++{
++      struct gpio_item *gpio_item = to_gpio_item(item);
++      struct gpio_attribute *gpio_attr
++              = container_of(attr, struct gpio_attribute, attr);
++      ssize_t ret = -EINVAL;
++
++      if (gpio_attr->store)
++              ret = gpio_attr->store(gpio_item, page, count);
++      return ret;
 +}
 +
-+static struct platform_driver twi_driver = {
-+      .probe          = twi_probe,
-+      .remove         = __devexit_p(twi_remove),
-+      .driver         = {
-+              .name   = "atmel_twi",
-+              .owner  = THIS_MODULE,
++static void gpio_release(struct config_item *item)
++{
++      kfree(to_gpio_item(item));
++}
++
++static struct configfs_item_operations gpio_item_ops = {
++      .release                = gpio_release,
++      .show_attribute         = gpio_show_attr,
++      .store_attribute        = gpio_store_attr,
++};
++
++static struct config_item_type gpio_item_type = {
++      .ct_item_ops    = &gpio_item_ops,
++      .ct_attrs       = gpio_item_attrs,
++      .ct_owner       = THIS_MODULE,
++};
++
++static struct config_item *gpio_make_item(struct config_group *group,
++                                        const char *name)
++{
++      static int next_id;
++      struct gpio_item *gpio;
++
++      if (next_id >= GPIO_DEV_MAX)
++              return NULL;
++
++      gpio = kzalloc(sizeof(struct gpio_item), GFP_KERNEL);
++      if (!gpio)
++              return NULL;
++
++      gpio->id = next_id++;
++      config_item_init_type_name(&gpio->item, name, &gpio_item_type);
++      spin_lock_init(&gpio->lock);
++      init_waitqueue_head(&gpio->change_wq);
++
++      return &gpio->item;
++}
++
++static void gpio_drop_item(struct config_group *group,
++                         struct config_item *item)
++{
++      struct gpio_item *gpio = to_gpio_item(item);
++
++      spin_lock(&gpio->lock);
++      if (gpio->enabled) {
++              class_device_unregister(gpio->gpio_dev);
++              cdev_del(&gpio->char_dev);
++      }
++
++      if (gpio->initialized) {
++              at32_deselect_pins(gpio->port, gpio->pin_mask);
++              gpio->initialized = 0;
++              gpio->enabled = 0;
++      }
++      spin_unlock(&gpio->lock);
++}
++
++static struct configfs_group_operations gpio_group_ops = {
++      .make_item      = gpio_make_item,
++      .drop_item      = gpio_drop_item,
++};
++
++static struct config_item_type gpio_group_type = {
++      .ct_group_ops   = &gpio_group_ops,
++      .ct_owner       = THIS_MODULE,
++};
++
++static struct configfs_subsystem gpio_subsys = {
++      .su_group = {
++              .cg_item = {
++                       .ci_namebuf = "gpio",
++                       .ci_type = &gpio_group_type,
++               },
 +      },
 +};
 +
-+static int __init atmel_twi_init(void)
++static int __init gpio_dev_init(void)
 +{
-+      return platform_driver_register(&twi_driver);
++      int err;
++
++      gpio_dev_class = class_create(THIS_MODULE, "gpio-dev");
++      if (IS_ERR(gpio_dev_class)) {
++              err = PTR_ERR(gpio_dev_class);
++              goto err_class_create;
++      }
++
++      err = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpio");
++      if (err < 0)
++              goto err_alloc_chrdev;
++
++      /* Configfs initialization */
++      config_group_init(&gpio_subsys.su_group);
++      init_MUTEX(&gpio_subsys.su_sem);
++      err = configfs_register_subsystem(&gpio_subsys);
++      if (err)
++              goto err_register_subsys;
++
++      return 0;
++
++err_register_subsys:
++      unregister_chrdev_region(gpio_devt, GPIO_DEV_MAX);
++err_alloc_chrdev:
++      class_destroy(gpio_dev_class);
++err_class_create:
++      printk(KERN_WARNING "Failed to initialize gpio /dev interface\n");
++      return err;
 +}
++late_initcall(gpio_dev_init);
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/Kconfig linux-avr32.git/arch/avr32/mach-at32ap/Kconfig
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/Kconfig      2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/Kconfig     2007-07-12 13:59:49.000000000 +0200
+@@ -26,6 +26,13 @@
+ endchoice
++config GPIO_DEV
++      bool "GPIO /dev interface"
++      select CONFIGFS_FS
++      default n
++      help
++        Say `Y' to enable a /dev interface to the GPIO pins.
 +
-+static void __exit atmel_twi_exit(void)
+ endmenu
+ endif # PLATFORM_AT32AP
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/Makefile linux-avr32.git/arch/avr32/mach-at32ap/Makefile
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/Makefile     2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/Makefile    2007-07-12 13:59:49.000000000 +0200
+@@ -1,3 +1,5 @@
+ obj-y                         += at32ap.o clock.o intc.o extint.o pio.o hsmc.o
+ obj-$(CONFIG_CPU_AT32AP7000)  += at32ap7000.o
+ obj-$(CONFIG_CPU_AT32AP7000)  += time-tc.o
++obj-$(CONFIG_CPU_FREQ_AT32AP) += cpufreq.o
++obj-$(CONFIG_GPIO_DEV)                += gpio-dev.o
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/pio.c linux-avr32.git/arch/avr32/mach-at32ap/pio.c
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/pio.c        2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/pio.c       2007-07-12 13:59:49.000000000 +0200
+@@ -158,6 +158,82 @@
+       dump_stack();
+ }
++#ifdef CONFIG_GPIO_DEV
++
++/* Gang allocators and accessors; used by the GPIO /dev driver */
++int at32_gpio_port_is_valid(unsigned int port)
 +{
-+      platform_driver_unregister(&twi_driver);
++      return port < MAX_NR_PIO_DEVICES && pio_dev[port].regs != NULL;
 +}
 +
-+module_init(atmel_twi_init);
-+module_exit(atmel_twi_exit);
++int at32_select_gpio_pins(unsigned int port, u32 pins, u32 oe_mask)
++{
++      struct pio_device *pio;
++      u32 old, new;
 +
-+MODULE_AUTHOR("Espen Krangnes");
-+MODULE_DESCRIPTION("I2C driver for Atmel TWI");
-+MODULE_LICENSE("GPL");
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/i2c-gpio.c avr32-git/drivers/i2c/busses/i2c-gpio.c
---- linux-2.6.21.3/drivers/i2c/busses/i2c-gpio.c       1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/drivers/i2c/busses/i2c-gpio.c    2007-06-06 11:33:51.000000000 +0200
-@@ -0,0 +1,215 @@
++      pio = &pio_dev[port];
++      BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs || (oe_mask & ~pins));
++
++      /* Try to allocate the pins */
++      do {
++              old = pio->pinmux_mask;
++              if (old & pins)
++                      return -EBUSY;
++
++              new = old | pins;
++      } while (cmpxchg(&pio->pinmux_mask, old, new) != old);
++
++      /* That went well, now configure the port */
++      pio_writel(pio, OER, oe_mask);
++      pio_writel(pio, PER, pins);
++
++      return 0;
++}
++
++void at32_deselect_pins(unsigned int port, u32 pins)
++{
++      struct pio_device *pio;
++      u32 old, new;
++
++      pio = &pio_dev[port];
++      BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs);
++
++      /* Return to a "safe" mux configuration */
++      pio_writel(pio, PUER, pins);
++      pio_writel(pio, ODR, pins);
++
++      /* Deallocate the pins */
++      do {
++              old = pio->pinmux_mask;
++              new = old & ~pins;
++      } while (cmpxchg(&pio->pinmux_mask, old, new) != old);
++}
++
++u32 at32_gpio_get_value_multiple(unsigned int port, u32 pins)
++{
++      struct pio_device *pio;
++
++      pio = &pio_dev[port];
++      BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs);
++
++      return pio_readl(pio, PDSR) & pins;
++}
++
++void at32_gpio_set_value_multiple(unsigned int port, u32 value, u32 mask)
++{
++      struct pio_device *pio;
++
++      pio = &pio_dev[port];
++      BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs);
++
++      /* No atomic updates for now... */
++      pio_writel(pio, CODR, ~value & mask);
++      pio_writel(pio, SODR, value & mask);
++}
++
++#endif /* CONFIG_GPIO_DEV */
++
++
+ /*--------------------------------------------------------------------------*/
+ /* GPIO API */
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/pm.h linux-avr32.git/arch/avr32/mach-at32ap/pm.h
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/pm.h 1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/arch/avr32/mach-at32ap/pm.h        2007-07-12 13:59:49.000000000 +0200
+@@ -0,0 +1,112 @@
++/*
++ * Register definitions for the Power Manager (PM)
++ */
++#ifndef __ARCH_AVR32_MACH_AT32AP_PM_H__
++#define __ARCH_AVR32_MACH_AT32AP_PM_H__
++
++/* PM register offsets */
++#define PM_MCCTRL                             0x0000
++#define PM_CKSEL                              0x0004
++#define PM_CPU_MASK                           0x0008
++#define PM_HSB_MASK                           0x000c
++#define PM_PBA_MASK                           0x0010
++#define PM_PBB_MASK                           0x0014
++#define PM_PLL0                                       0x0020
++#define PM_PLL1                                       0x0024
++#define PM_IER                                        0x0040
++#define PM_IDR                                        0x0044
++#define PM_IMR                                        0x0048
++#define PM_ISR                                        0x004c
++#define PM_ICR                                        0x0050
++#define PM_GCCTRL(x)                          (0x0060 + 4 * (x))
++#define PM_RCAUSE                             0x00c0
++
++/* Bitfields in CKSEL */
++#define PM_CPUSEL_OFFSET                      0
++#define PM_CPUSEL_SIZE                                3
++#define PM_CPUDIV_OFFSET                      7
++#define PM_CPUDIV_SIZE                                1
++#define PM_HSBSEL_OFFSET                      8
++#define PM_HSBSEL_SIZE                                3
++#define PM_HSBDIV_OFFSET                      15
++#define PM_HSBDIV_SIZE                                1
++#define PM_PBASEL_OFFSET                      16
++#define PM_PBASEL_SIZE                                3
++#define PM_PBADIV_OFFSET                      23
++#define PM_PBADIV_SIZE                                1
++#define PM_PBBSEL_OFFSET                      24
++#define PM_PBBSEL_SIZE                                3
++#define PM_PBBDIV_OFFSET                      31
++#define PM_PBBDIV_SIZE                                1
++
++/* Bitfields in PLL0 */
++#define PM_PLLEN_OFFSET                               0
++#define PM_PLLEN_SIZE                         1
++#define PM_PLLOSC_OFFSET                      1
++#define PM_PLLOSC_SIZE                                1
++#define PM_PLLOPT_OFFSET                      2
++#define PM_PLLOPT_SIZE                                3
++#define PM_PLLDIV_OFFSET                      8
++#define PM_PLLDIV_SIZE                                8
++#define PM_PLLMUL_OFFSET                      16
++#define PM_PLLMUL_SIZE                                8
++#define PM_PLLCOUNT_OFFSET                    24
++#define PM_PLLCOUNT_SIZE                      6
++#define PM_PLLTEST_OFFSET                     31
++#define PM_PLLTEST_SIZE                               1
++
++/* Bitfields in ICR */
++#define PM_LOCK0_OFFSET                               0
++#define PM_LOCK0_SIZE                         1
++#define PM_LOCK1_OFFSET                               1
++#define PM_LOCK1_SIZE                         1
++#define PM_WAKE_OFFSET                                2
++#define PM_WAKE_SIZE                          1
++#define PM_CKRDY_OFFSET                               5
++#define PM_CKRDY_SIZE                         1
++#define PM_MSKRDY_OFFSET                      6
++#define PM_MSKRDY_SIZE                                1
++
++/* Bitfields in GCCTRL0 */
++#define PM_OSCSEL_OFFSET                      0
++#define PM_OSCSEL_SIZE                                1
++#define PM_PLLSEL_OFFSET                      1
++#define PM_PLLSEL_SIZE                                1
++#define PM_CEN_OFFSET                         2
++#define PM_CEN_SIZE                           1
++#define PM_DIVEN_OFFSET                               4
++#define PM_DIVEN_SIZE                         1
++#define PM_DIV_OFFSET                         8
++#define PM_DIV_SIZE                           8
++
++/* Bitfields in RCAUSE */
++#define PM_POR_OFFSET                         0
++#define PM_POR_SIZE                           1
++#define PM_EXT_OFFSET                         2
++#define PM_EXT_SIZE                           1
++#define PM_WDT_OFFSET                         3
++#define PM_WDT_SIZE                           1
++#define PM_NTAE_OFFSET                                4
++#define PM_NTAE_SIZE                          1
++
++/* Bit manipulation macros */
++#define PM_BIT(name)                                  \
++      (1 << PM_##name##_OFFSET)
++#define PM_BF(name,value)                             \
++      (((value) & ((1 << PM_##name##_SIZE) - 1))      \
++       << PM_##name##_OFFSET)
++#define PM_BFEXT(name,value)                          \
++      (((value) >> PM_##name##_OFFSET)                \
++       & ((1 << PM_##name##_SIZE) - 1))
++#define PM_BFINS(name,value,old)\
++      (((old) & ~(((1 << PM_##name##_SIZE) - 1)       \
++                  << PM_##name##_OFFSET))             \
++       | PM_BF(name,value))
++
++/* Register access macros */
++#define pm_readl(reg)                                                 \
++      __raw_readl((void __iomem *)AT32_PM_BASE + PM_##reg)
++#define pm_writel(reg,value)                                          \
++      __raw_writel((value), (void __iomem *)AT32_PM_BASE + PM_##reg)
++
++#endif /* __ARCH_AVR32_MACH_AT32AP_PM_H__ */
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/sm.h linux-avr32.git/arch/avr32/mach-at32ap/sm.h
+--- linux-2.6.22.1/arch/avr32/mach-at32ap/sm.h 2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mach-at32ap/sm.h        1970-01-01 01:00:00.000000000 +0100
+@@ -1,242 +0,0 @@
+-/*
+- * Register definitions for SM
+- *
+- * System Manager
+- */
+-#ifndef __ASM_AVR32_SM_H__
+-#define __ASM_AVR32_SM_H__
+-
+-/* SM register offsets */
+-#define SM_PM_MCCTRL                            0x0000
+-#define SM_PM_CKSEL                             0x0004
+-#define SM_PM_CPU_MASK                          0x0008
+-#define SM_PM_HSB_MASK                          0x000c
+-#define SM_PM_PBA_MASK                         0x0010
+-#define SM_PM_PBB_MASK                         0x0014
+-#define SM_PM_PLL0                              0x0020
+-#define SM_PM_PLL1                              0x0024
+-#define SM_PM_VCTRL                             0x0030
+-#define SM_PM_VMREF                             0x0034
+-#define SM_PM_VMV                               0x0038
+-#define SM_PM_IER                               0x0040
+-#define SM_PM_IDR                               0x0044
+-#define SM_PM_IMR                               0x0048
+-#define SM_PM_ISR                               0x004c
+-#define SM_PM_ICR                               0x0050
+-#define SM_PM_GCCTRL                            0x0060
+-#define SM_RTC_CTRL                             0x0080
+-#define SM_RTC_VAL                              0x0084
+-#define SM_RTC_TOP                              0x0088
+-#define SM_RTC_IER                              0x0090
+-#define SM_RTC_IDR                              0x0094
+-#define SM_RTC_IMR                              0x0098
+-#define SM_RTC_ISR                              0x009c
+-#define SM_RTC_ICR                              0x00a0
+-#define SM_WDT_CTRL                             0x00b0
+-#define SM_WDT_CLR                              0x00b4
+-#define SM_WDT_EXT                              0x00b8
+-#define SM_RC_RCAUSE                            0x00c0
+-#define SM_EIM_IER                              0x0100
+-#define SM_EIM_IDR                              0x0104
+-#define SM_EIM_IMR                              0x0108
+-#define SM_EIM_ISR                              0x010c
+-#define SM_EIM_ICR                              0x0110
+-#define SM_EIM_MODE                             0x0114
+-#define SM_EIM_EDGE                             0x0118
+-#define SM_EIM_LEVEL                            0x011c
+-#define SM_EIM_TEST                             0x0120
+-#define SM_EIM_NMIC                             0x0124
+-
+-/* Bitfields in PM_MCCTRL */
+-
+-/* Bitfields in PM_CKSEL */
+-#define SM_CPUSEL_OFFSET                        0
+-#define SM_CPUSEL_SIZE                          3
+-#define SM_CPUDIV_OFFSET                        7
+-#define SM_CPUDIV_SIZE                          1
+-#define SM_HSBSEL_OFFSET                        8
+-#define SM_HSBSEL_SIZE                          3
+-#define SM_HSBDIV_OFFSET                        15
+-#define SM_HSBDIV_SIZE                          1
+-#define SM_PBASEL_OFFSET                       16
+-#define SM_PBASEL_SIZE                         3
+-#define SM_PBADIV_OFFSET                       23
+-#define SM_PBADIV_SIZE                         1
+-#define SM_PBBSEL_OFFSET                       24
+-#define SM_PBBSEL_SIZE                         3
+-#define SM_PBBDIV_OFFSET                       31
+-#define SM_PBBDIV_SIZE                         1
+-
+-/* Bitfields in PM_CPU_MASK */
+-
+-/* Bitfields in PM_HSB_MASK */
+-
+-/* Bitfields in PM_PBA_MASK */
+-
+-/* Bitfields in PM_PBB_MASK */
+-
+-/* Bitfields in PM_PLL0 */
+-#define SM_PLLEN_OFFSET                         0
+-#define SM_PLLEN_SIZE                           1
+-#define SM_PLLOSC_OFFSET                        1
+-#define SM_PLLOSC_SIZE                          1
+-#define SM_PLLOPT_OFFSET                        2
+-#define SM_PLLOPT_SIZE                          3
+-#define SM_PLLDIV_OFFSET                        8
+-#define SM_PLLDIV_SIZE                          8
+-#define SM_PLLMUL_OFFSET                        16
+-#define SM_PLLMUL_SIZE                          8
+-#define SM_PLLCOUNT_OFFSET                      24
+-#define SM_PLLCOUNT_SIZE                        6
+-#define SM_PLLTEST_OFFSET                       31
+-#define SM_PLLTEST_SIZE                         1
+-
+-/* Bitfields in PM_PLL1 */
+-
+-/* Bitfields in PM_VCTRL */
+-#define SM_VAUTO_OFFSET                         0
+-#define SM_VAUTO_SIZE                           1
+-#define SM_PM_VCTRL_VAL_OFFSET                  8
+-#define SM_PM_VCTRL_VAL_SIZE                    7
+-
+-/* Bitfields in PM_VMREF */
+-#define SM_REFSEL_OFFSET                        0
+-#define SM_REFSEL_SIZE                          4
+-
+-/* Bitfields in PM_VMV */
+-#define SM_PM_VMV_VAL_OFFSET                    0
+-#define SM_PM_VMV_VAL_SIZE                      8
+-
+-/* Bitfields in PM_IER */
+-
+-/* Bitfields in PM_IDR */
+-
+-/* Bitfields in PM_IMR */
+-
+-/* Bitfields in PM_ISR */
+-
+-/* Bitfields in PM_ICR */
+-#define SM_LOCK0_OFFSET                         0
+-#define SM_LOCK0_SIZE                           1
+-#define SM_LOCK1_OFFSET                         1
+-#define SM_LOCK1_SIZE                           1
+-#define SM_WAKE_OFFSET                          2
+-#define SM_WAKE_SIZE                            1
+-#define SM_VOK_OFFSET                           3
+-#define SM_VOK_SIZE                             1
+-#define SM_VMRDY_OFFSET                         4
+-#define SM_VMRDY_SIZE                           1
+-#define SM_CKRDY_OFFSET                         5
+-#define SM_CKRDY_SIZE                           1
+-
+-/* Bitfields in PM_GCCTRL */
+-#define SM_OSCSEL_OFFSET                        0
+-#define SM_OSCSEL_SIZE                          1
+-#define SM_PLLSEL_OFFSET                        1
+-#define SM_PLLSEL_SIZE                          1
+-#define SM_CEN_OFFSET                           2
+-#define SM_CEN_SIZE                             1
+-#define SM_CPC_OFFSET                           3
+-#define SM_CPC_SIZE                             1
+-#define SM_DIVEN_OFFSET                         4
+-#define SM_DIVEN_SIZE                           1
+-#define SM_DIV_OFFSET                           8
+-#define SM_DIV_SIZE                             8
+-
+-/* Bitfields in RTC_CTRL */
+-#define SM_PCLR_OFFSET                          1
+-#define SM_PCLR_SIZE                            1
+-#define SM_TOPEN_OFFSET                         2
+-#define SM_TOPEN_SIZE                           1
+-#define SM_CLKEN_OFFSET                         3
+-#define SM_CLKEN_SIZE                           1
+-#define SM_PSEL_OFFSET                          8
+-#define SM_PSEL_SIZE                            16
+-
+-/* Bitfields in RTC_VAL */
+-#define SM_RTC_VAL_VAL_OFFSET                   0
+-#define SM_RTC_VAL_VAL_SIZE                     31
+-
+-/* Bitfields in RTC_TOP */
+-#define SM_RTC_TOP_VAL_OFFSET                   0
+-#define SM_RTC_TOP_VAL_SIZE                     32
+-
+-/* Bitfields in RTC_IER */
+-
+-/* Bitfields in RTC_IDR */
+-
+-/* Bitfields in RTC_IMR */
+-
+-/* Bitfields in RTC_ISR */
+-
+-/* Bitfields in RTC_ICR */
+-#define SM_TOPI_OFFSET                          0
+-#define SM_TOPI_SIZE                            1
+-
+-/* Bitfields in WDT_CTRL */
+-#define SM_KEY_OFFSET                           24
+-#define SM_KEY_SIZE                             8
+-
+-/* Bitfields in WDT_CLR */
+-
+-/* Bitfields in WDT_EXT */
+-
+-/* Bitfields in RC_RCAUSE */
+-#define SM_POR_OFFSET                           0
+-#define SM_POR_SIZE                             1
+-#define SM_BOD_OFFSET                           1
+-#define SM_BOD_SIZE                             1
+-#define SM_EXT_OFFSET                           2
+-#define SM_EXT_SIZE                             1
+-#define SM_WDT_OFFSET                           3
+-#define SM_WDT_SIZE                             1
+-#define SM_NTAE_OFFSET                          4
+-#define SM_NTAE_SIZE                            1
+-#define SM_SERP_OFFSET                          5
+-#define SM_SERP_SIZE                            1
+-
+-/* Bitfields in EIM_IER */
+-
+-/* Bitfields in EIM_IDR */
+-
+-/* Bitfields in EIM_IMR */
+-
+-/* Bitfields in EIM_ISR */
+-
+-/* Bitfields in EIM_ICR */
+-
+-/* Bitfields in EIM_MODE */
+-
+-/* Bitfields in EIM_EDGE */
+-#define SM_INT0_OFFSET                          0
+-#define SM_INT0_SIZE                            1
+-#define SM_INT1_OFFSET                          1
+-#define SM_INT1_SIZE                            1
+-#define SM_INT2_OFFSET                          2
+-#define SM_INT2_SIZE                            1
+-#define SM_INT3_OFFSET                          3
+-#define SM_INT3_SIZE                            1
+-
+-/* Bitfields in EIM_LEVEL */
+-
+-/* Bitfields in EIM_TEST */
+-#define SM_TESTEN_OFFSET                        31
+-#define SM_TESTEN_SIZE                          1
+-
+-/* Bitfields in EIM_NMIC */
+-#define SM_EN_OFFSET                            0
+-#define SM_EN_SIZE                              1
+-
+-/* Bit manipulation macros */
+-#define SM_BIT(name)                            (1 << SM_##name##_OFFSET)
+-#define SM_BF(name,value)                       (((value) & ((1 << SM_##name##_SIZE) - 1)) << SM_##name##_OFFSET)
+-#define SM_BFEXT(name,value)                    (((value) >> SM_##name##_OFFSET) & ((1 << SM_##name##_SIZE) - 1))
+-#define SM_BFINS(name,value,old)                (((old) & ~(((1 << SM_##name##_SIZE) - 1) << SM_##name##_OFFSET)) | SM_BF(name,value))
+-
+-/* Register access macros */
+-#define sm_readl(port,reg)                                    \
+-      __raw_readl((port)->regs + SM_##reg)
+-#define sm_writel(port,reg,value)                             \
+-      __raw_writel((value), (port)->regs + SM_##reg)
+-
+-#endif /* __ASM_AVR32_SM_H__ */
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/Makefile linux-avr32.git/arch/avr32/Makefile
+--- linux-2.6.22.1/arch/avr32/Makefile 2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/Makefile        2007-06-06 11:33:46.000000000 +0200
+@@ -31,6 +31,7 @@
+ core-$(CONFIG_LOADER_U_BOOT)          += arch/avr32/boot/u-boot/
+ core-y                                        += arch/avr32/kernel/
+ core-y                                        += arch/avr32/mm/
++drivers-y                             += arch/avr32/drivers/
+ libs-y                                        += arch/avr32/lib/
+ archincdir-$(CONFIG_PLATFORM_AT32AP)  := arch-at32ap
+diff -x .git -Nur linux-2.6.22.1/arch/avr32/mm/dma-coherent.c linux-avr32.git/arch/avr32/mm/dma-coherent.c
+--- linux-2.6.22.1/arch/avr32/mm/dma-coherent.c        2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/arch/avr32/mm/dma-coherent.c       2007-07-12 13:59:49.000000000 +0200
+@@ -41,6 +41,13 @@
+       struct page *page, *free, *end;
+       int order;
++      /* Following is a work-around (a.k.a. hack) to prevent pages
++       * with __GFP_COMP being passed to split_page() which cannot
++       * handle them.  The real problem is that this flag probably
++       * should be 0 on AVR32 as it is not supported on this
++       * platform--see CONFIG_HUGETLB_PAGE. */
++      gfp &= ~(__GFP_COMP);
++
+       size = PAGE_ALIGN(size);
+       order = get_order(size);
+diff -x .git -Nur linux-2.6.22.1/drivers/char/watchdog/at32ap700x_wdt.c linux-avr32.git/drivers/char/watchdog/at32ap700x_wdt.c
+--- linux-2.6.22.1/drivers/char/watchdog/at32ap700x_wdt.c      1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/drivers/char/watchdog/at32ap700x_wdt.c     2007-07-12 13:59:59.000000000 +0200
+@@ -0,0 +1,325 @@
 +/*
-+ * Bitbanging I2C bus driver using the GPIO API
++ * Watchdog driver for Atmel AT32AP700X devices
 + *
-+ * Copyright (C) 2007 Atmel Corporation
++ * Copyright (C) 2005-2006 Atmel Corporation
 + *
 + * 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.
 + */
-+#include <linux/i2c.h>
-+#include <linux/i2c-algo-bit.h>
-+#include <linux/i2c-gpio.h>
++
 +#include <linux/init.h>
++#include <linux/kernel.h>
 +#include <linux/module.h>
++#include <linux/moduleparam.h>
++#include <linux/miscdevice.h>
++#include <linux/fs.h>
 +#include <linux/platform_device.h>
++#include <linux/watchdog.h>
++#include <linux/uaccess.h>
++#include <linux/io.h>
 +
-+#include <asm/gpio.h>
++#define TIMEOUT_MIN           1
++#define TIMEOUT_DEFAULT               CONFIG_AT32AP700X_WDT_TIMEOUT
++#define TIMEOUT_MAX           2
 +
-+/* Toggle SDA by changing the direction of the pin */
-+static void i2c_gpio_setsda_dir(void *data, int state)
-+{
-+      struct i2c_gpio_platform_data *pdata = data;
++/* Watchdog registers and write/read macro */
++#define       WDT_CTRL                0x00
++#define WDT_CTRL_EN              0
++#define WDT_CTRL_PSEL            8
++#define WDT_CTRL_KEY            24
 +
-+      if (state)
-+              gpio_direction_input(pdata->sda_pin);
-+      else
-+              gpio_direction_output(pdata->sda_pin, 0);
-+}
++#define WDT_CLR                       0x04
++
++#define WDT_BIT(name)         (1 << WDT_##name)
++#define WDT_BF(name,value)    ((value) << WDT_##name)
++
++#define wdt_readl(dev,reg)                            \
++      __raw_readl((dev)->regs + WDT_##reg)
++#define wdt_writel(dev,reg,value)                     \
++      __raw_writel((value), (dev)->regs + WDT_##reg)
++
++struct wdt_at32ap700x {
++      void __iomem            *regs;
++      int                     timeout;
++      int                     users;
++      struct miscdevice       miscdev;
++};
++
++static struct wdt_at32ap700x *wdt;
 +
 +/*
-+ * Toggle SDA by changing the output value of the pin. This is only
-+ * valid for pins configured as open drain (i.e. setting the value
-+ * high effectively turns off the output driver.)
++ * Disable the watchdog.
 + */
-+static void i2c_gpio_setsda_val(void *data, int state)
++static void inline at32_wdt_stop(void)
 +{
-+      struct i2c_gpio_platform_data *pdata = data;
-+
-+      gpio_set_value(pdata->sda_pin, state);
++      unsigned long psel = wdt_readl(wdt, CTRL) & WDT_BF(CTRL_PSEL, 0x0f);
++      wdt_writel(wdt, CTRL, psel | WDT_BF(CTRL_KEY, 0x55));
++      wdt_writel(wdt, CTRL, psel | WDT_BF(CTRL_KEY, 0xaa));
 +}
 +
-+/* Toggle SCL by changing the direction of the pin. */
-+static void i2c_gpio_setscl_dir(void *data, int state)
++/*
++ * Enable and reset the watchdog.
++ */
++static void inline at32_wdt_start(void)
 +{
-+      struct i2c_gpio_platform_data *pdata = data;
++      /* 0xf is 2^16 divider = 2 sec, 0xe is 2^15 divider = 1 sec */
++      unsigned long psel = (wdt->timeout > 1) ? 0xf : 0xe;
 +
-+      if (state)
-+              gpio_direction_input(pdata->scl_pin);
-+      else
-+              gpio_direction_output(pdata->scl_pin, 0);
++      wdt_writel(wdt, CTRL, WDT_BIT(CTRL_EN)
++                      | WDT_BF(CTRL_PSEL, psel)
++                      | WDT_BF(CTRL_KEY, 0x55));
++      wdt_writel(wdt, CTRL, WDT_BIT(CTRL_EN)
++                      | WDT_BF(CTRL_PSEL, psel)
++                      | WDT_BF(CTRL_KEY, 0xaa));
 +}
 +
 +/*
-+ * Toggle SCL by changing the output value of the pin. This is used
-+ * for pins that are configured as open drain and for output-only
-+ * pins. The latter case will break the i2c protocol, but it will
-+ * often work in practice.
++ * Pat the watchdog timer.
 + */
-+static void i2c_gpio_setscl_val(void *data, int state)
++static void inline at32_wdt_pat(void)
 +{
-+      struct i2c_gpio_platform_data *pdata = data;
-+
-+      gpio_set_value(pdata->scl_pin, state);
++      wdt_writel(wdt, CLR, 0x42);
 +}
 +
-+int i2c_gpio_getsda(void *data)
++/*
++ * Watchdog device is opened, and watchdog starts running.
++ */
++static int at32_wdt_open(struct inode *inode, struct file *file)
 +{
-+      struct i2c_gpio_platform_data *pdata = data;
++      if (test_and_set_bit(1, &wdt->users))
++              return -EBUSY;
 +
-+      return gpio_get_value(pdata->sda_pin);
++      at32_wdt_start();
++      return nonseekable_open(inode, file);
 +}
 +
-+int i2c_gpio_getscl(void *data)
++/*
++ * Close the watchdog device. If CONFIG_WATCHDOG_NOWAYOUT is _not_ defined then
++ * the watchdog is also disabled.
++ */
++static int at32_wdt_close(struct inode *inode, struct file *file)
 +{
-+      struct i2c_gpio_platform_data *pdata = data;
-+
-+      return gpio_get_value(pdata->scl_pin);
++#ifndef CONFIG_WATCHDOG_NOWAYOUT
++      at32_wdt_stop();
++#endif
++      clear_bit(1, &wdt->users);
++      return 0;
 +}
 +
-+static int __init i2c_gpio_probe(struct platform_device *pdev)
++/*
++ * Change the watchdog time interval.
++ */
++static int at32_wdt_settimeout(int time)
 +{
-+      struct i2c_gpio_platform_data *pdata;
-+      struct i2c_algo_bit_data *bit_data;
-+      struct i2c_adapter *adap;
-+      int ret;
++      /*
++       * All counting occurs at 1 / SLOW_CLOCK (32 kHz) and max prescaler is
++       * 2 ^ 16 allowing up to 2 seconds timeout.
++       */
++      if ((time < TIMEOUT_MIN) || (time > TIMEOUT_MAX))
++              return -EINVAL;
 +
-+      pdata = pdev->dev.platform_data;
-+      if (!pdata)
-+              return -ENXIO;
++      /*
++       * Set new watchdog time. It will be used when at32_wdt_start() is
++       * called.
++       */
++      wdt->timeout = time;
++      return 0;
++}
 +
-+      ret = -ENOMEM;
-+      adap = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL);
-+      if (!adap)
-+              goto err_alloc_adap;
-+      bit_data = kzalloc(sizeof(struct i2c_algo_bit_data), GFP_KERNEL);
-+      if (!bit_data)
-+              goto err_alloc_bit_data;
-+
-+      ret = gpio_request(pdata->sda_pin, "sda");
-+      if (ret)
-+              goto err_request_sda;
-+      ret = gpio_request(pdata->scl_pin, "scl");
-+      if (ret)
-+              goto err_request_scl;
++static struct watchdog_info at32_wdt_info = {
++      .identity       = "at32ap700x watchdog",
++      .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
++};
 +
-+      if (pdata->sda_is_open_drain) {
-+              gpio_direction_output(pdata->sda_pin, 1);
-+              bit_data->setsda = i2c_gpio_setsda_val;
-+      } else {
-+              gpio_direction_input(pdata->sda_pin);
-+              bit_data->setsda = i2c_gpio_setsda_dir;
++/*
++ * Handle commands from user-space.
++ */
++static int at32_wdt_ioctl(struct inode *inode, struct file *file,
++              unsigned int cmd, unsigned long arg)
++{
++      int ret = -ENOTTY;
++      int time;
++      void __user *argp = (void __user *)arg;
++      int __user *p = argp;
++
++      switch (cmd) {
++      case WDIOC_KEEPALIVE:
++              at32_wdt_pat();
++              ret = 0;
++              break;
++      case WDIOC_GETSUPPORT:
++              ret = copy_to_user(argp, &at32_wdt_info,
++                              sizeof(at32_wdt_info)) ? -EFAULT : 0;
++              break;
++      case WDIOC_SETTIMEOUT:
++              ret = get_user(time, p);
++              if (ret)
++                      break;
++              ret = at32_wdt_settimeout(time);
++              if (ret)
++                      break;
++              /* Enable new time value */
++              at32_wdt_start();
++              /* fall through */
++      case WDIOC_GETTIMEOUT:
++              ret = put_user(wdt->timeout, p);
++              break;
++      case WDIOC_GETSTATUS: /* fall through */
++      case WDIOC_GETBOOTSTATUS:
++              ret = put_user(0, p);
++              break;
++      case WDIOC_SETOPTIONS:
++              ret = get_user(time, p);
++              if (ret)
++                      break;
++              if (time & WDIOS_DISABLECARD)
++                      at32_wdt_stop();
++              if (time & WDIOS_ENABLECARD)
++                      at32_wdt_start();
++              ret = 0;
++              break;
 +      }
 +
-+      if (pdata->scl_is_open_drain || pdata->scl_is_output_only) {
-+              gpio_direction_output(pdata->scl_pin, 1);
-+              bit_data->setscl = i2c_gpio_setscl_val;
-+      } else {
-+              gpio_direction_input(pdata->scl_pin);
-+              bit_data->setscl = i2c_gpio_setscl_dir;
-+      }
++      return ret;
++}
 +
-+      if (!pdata->scl_is_output_only)
-+              bit_data->getscl = i2c_gpio_getscl;
-+      bit_data->getsda = i2c_gpio_getsda;
++static ssize_t at32_wdt_write(struct file *file, const char *data, size_t len,
++                              loff_t *ppos)
++{
++      at32_wdt_pat();
++      return len;
++}
 +
-+      if (pdata->udelay)
-+              bit_data->udelay = pdata->udelay;
-+      else if (pdata->scl_is_output_only)
-+              bit_data->udelay = 50;                  /* 10 kHz */
-+      else
-+              bit_data->udelay = 5;                   /* 100 kHz */
++static const struct file_operations at32_wdt_fops = {
++      .owner          = THIS_MODULE,
++      .llseek         = no_llseek,
++      .ioctl          = at32_wdt_ioctl,
++      .open           = at32_wdt_open,
++      .release        = at32_wdt_close,
++      .write          = at32_wdt_write,
++};
 +
-+      if (pdata->timeout)
-+              bit_data->timeout = pdata->timeout;
-+      else
-+              bit_data->timeout = HZ / 10;            /* 100 ms */
++static int __init at32_wdt_probe(struct platform_device *pdev)
++{
++      struct resource *regs;
++      int ret;
++
++      if (wdt) {
++              dev_dbg(&pdev->dev, "only 1 wdt instance supported.\n");
++              return -EBUSY;
++      }
 +
-+      bit_data->data = pdata;
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      if (!regs) {
++              dev_dbg(&pdev->dev, "missing mmio resource\n");
++              return -ENXIO;
++      }
 +
-+      adap->owner = THIS_MODULE;
-+      snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);
-+      adap->algo_data = bit_data;
-+      adap->dev.parent = &pdev->dev;
++      wdt = kzalloc(sizeof(struct wdt_at32ap700x), GFP_KERNEL);
++      if (!wdt) {
++              dev_dbg(&pdev->dev, "no memory for wdt structure\n");
++              return -ENOMEM;
++      }
 +
-+      ret = i2c_bit_add_bus(adap);
-+      if (ret)
-+              goto err_add_bus;
++      wdt->regs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!wdt->regs) {
++              ret = -ENOMEM;
++              dev_dbg(&pdev->dev, "could not map I/O memory\n");
++              goto err_free;
++      }
++      wdt->users = 0;
++      wdt->miscdev.minor = WATCHDOG_MINOR;
++      wdt->miscdev.name = "watchdog";
++      wdt->miscdev.fops = &at32_wdt_fops;
++
++      if (at32_wdt_settimeout(TIMEOUT_DEFAULT)) {
++              at32_wdt_settimeout(TIMEOUT_MAX);
++              dev_dbg(&pdev->dev,
++                      "default timeout invalid, set to %d sec.\n",
++                      TIMEOUT_MAX);
++      }
 +
-+      platform_set_drvdata(pdev, adap);
++      ret = misc_register(&wdt->miscdev);
++      if (ret) {
++              dev_dbg(&pdev->dev, "failed to register wdt miscdev\n");
++              goto err_iounmap;
++      }
 +
-+      dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",
-+               pdata->sda_pin, pdata->scl_pin,
-+               pdata->scl_is_output_only
-+               ? ", no clock stretching" : "");
++      platform_set_drvdata(pdev, wdt);
++      wdt->miscdev.parent = &pdev->dev;
++      dev_info(&pdev->dev, "AT32AP700X WDT at 0x%p\n", wdt->regs);
 +
 +      return 0;
 +
-+err_add_bus:
-+      gpio_free(pdata->scl_pin);
-+err_request_scl:
-+      gpio_free(pdata->sda_pin);
-+err_request_sda:
-+      kfree(bit_data);
-+err_alloc_bit_data:
-+      kfree(adap);
-+err_alloc_adap:
++err_iounmap:
++      iounmap(wdt->regs);
++err_free:
++      kfree(wdt);
++      wdt = NULL;
 +      return ret;
 +}
 +
-+static int __exit i2c_gpio_remove(struct platform_device *pdev)
++static int __exit at32_wdt_remove(struct platform_device *pdev)
 +{
-+      struct i2c_gpio_platform_data *pdata;
-+      struct i2c_adapter *adap;
++      if (wdt && platform_get_drvdata(pdev) == wdt) {
++              misc_deregister(&wdt->miscdev);
++              iounmap(wdt->regs);
++              kfree(wdt);
++              wdt = NULL;
++              platform_set_drvdata(pdev, NULL);
++      }
 +
-+      adap = platform_get_drvdata(pdev);
-+      pdata = pdev->dev.platform_data;
++      return 0;
++}
++
++static void at32_wdt_shutdown(struct platform_device *pdev)
++{
++      at32_wdt_stop();
++}
 +
-+      i2c_del_adapter(adap);
-+      gpio_free(pdata->scl_pin);
-+      gpio_free(pdata->sda_pin);
-+      kfree(adap->algo_data);
-+      kfree(adap);
++#ifdef CONFIG_PM
++static int at32_wdt_suspend(struct platform_device *pdev, pm_message_t message)
++{
++      at32_wdt_stop();
++      return 0;
++}
 +
++static int at32_wdt_resume(struct platform_device *pdev)
++{
++      if (wdt->users)
++              at32_wdt_start();
 +      return 0;
 +}
++#else
++#define at32_wdt_suspend NULL
++#define at32_wdt_resume NULL
++#endif
 +
-+static struct platform_driver i2c_gpio_driver = {
++static struct platform_driver at32_wdt_driver = {
++      .remove         = __exit_p(at32_wdt_remove),
++      .suspend        = at32_wdt_suspend,
++      .resume         = at32_wdt_resume,
 +      .driver         = {
-+              .name   = "i2c-gpio",
++              .name   = "at32_wdt",
 +              .owner  = THIS_MODULE,
 +      },
-+      .remove         = __exit_p(i2c_gpio_remove),
++      .shutdown       = at32_wdt_shutdown,
 +};
 +
-+static int __init i2c_gpio_init(void)
++static int __init at32_wdt_init(void)
 +{
-+      int ret;
-+
-+      ret = platform_driver_probe(&i2c_gpio_driver, i2c_gpio_probe);
-+      if (ret)
-+              printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);
-+
-+      return ret;
++      return platform_driver_probe(&at32_wdt_driver, at32_wdt_probe);
 +}
-+module_init(i2c_gpio_init);
++module_init(at32_wdt_init);
 +
-+static void __exit i2c_gpio_exit(void)
++static void __exit at32_wdt_exit(void)
 +{
-+      platform_driver_unregister(&i2c_gpio_driver);
++      platform_driver_unregister(&at32_wdt_driver);
 +}
-+module_exit(i2c_gpio_exit);
++module_exit(at32_wdt_exit);
 +
-+MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>");
-+MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver");
++MODULE_AUTHOR("Hans-Christian Egtvedt <hcegtvedt@atmel.com>");
++MODULE_DESCRIPTION("Watchdog driver for Atmel AT32AP700X");
 +MODULE_LICENSE("GPL");
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/Kconfig avr32-git/drivers/i2c/busses/Kconfig
---- linux-2.6.21.3/drivers/i2c/busses/Kconfig  2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/drivers/i2c/busses/Kconfig       2007-06-06 11:33:51.000000000 +0200
-@@ -5,6 +5,26 @@
- menu "I2C Hardware Bus support"
-       depends on I2C
++MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+diff -x .git -Nur linux-2.6.22.1/drivers/char/watchdog/Kconfig linux-avr32.git/drivers/char/watchdog/Kconfig
+--- linux-2.6.22.1/drivers/char/watchdog/Kconfig       2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/drivers/char/watchdog/Kconfig      2007-07-12 13:59:59.000000000 +0200
+@@ -187,6 +187,26 @@
  
-+config I2C_ATMELTWI
-+      tristate "Atmel TWI/I2C"
-+      depends on I2C
-+      help
-+        Atmel on-chip TWI controller. Say Y if you have an AT32 or
-+        AT91-based device and want to use its built-in TWI
-+        functionality. Atmel's TWI is compatible with Philips' I2C
-+        protocol. If in doubt, say NO
+         Say N if you are unsure.
++# AVR32 Architecture
 +
-+config I2C_ATMELTWI_BAUDRATE
-+      prompt "Atmel TWI baudrate"
-+      depends on I2C_ATMELTWI
-+      int
-+      default 100000
++config AT32AP700X_WDT
++      tristate "AT32AP700x watchdog"
++      depends on WATCHDOG && CPU_AT32AP7000
 +      help
-+        Set the TWI/I2C baudrate. This will alter the default value. A
-+        different baudrate can be set by using a module parameter as well. If
-+        no parameter is provided when loading, this is the value that will be
-+        used.
-+
- config I2C_ALI1535
-       tristate "ALI 1535"
-       depends on I2C && PCI
-@@ -102,6 +122,14 @@
-         This support is also available as a module.  If so, the module 
-         will be called i2c-elektor.
-+config I2C_GPIO
-+      tristate "GPIO-based bitbanging I2C"
-+      depends on GENERIC_GPIO
-+      select I2C_ALGOBIT
++        Watchdog timer embedded into AT32AP700x devices. This will reboot
++        your system when the timeout is reached.
++
++config AT32AP700X_WDT_TIMEOUT
++      int "Timeout value for AT32AP700x watchdog"
++      depends on AT32AP700X_WDT
++      default "2"
++      range 1 2
 +      help
-+        This is a very simple bitbanging I2C driver utilizing the
-+        arch-neutral GPIO API to control the SCL and SDA lines.
-+
- config I2C_HYDRA
-       tristate "CHRP Apple Hydra Mac I/O I2C interface"
-       depends on I2C && PCI && PPC_CHRP && EXPERIMENTAL
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/i2c/busses/Makefile avr32-git/drivers/i2c/busses/Makefile
---- linux-2.6.21.3/drivers/i2c/busses/Makefile 2007-05-24 23:22:47.000000000 +0200
-+++ avr32-git/drivers/i2c/busses/Makefile      2007-06-06 11:33:51.000000000 +0200
-@@ -11,6 +11,7 @@
- obj-$(CONFIG_I2C_AT91)                += i2c-at91.o
- obj-$(CONFIG_I2C_AU1550)      += i2c-au1550.o
- obj-$(CONFIG_I2C_ELEKTOR)     += i2c-elektor.o
-+obj-$(CONFIG_I2C_GPIO)                += i2c-gpio.o
- obj-$(CONFIG_I2C_HYDRA)               += i2c-hydra.o
- obj-$(CONFIG_I2C_I801)                += i2c-i801.o
- obj-$(CONFIG_I2C_I810)                += i2c-i810.o
-@@ -48,6 +49,7 @@
- obj-$(CONFIG_I2C_VOODOO3)     += i2c-voodoo3.o
- obj-$(CONFIG_SCx200_ACB)      += scx200_acb.o
- obj-$(CONFIG_SCx200_I2C)      += scx200_i2c.o
-+obj-$(CONFIG_I2C_ATMELTWI)    += i2c-atmeltwi.o
- ifeq ($(CONFIG_I2C_DEBUG_BUS),y)
- EXTRA_CFLAGS += -DDEBUG
-diff -Nur -x .gitignore -x .git linux-2.6.21.3/drivers/mmc/atmel-mci.c avr32-git/drivers/mmc/atmel-mci.c
---- linux-2.6.21.3/drivers/mmc/atmel-mci.c     1970-01-01 01:00:00.000000000 +0100
-+++ avr32-git/drivers/mmc/atmel-mci.c  2007-06-06 11:33:56.000000000 +0200
-@@ -0,0 +1,1218 @@
++        Sets the timeout value for the watchdog in AT32AP700x devices.
++        Limited by hardware to be 1 or 2 seconds.
++
++        Set to 2 seconds by default.
++
+ # X86 (i386 + ia64 + x86_64) Architecture
+ config ACQUIRE_WDT
+diff -x .git -Nur linux-2.6.22.1/drivers/char/watchdog/Makefile linux-avr32.git/drivers/char/watchdog/Makefile
+--- linux-2.6.22.1/drivers/char/watchdog/Makefile      2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/drivers/char/watchdog/Makefile     2007-07-12 13:59:59.000000000 +0200
+@@ -36,6 +36,9 @@
+ obj-$(CONFIG_EP93XX_WATCHDOG) += ep93xx_wdt.o
+ obj-$(CONFIG_PNX4008_WATCHDOG) += pnx4008_wdt.o
++# AVR32 Architecture
++obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
++
+ # X86 (i386 + ia64 + x86_64) Architecture
+ obj-$(CONFIG_ACQUIRE_WDT) += acquirewdt.o
+ obj-$(CONFIG_ADVANTECH_WDT) += advantechwdt.o
+diff -x .git -Nur linux-2.6.22.1/drivers/i2c/busses/atmeltwi.h linux-avr32.git/drivers/i2c/busses/atmeltwi.h
+--- linux-2.6.22.1/drivers/i2c/busses/atmeltwi.h       1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/drivers/i2c/busses/atmeltwi.h      2007-06-06 11:33:51.000000000 +0200
+@@ -0,0 +1,117 @@
 +/*
-+ * Atmel MultiMedia Card Interface driver
++ * Register definitions for the Atmel Two-Wire Interface
++ */
++
++#ifndef __ASM_AVR32_TWI_H__
++#define __ASM_AVR32_TWI_H__
++
++/* TWI register offsets */
++#define TWI_CR                                        0x0000
++#define TWI_MMR                                       0x0004
++#define TWI_SMR                                       0x0008
++#define TWI_IADR                              0x000c
++#define TWI_CWGR                              0x0010
++#define TWI_SR                                        0x0020
++#define TWI_IER                                       0x0024
++#define TWI_IDR                                       0x0028
++#define TWI_IMR                                       0x002c
++#define TWI_RHR                                       0x0030
++#define TWI_THR                                       0x0034
++
++/* Bitfields in CR */
++#define TWI_START_OFFSET                      0
++#define TWI_START_SIZE                                1
++#define TWI_STOP_OFFSET                               1
++#define TWI_STOP_SIZE                         1
++#define TWI_MSEN_OFFSET                               2
++#define TWI_MSEN_SIZE                         1
++#define TWI_MSDIS_OFFSET                      3
++#define TWI_MSDIS_SIZE                                1
++#define TWI_SVEN_OFFSET                               4
++#define TWI_SVEN_SIZE                         1
++#define TWI_SVDIS_OFFSET                      5
++#define TWI_SVDIS_SIZE                                1
++#define TWI_SWRST_OFFSET                      7
++#define TWI_SWRST_SIZE                                1
++
++/* Bitfields in MMR */
++#define TWI_IADRSZ_OFFSET                     8
++#define TWI_IADRSZ_SIZE                               2
++#define TWI_MREAD_OFFSET                      12
++#define TWI_MREAD_SIZE                                1
++#define TWI_DADR_OFFSET                               16
++#define TWI_DADR_SIZE                         7
++
++/* Bitfields in SMR */
++#define TWI_SADR_OFFSET                               16
++#define TWI_SADR_SIZE                         7
++
++/* Bitfields in IADR */
++#define TWI_IADR_OFFSET                               0
++#define TWI_IADR_SIZE                         24
++
++/* Bitfields in CWGR */
++#define TWI_CLDIV_OFFSET                      0
++#define TWI_CLDIV_SIZE                                8
++#define TWI_CHDIV_OFFSET                      8
++#define TWI_CHDIV_SIZE                                8
++#define TWI_CKDIV_OFFSET                      16
++#define TWI_CKDIV_SIZE                                3
++
++/* Bitfields in SR */
++#define TWI_TXCOMP_OFFSET                     0
++#define TWI_TXCOMP_SIZE                               1
++#define TWI_RXRDY_OFFSET                      1
++#define TWI_RXRDY_SIZE                                1
++#define TWI_TXRDY_OFFSET                      2
++#define TWI_TXRDY_SIZE                                1
++#define TWI_SVDIR_OFFSET                      3
++#define TWI_SVDIR_SIZE                                1
++#define TWI_SVACC_OFFSET                      4
++#define TWI_SVACC_SIZE                                1
++#define TWI_GCACC_OFFSET                      5
++#define TWI_GCACC_SIZE                                1
++#define TWI_OVRE_OFFSET                               6
++#define TWI_OVRE_SIZE                         1
++#define TWI_UNRE_OFFSET                               7
++#define TWI_UNRE_SIZE                         1
++#define TWI_NACK_OFFSET                               8
++#define TWI_NACK_SIZE                         1
++#define TWI_ARBLST_OFFSET                     9
++#define TWI_ARBLST_SIZE                               1
++
++/* Bitfields in RHR */
++#define TWI_RXDATA_OFFSET                     0
++#define TWI_RXDATA_SIZE                               8
++
++/* Bitfields in THR */
++#define TWI_TXDATA_OFFSET                     0
++#define TWI_TXDATA_SIZE                               8
++
++/* Constants for IADRSZ */
++#define TWI_IADRSZ_NO_ADDR                    0
++#define TWI_IADRSZ_ONE_BYTE                   1
++#define TWI_IADRSZ_TWO_BYTES                  2
++#define TWI_IADRSZ_THREE_BYTES                        3
++
++/* Bit manipulation macros */
++#define TWI_BIT(name)                                 \
++      (1 << TWI_##name##_OFFSET)
++#define TWI_BF(name,value)                            \
++      (((value) & ((1 << TWI_##name##_SIZE) - 1))     \
++       << TWI_##name##_OFFSET)
++#define TWI_BFEXT(name,value)                         \
++      (((value) >> TWI_##name##_OFFSET)               \
++       & ((1 << TWI_##name##_SIZE) - 1))
++#define TWI_BFINS(name,value,old)                     \
++      (((old) & ~(((1 << TWI_##name##_SIZE) - 1)      \
++                  << TWI_##name##_OFFSET))            \
++       | TWI_BF(name,value))
++
++/* Register access macros */
++#define twi_readl(port,reg)                           \
++      __raw_readl((port)->regs + TWI_##reg)
++#define twi_writel(port,reg,value)                    \
++      __raw_writel((value), (port)->regs + TWI_##reg)
++
++#endif /* __ASM_AVR32_TWI_H__ */
+diff -x .git -Nur linux-2.6.22.1/drivers/i2c/busses/i2c-atmeltwi.c linux-avr32.git/drivers/i2c/busses/i2c-atmeltwi.c
+--- linux-2.6.22.1/drivers/i2c/busses/i2c-atmeltwi.c   1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/drivers/i2c/busses/i2c-atmeltwi.c  2007-07-12 13:59:59.000000000 +0200
+@@ -0,0 +1,348 @@
++/*
++ * i2c Support for Atmel's Two-Wire Interface (TWI)
 + *
-+ * Copyright (C) 2004-2006 Atmel Corporation
++ * Based on the work of Copyright (C) 2004 Rick Bronson
++ * Converted to 2.6 by Andrew Victor <andrew at sanpeople.com>
++ * Ported to AVR32 and heavily modified by Espen Krangnes <ekrangnes at atmel.com>
++ *
++ * Copyright (C) 2006 Atmel Corporation
++ *
++ * Borrowed heavily from the original work by:
++ * Copyright (C) 2000 Philip Edelbrock <phil at stimpy.netroedge.com>
 + *
 + * 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.
++ * 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/blkdev.h>
-+#include <linux/clk.h>
-+#include <linux/device.h>
-+#include <linux/dma-mapping.h>
++
++
++#include <linux/err.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/types.h>
++#include <linux/delay.h>
++#include <linux/i2c.h>
 +#include <linux/init.h>
++#include <linux/clk.h>
 +#include <linux/interrupt.h>
-+#include <linux/ioport.h>
-+#include <linux/module.h>
++#include <linux/irq.h>
 +#include <linux/platform_device.h>
-+
-+#include <linux/mmc/host.h>
-+#include <linux/mmc/protocol.h>
-+
-+#include <asm/dma-controller.h>
++#include <linux/completion.h>
 +#include <asm/io.h>
-+#include <asm/arch/board.h>
-+#include <asm/arch/gpio.h>
++#include <linux/time.h>
++#include "atmeltwi.h"
 +
-+#include "atmel-mci.h"
++static unsigned int baudrate = CONFIG_I2C_ATMELTWI_BAUDRATE;
++module_param(baudrate, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
++MODULE_PARM_DESC(baudrate, "The TWI baudrate");
 +
-+#define DRIVER_NAME "atmel_mci"
 +
-+#define MCI_CMD_ERROR_FLAGS   (MCI_BIT(RINDE) | MCI_BIT(RDIRE) |      \
-+                               MCI_BIT(RCRCE) | MCI_BIT(RENDE) |      \
-+                               MCI_BIT(RTOE))
-+#define MCI_DATA_ERROR_FLAGS  (MCI_BIT(DCRCE) | MCI_BIT(DTOE) |       \
-+                               MCI_BIT(OVRE) | MCI_BIT(UNRE))
++struct atmel_twi {
++      void __iomem *regs;
++      struct i2c_adapter adapter;
++      struct clk *pclk;
++      spinlock_t lock;
++      struct completion comp;
++      u32 intmask;
++      u8 *buf;
++      u8 len;
++      u8 acks_left;
++      unsigned int irq;
 +
-+enum {
-+      EVENT_CMD_COMPLETE = 0,
-+      EVENT_CMD_ERROR,
-+      EVENT_DATA_COMPLETE,
-+      EVENT_DATA_ERROR,
-+      EVENT_STOP_SENT,
-+      EVENT_STOP_COMPLETE,
-+      EVENT_STOP_ERROR,
-+      EVENT_DMA_ERROR,
-+      EVENT_CARD_DETECT,
 +};
++#define to_atmel_twi(adap) container_of(adap, struct atmel_twi, adapter)
++
++/*
++ * Initialize the TWI hardware registers.
++ */
++static int __devinit twi_hwinit(struct atmel_twi *twi)
++{
++      unsigned long cdiv, ckdiv=0;
++
++      twi_writel(twi, IDR, ~0UL);
++      twi_writel(twi, CR, TWI_BIT(SWRST));    /*Reset peripheral*/
++      twi_readl(twi, SR);
++
++      cdiv = (clk_get_rate(twi->pclk) / (2 * baudrate)) - 4;
++
++      while (cdiv > 255) {
++              ckdiv++;
++              cdiv = cdiv >> 1;
++      }
++
++      if (ckdiv > 7)
++              return -EINVAL;
++      else
++              twi_writel(twi, CWGR, (TWI_BF(CKDIV, ckdiv)
++                             | TWI_BF(CHDIV, cdiv)
++                             | TWI_BF(CLDIV, cdiv)));
++      return 0;
++}
++
++/*
++ * Waits for the i2c status register to set the specified bitmask
++ * Returns 0 if timed out (~100ms).
++ */
++static short twi_wait_for_completion(struct atmel_twi *twi,
++              u32 mask)
++{
++      int timeout = msecs_to_jiffies(100);
++
++      twi->intmask = mask;
++      init_completion(&twi->comp);
++
++      twi_writel(twi, IER, mask);
++
++      if(!wait_for_completion_timeout(&twi->comp, timeout))
++              return -ETIMEDOUT;
++
++      return 0;
++}
++
++/*
++ * Generic i2c master transfer entrypoint.
++ */
++static int twi_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
++{
++      struct atmel_twi *twi = to_atmel_twi(adap);
++      struct i2c_msg *pmsg;
++      int i;
++
++      /* get first message */
++      pmsg = msgs;
++
++      dev_dbg(&adap->dev, "twi_xfer: processing %d messages:\n", num);
++
++      for (i = 0; i < num; i++, pmsg++) {
++
++              twi->len = pmsg->len;
++              twi->buf = pmsg->buf;
++              twi->acks_left = pmsg->len;
++              twi_writel(twi, MMR, TWI_BF(DADR, pmsg->addr) |
++                      (pmsg->flags & I2C_M_RD ? TWI_BIT(MREAD) : 0));
++              twi_writel(twi, IADR, TWI_BF(IADR, pmsg->addr));
++
++              dev_dbg(&adap->dev,"#%d: internal addr %d %s byte%s %s 0x%02x\n",
++                      i,pmsg->len, pmsg->flags & I2C_M_RD ? "reading" : "writing",
++                      pmsg->len > 1 ? "s" : "",
++                      pmsg->flags & I2C_M_RD ? "from" : "to", pmsg->addr);
++
++              /* enable */
++              twi_writel(twi, CR, TWI_BIT(MSEN));
++
++              if (pmsg->flags & I2C_M_RD) {
++                      twi_writel(twi, CR, TWI_BIT(START));
++                      if ( twi_wait_for_completion(twi,TWI_BIT(RXRDY))==-ETIMEDOUT ) {
++                              dev_dbg(&adap->dev, "RXRDY timeout. Stopped with %d bytes left\n",
++                                      twi->acks_left);
++                              return -ETIMEDOUT;
++                      }
++
++                      /* Send Stop, and Wait until transfer is finished */
++                      if ( twi_wait_for_completion(twi,TWI_BIT(TXCOMP))==-ETIMEDOUT ) {
++                              dev_dbg(&adap->dev, "TXCOMP timeout\n");
++                              return -ETIMEDOUT;
++                      }
++
++              } else {
++                      twi_writel(twi, THR, twi->buf[0]);
++                      if ( twi_wait_for_completion(twi,TWI_BIT(TXRDY))==-ETIMEDOUT ) {
++                              dev_dbg(&adap->dev, "TXRDY timeout. Stopped with %d bytes left\n",
++                              twi->acks_left);
++                              return -ETIMEDOUT;
++                      }
++              }
++
++              /* Disable TWI interface */
++              twi_writel(twi, CR, TWI_BIT(MSDIS));
++
++      } /* end cur msg */
++
++      return i;
++}
++
++
++static irqreturn_t twi_interrupt(int irq, void *dev_id)
++{
++      struct atmel_twi *twi = dev_id;
++      int status = twi_readl(twi, SR);
++
++      if (twi->intmask & status){
++              if (twi->intmask & TWI_BIT(NACK)) {
++                      goto nack;
++              } else if (twi->intmask & TWI_BIT(RXRDY)){
++                      twi->buf[twi->len - twi->acks_left] = twi_readl(twi,RHR);
++                      if(--twi->acks_left==1)
++                              twi_writel(twi, CR, TWI_BIT(STOP));
++                      if (twi->acks_left==0)
++                              goto complete;
++              } else if (twi->intmask & TWI_BIT(TXRDY)) {
++                      twi->acks_left--;
++                      if (twi->acks_left==0) {
++                              twi->intmask = TWI_BIT(TXCOMP);
++                              twi_writel(twi, IER, TWI_BIT(TXCOMP));
++                      } else
++                              twi_writel(twi, THR, twi->buf[twi->len - twi->acks_left]);
++              } else if (twi->intmask & TWI_BIT(TXCOMP)) {
++                      goto complete;
++              }
++      }
++
++      return IRQ_HANDLED;
++
++nack:
++      printk(KERN_INFO "NACK received!\n");
++
++complete:
++      twi_writel(twi, IDR, ~0UL);
++      complete(&twi->comp);
++
++      return IRQ_HANDLED;
++
++}
++
++
++/*
++ * Return list of supported functionality.
++ */
++static u32 twi_func(struct i2c_adapter *adapter)
++{
++      return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
++}
++
++/* For now, we only handle combined mode (smbus) */
++static struct i2c_algorithm twi_algorithm = {
++      .master_xfer    = twi_xfer,
++      .functionality  = twi_func,
++};
++
++/*
++ * Main initialization routine.
++ */
++static int __devinit twi_probe(struct platform_device *pdev)
++{
++      struct atmel_twi *twi;
++      struct resource *regs;
++      struct clk *pclk;
++      struct i2c_adapter *adapter;
++      int rc, irq;
++
++      regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++      if (!regs)
++              return -ENXIO;
++
++      pclk = clk_get(&pdev->dev, "pclk");
++      if (IS_ERR(pclk))
++              return PTR_ERR(pclk);
++      clk_enable(pclk);
++
++      rc = -ENOMEM;
++      twi = kzalloc(sizeof(struct atmel_twi), GFP_KERNEL);
++      if (!twi) {
++              dev_err(&pdev->dev, "can't allocate interface!\n");
++              goto err_alloc_twi;
++      }
++
++      twi->pclk = pclk;
++      twi->regs = ioremap(regs->start, regs->end - regs->start + 1);
++      if (!twi->regs)
++              goto err_ioremap;
++
++      irq = platform_get_irq(pdev,0);
++      rc = request_irq(irq, twi_interrupt, 0, "twi", twi);
++      if (rc) {
++              dev_err(&pdev->dev, "can't bind irq!\n");
++              goto err_irq;
++      }
++      twi->irq = irq;
++
++      rc = twi_hwinit(twi);
++      if (rc) {
++              dev_err(&pdev->dev, "Unable to set baudrate\n");
++              goto err_hw_init;
++      }
++
++      adapter = &twi->adapter;
++      sprintf(adapter->name, "TWI");
++      adapter->algo = &twi_algorithm;
++      adapter->class = I2C_CLASS_HWMON;
++      adapter->dev.parent = &pdev->dev;
++
++      platform_set_drvdata(pdev, twi);
++
++      rc = i2c_add_adapter(adapter);
++      if (rc) {
++              dev_err(&pdev->dev, "Adapter %s registration failed\n",
++                      adapter->name);
++              goto err_register;
++      }
++
++      dev_info(&pdev->dev, "Atmel TWI i2c bus device (baudrate %dk) at 0x%08lx.\n",
++               baudrate/1000, (unsigned long)regs->start);
++
++      return 0;
++
++
++err_register:
++      platform_set_drvdata(pdev, NULL);
++
++err_hw_init:
++      free_irq(irq, twi);
++
++err_irq:
++      iounmap(twi->regs);
++
++err_ioremap:
++      kfree(twi);
++
++err_alloc_twi:
++      clk_disable(pclk);
++      clk_put(pclk);
++
++      return rc;
++}
++
++static int __devexit twi_remove(struct platform_device *pdev)
++{
++      struct atmel_twi *twi = platform_get_drvdata(pdev);
++      int res;
++
++      platform_set_drvdata(pdev, NULL);
++      res = i2c_del_adapter(&twi->adapter);
++      twi_writel(twi, CR, TWI_BIT(MSDIS));
++      iounmap(twi->regs);
++      clk_disable(twi->pclk);
++      clk_put(twi->pclk);
++      free_irq(twi->irq, twi);
++      kfree(twi);
++
++      return res;
++}
++
++static struct platform_driver twi_driver = {
++      .probe          = twi_probe,
++      .remove         = __devexit_p(twi_remove),
++      .driver         = {
++              .name   = "atmel_twi",
++              .owner  = THIS_MODULE,
++      },
++};
++
++static int __init atmel_twi_init(void)
++{
++      return platform_driver_register(&twi_driver);
++}
++
++static void __exit atmel_twi_exit(void)
++{
++      platform_driver_unregister(&twi_driver);
++}
++
++module_init(atmel_twi_init);
++module_exit(atmel_twi_exit);
++
++MODULE_AUTHOR("Espen Krangnes");
++MODULE_DESCRIPTION("I2C driver for Atmel TWI");
++MODULE_LICENSE("GPL");
+diff -x .git -Nur linux-2.6.22.1/drivers/i2c/busses/Kconfig linux-avr32.git/drivers/i2c/busses/Kconfig
+--- linux-2.6.22.1/drivers/i2c/busses/Kconfig  2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/drivers/i2c/busses/Kconfig 2007-07-12 13:59:59.000000000 +0200
+@@ -4,6 +4,26 @@
+ menu "I2C Hardware Bus support"
++config I2C_ATMELTWI
++      tristate "Atmel TWI/I2C"
++      depends on I2C
++      help
++        Atmel on-chip TWI controller. Say Y if you have an AT32 or
++        AT91-based device and want to use its built-in TWI
++        functionality. Atmel's TWI is compatible with Philips' I2C
++        protocol. If in doubt, say NO
++
++config I2C_ATMELTWI_BAUDRATE
++      prompt "Atmel TWI baudrate"
++      depends on I2C_ATMELTWI
++      int
++      default 100000
++      help
++        Set the TWI/I2C baudrate. This will alter the default value. A
++        different baudrate can be set by using a module parameter as well. If
++        no parameter is provided when loading, this is the value that will be
++        used.
++
+ config I2C_ALI1535
+       tristate "ALI 1535"
+       depends on PCI
+diff -x .git -Nur linux-2.6.22.1/drivers/i2c/busses/Makefile linux-avr32.git/drivers/i2c/busses/Makefile
+--- linux-2.6.22.1/drivers/i2c/busses/Makefile 2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/drivers/i2c/busses/Makefile        2007-07-12 13:59:59.000000000 +0200
+@@ -52,6 +52,7 @@
+ obj-$(CONFIG_I2C_VOODOO3)     += i2c-voodoo3.o
+ obj-$(CONFIG_SCx200_ACB)      += scx200_acb.o
+ obj-$(CONFIG_SCx200_I2C)      += scx200_i2c.o
++obj-$(CONFIG_I2C_ATMELTWI)    += i2c-atmeltwi.o
+ ifeq ($(CONFIG_I2C_DEBUG_BUS),y)
+ EXTRA_CFLAGS += -DDEBUG
+diff -x .git -Nur linux-2.6.22.1/drivers/leds/Kconfig linux-avr32.git/drivers/leds/Kconfig
+--- linux-2.6.22.1/drivers/leds/Kconfig        2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/drivers/leds/Kconfig       2007-07-12 14:00:02.000000000 +0200
+@@ -95,6 +95,14 @@
+       help
+         This option enables support for the front LED on Cobalt Server
++config LEDS_GPIO
++      tristate "LED Support for GPIO connected LEDs"
++      depends on LEDS_CLASS && GENERIC_GPIO
++      help
++        This option enables support for the LEDs connected to GPIO
++        outputs. To be useful the particular board must have LEDs
++        and they must be connected to the GPIO lines.
++
+ comment "LED Triggers"
+ config LEDS_TRIGGERS
+diff -x .git -Nur linux-2.6.22.1/drivers/leds/leds-gpio.c linux-avr32.git/drivers/leds/leds-gpio.c
+--- linux-2.6.22.1/drivers/leds/leds-gpio.c    1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/drivers/leds/leds-gpio.c   2007-07-12 14:00:02.000000000 +0200
+@@ -0,0 +1,199 @@
++/*
++ * LEDs driver for GPIOs
++ *
++ * Copyright (C) 2007 8D Technologies inc.
++ * Raphael Assenat <raph@8d.com>
++ *
++ * 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.
++ *
++ */
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/platform_device.h>
++#include <linux/leds.h>
++#include <linux/workqueue.h>
++
++#include <asm/gpio.h>
++
++struct gpio_led_data {
++      struct led_classdev cdev;
++      unsigned gpio;
++      struct work_struct work;
++      u8 new_level;
++      u8 can_sleep;
++      u8 active_low;
++};
++
++static void gpio_led_work(struct work_struct *work)
++{
++      struct gpio_led_data    *led_dat =
++              container_of(work, struct gpio_led_data, work);
++
++      gpio_set_value_cansleep(led_dat->gpio, led_dat->new_level);
++}
++
++static void gpio_led_set(struct led_classdev *led_cdev,
++      enum led_brightness value)
++{
++      struct gpio_led_data *led_dat =
++              container_of(led_cdev, struct gpio_led_data, cdev);
++      int level;
++
++      if (value == LED_OFF)
++              level = 0;
++      else
++              level = 1;
++
++      if (led_dat->active_low)
++              level = !level;
++
++      /* setting GPIOs with I2C/etc requires a preemptible task context */
++      if (led_dat->can_sleep) {
++              if (preempt_count()) {
++                      led_dat->new_level = level;
++                      schedule_work(&led_dat->work);
++              } else
++                      gpio_set_value_cansleep(led_dat->gpio, level);
++      } else
++              gpio_set_value(led_dat->gpio, level);
++}
++
++static int __init gpio_led_probe(struct platform_device *pdev)
++{
++      struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
++      struct gpio_led *cur_led;
++      struct gpio_led_data *leds_data, *led_dat;
++      int i, ret = 0;
++
++      if (!pdata)
++              return -EBUSY;
++
++      leds_data = kzalloc(sizeof(struct gpio_led_data) * pdata->num_leds,
++                              GFP_KERNEL);
++      if (!leds_data)
++              return -ENOMEM;
++
++      for (i = 0; i < pdata->num_leds; i++) {
++              cur_led = &pdata->leds[i];
++              led_dat = &leds_data[i];
++
++              led_dat->cdev.name = cur_led->name;
++              led_dat->cdev.default_trigger = cur_led->default_trigger;
++              led_dat->gpio = cur_led->gpio;
++              led_dat->can_sleep = gpio_cansleep(cur_led->gpio);
++              led_dat->active_low = cur_led->active_low;
++              led_dat->cdev.brightness_set = gpio_led_set;
++              led_dat->cdev.brightness = cur_led->active_low ? LED_FULL : LED_OFF;
++
++              ret = gpio_request(led_dat->gpio, led_dat->cdev.name);
++              if (ret < 0)
++                      goto err;
++
++              gpio_direction_output(led_dat->gpio, led_dat->active_low);
++
++              ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
++              if (ret < 0) {
++                      gpio_free(led_dat->gpio);
++                      goto err;
++              }
++
++              INIT_WORK(&led_dat->work, gpio_led_work);
++      }
++
++      platform_set_drvdata(pdev, leds_data);
++
++      return 0;
++
++err:
++      if (i > 0) {
++              for (i = i - 1; i >= 0; i--) {
++                      led_classdev_unregister(&leds_data[i].cdev);
++                      gpio_free(leds_data[i].gpio);
++              }
++      }
++
++      flush_scheduled_work();
++      kfree(leds_data);
++
++      return ret;
++}
++
++static int __exit gpio_led_remove(struct platform_device *pdev)
++{
++      int i;
++      struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
++      struct gpio_led_data *leds_data;
++
++      leds_data = platform_get_drvdata(pdev);
++
++      for (i = 0; i < pdata->num_leds; i++) {
++              led_classdev_unregister(&leds_data[i].cdev);
++              gpio_free(leds_data[i].gpio);
++      }
++      
++      kfree(leds_data);
++
++      return 0;
++}
++
++#ifdef CONFIG_PM
++static int gpio_led_suspend(struct platform_device *pdev, pm_message_t state)
++{
++      struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
++      struct gpio_led_data *leds_data;
++      int i;
++      
++      leds_data = platform_get_drvdata(pdev);
++
++      for (i = 0; i < pdata->num_leds; i++)
++              led_classdev_suspend(&leds_data[i].cdev);
++
++      return 0;
++}
++
++static int gpio_led_resume(struct platform_device *pdev)
++{
++      struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
++      struct gpio_led_data *leds_data;
++      int i;
++
++      leds_data = platform_get_drvdata(pdev);
++
++      for (i = 0; i < pdata->num_leds; i++)
++              led_classdev_resume(&leds_data[i].cdev);
++
++      return 0;
++}
++#else
++#define gpio_led_suspend NULL
++#define gpio_led_resume NULL
++#endif
++
++static struct platform_driver gpio_led_driver = {
++      .remove         = __exit_p(gpio_led_remove),
++      .suspend        = gpio_led_suspend,
++      .resume         = gpio_led_resume,
++      .driver         = {
++              .name   = "leds-gpio",
++              .owner  = THIS_MODULE,
++      },
++};
++
++static int __init gpio_led_init(void)
++{
++      return platform_driver_probe(&gpio_led_driver, gpio_led_probe);
++}
++
++static void __exit gpio_led_exit(void)
++{
++      platform_driver_unregister(&gpio_led_driver);
++}
++
++module_init(gpio_led_init);
++module_exit(gpio_led_exit);
++
++MODULE_AUTHOR("Raphael Assenat <raph@8d.com>");
++MODULE_DESCRIPTION("GPIO LED driver");
++MODULE_LICENSE("GPL");
+diff -x .git -Nur linux-2.6.22.1/drivers/leds/Makefile linux-avr32.git/drivers/leds/Makefile
+--- linux-2.6.22.1/drivers/leds/Makefile       2007-07-10 20:56:30.000000000 +0200
++++ linux-avr32.git/drivers/leds/Makefile      2007-07-12 14:00:02.000000000 +0200
+@@ -16,6 +16,7 @@
+ obj-$(CONFIG_LEDS_WRAP)                       += leds-wrap.o
+ obj-$(CONFIG_LEDS_H1940)              += leds-h1940.o
+ obj-$(CONFIG_LEDS_COBALT)             += leds-cobalt.o
++obj-$(CONFIG_LEDS_GPIO)                       += leds-gpio.o
+ # LED Triggers
+ obj-$(CONFIG_LEDS_TRIGGER_TIMER)      += ledtrig-timer.o
+diff -x .git -Nur linux-2.6.22.1/drivers/mmc/host/atmel-mci.c linux-avr32.git/drivers/mmc/host/atmel-mci.c
+--- linux-2.6.22.1/drivers/mmc/host/atmel-mci.c        1970-01-01 01:00:00.000000000 +0100
++++ linux-avr32.git/drivers/mmc/host/atmel-mci.c       2007-07-12 14:00:03.000000000 +0200
+@@ -0,0 +1,1217 @@
++/*
++ * Atmel MultiMedia Card Interface driver
++ *
++ * Copyright (C) 2004-2006 Atmel Corporation
++ *
++ * 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.
++ */
++#include <linux/blkdev.h>
++#include <linux/clk.h>
++#include <linux/device.h>
++#include <linux/dma-mapping.h>
++#include <linux/init.h>
++#include <linux/interrupt.h>
++#include <linux/ioport.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++
++#include <linux/mmc/host.h>
++
++#include <asm/dma-controller.h>
++#include <asm/io.h>
++#include <asm/arch/board.h>
++#include <asm/arch/gpio.h>
++
++#include "atmel-mci.h"
++
++#define DRIVER_NAME "atmel_mci"
++
++#define MCI_CMD_ERROR_FLAGS   (MCI_BIT(RINDE) | MCI_BIT(RDIRE) |      \
++                               MCI_BIT(RCRCE) | MCI_BIT(RENDE) |      \
++                               MCI_BIT(RTOE))
++#define MCI_DATA_ERROR_FLAGS  (MCI_BIT(DCRCE) | MCI_BIT(DTOE) |       \
++                               MCI_BIT(OVRE) | MCI_BIT(UNRE))
++
++enum {
++      EVENT_CMD_COMPLETE = 0,
++      EVENT_CMD_ERROR,
++      EVENT_DATA_COMPLETE,
++      EVENT_DATA_ERROR,
++      EVENT_STOP_SENT,
++      EVENT_STOP_COMPLETE,
++      EVENT_STOP_ERROR,
++      EVENT_DMA_ERROR,
++      EVENT_CARD_DETECT,
++};
++
++struct atmel_mci_dma {
++      struct dma_request_sg   req;
++      unsigned short          rx_periph_id;
++      unsigned short          tx_periph_id;
++};
++
++struct atmel_mci {
++      struct mmc_host         *mmc;
++      void __iomem            *regs;
++      struct atmel_mci_dma    dma;
++
++      struct mmc_request      *mrq;
++      struct mmc_command      *cmd;
++      struct mmc_data         *data;
++
++      u32                     stop_cmdr;
++      u32                     stop_iflags;
++
++      struct tasklet_struct   tasklet;
++      unsigned long           pending_events;
++      unsigned long           completed_events;
++      u32                     error_status;
++
++      int                     present;
++      int                     detect_pin;
++      int                     wp_pin;
++
++      unsigned long           bus_hz;
++      unsigned long           mapbase;
++      struct clk              *mck;
++      struct platform_device  *pdev;
++
++#ifdef CONFIG_DEBUG_FS
++      struct dentry           *debugfs_root;
++      struct dentry           *debugfs_regs;
++      struct dentry           *debugfs_req;
++      struct dentry           *debugfs_pending_events;
++      struct dentry           *debugfs_completed_events;
++#endif
++};
++
++/* Those printks take an awful lot of time... */
++#ifndef DEBUG
++static unsigned int fmax = 15000000U;
++#else
++static unsigned int fmax = 1000000U;
++#endif
++module_param(fmax, uint, 0444);
++MODULE_PARM_DESC(fmax, "Max frequency in Hz of the MMC bus clock");
++
++/* Test bit macros for completed events */
++#define mci_cmd_is_complete(host)                     \
++      test_bit(EVENT_CMD_COMPLETE, &host->completed_events)
++#define mci_cmd_error_is_complete(host)                       \
++      test_bit(EVENT_CMD_ERROR, &host->completed_events)
++#define mci_data_is_complete(host)                    \
++      test_bit(EVENT_DATA_COMPLETE, &host->completed_events)
++#define mci_data_error_is_complete(host)              \
++      test_bit(EVENT_DATA_ERROR, &host->completed_events)
++#define mci_stop_sent_is_complete(host)                       \
++      test_bit(EVENT_STOP_SENT, &host->completed_events)
++#define mci_stop_is_complete(host)                    \
++      test_bit(EVENT_STOP_COMPLETE, &host->completed_events)
++#define mci_stop_error_is_complete(host)              \
++      test_bit(EVENT_STOP_ERROR, &host->completed_events)
++#define mci_dma_error_is_complete(host)                       \
++      test_bit(EVENT_DMA_ERROR, &host->completed_events)
++#define mci_card_detect_is_complete(host)                     \
++      test_bit(EVENT_CARD_DETECT, &host->completed_events)
++
++/* Test and clear bit macros for pending events */
++#define mci_clear_cmd_is_pending(host)                        \
++      test_and_clear_bit(EVENT_CMD_COMPLETE, &host->pending_events)
++#define mci_clear_cmd_error_is_pending(host)          \
++      test_and_clear_bit(EVENT_CMD_ERROR, &host->pending_events)
++#define mci_clear_data_is_pending(host)                       \
++      test_and_clear_bit(EVENT_DATA_COMPLETE, &host->pending_events)
++#define mci_clear_data_error_is_pending(host)         \
++      test_and_clear_bit(EVENT_DATA_ERROR, &host->pending_events)
++#define mci_clear_stop_sent_is_pending(host)          \
++      test_and_clear_bit(EVENT_STOP_SENT, &host->pending_events)
++#define mci_clear_stop_is_pending(host)                       \
++      test_and_clear_bit(EVENT_STOP_COMPLETE, &host->pending_events)
++#define mci_clear_stop_error_is_pending(host)         \
++      test_and_clear_bit(EVENT_STOP_ERROR, &host->pending_events)
++#define mci_clear_dma_error_is_pending(host)          \
++      test_and_clear_bit(EVENT_DMA_ERROR, &host->pending_events)
++#define mci_clear_card_detect_is_pending(host)                \
++      test_and_clear_bit(EVENT_CARD_DETECT, &host->pending_events)
++
++/* Test and set bit macros for completed events */
++#define mci_set_cmd_is_completed(host)                        \
++      test_and_set_bit(EVENT_CMD_COMPLETE, &host->completed_events)
++#define mci_set_cmd_error_is_completed(host)          \
++      test_and_set_bit(EVENT_CMD_ERROR, &host->completed_events)
++#define mci_set_data_is_completed(host)                       \
++      test_and_set_bit(EVENT_DATA_COMPLETE, &host->completed_events)
++#define mci_set_data_error_is_completed(host)         \
++      test_and_set_bit(EVENT_DATA_ERROR, &host->completed_events)
++#define mci_set_stop_sent_is_completed(host)          \
++      test_and_set_bit(EVENT_STOP_SENT, &host->completed_events)
++#define mci_set_stop_is_completed(host)                       \
++      test_and_set_bit(EVENT_STOP_COMPLETE, &host->completed_events)
++#define mci_set_stop_error_is_completed(host)         \
++      test_and_set_bit(EVENT_STOP_ERROR, &host->completed_events)
++#define mci_set_dma_error_is_completed(host)          \
++      test_and_set_bit(EVENT_DMA_ERROR, &host->completed_events)
++#define mci_set_card_detect_is_completed(host)                \
++      test_and_set_bit(EVENT_CARD_DETECT, &host->completed_events)
++
++/* Set bit macros for completed events */
++#define mci_set_cmd_complete(host)                    \
++      set_bit(EVENT_CMD_COMPLETE, &host->completed_events)
++#define mci_set_cmd_error_complete(host)              \
++      set_bit(EVENT_CMD_ERROR, &host->completed_events)
++#define mci_set_data_complete(host)                   \
++      set_bit(EVENT_DATA_COMPLETE, &host->completed_events)
++#define mci_set_data_error_complete(host)             \
++      set_bit(EVENT_DATA_ERROR, &host->completed_events)
++#define mci_set_stop_sent_complete(host)              \
++      set_bit(EVENT_STOP_SENT, &host->completed_events)
++#define mci_set_stop_complete(host)                   \
++      set_bit(EVENT_STOP_COMPLETE, &host->completed_events)
++#define mci_set_stop_error_complete(host)             \
++      set_bit(EVENT_STOP_ERROR, &host->completed_events)
++#define mci_set_dma_error_complete(host)              \
++      set_bit(EVENT_DMA_ERROR, &host->completed_events)
++#define mci_set_card_detect_complete(host)            \
++      set_bit(EVENT_CARD_DETECT, &host->completed_events)
++
++/* Set bit macros for pending events */
++#define mci_set_cmd_pending(host)                     \
++      set_bit(EVENT_CMD_COMPLETE, &host->pending_events)
++#define mci_set_cmd_error_pending(host)                       \
++      set_bit(EVENT_CMD_ERROR, &host->pending_events)
++#define mci_set_data_pending(host)                    \
++      set_bit(EVENT_DATA_COMPLETE, &host->pending_events)
++#define mci_set_data_error_pending(host)              \
++      set_bit(EVENT_DATA_ERROR, &host->pending_events)
++#define mci_set_stop_sent_pending(host)                       \
++      set_bit(EVENT_STOP_SENT, &host->pending_events)
++#define mci_set_stop_pending(host)                    \
++      set_bit(EVENT_STOP_COMPLETE, &host->pending_events)
++#define mci_set_stop_error_pending(host)              \
++      set_bit(EVENT_STOP_ERROR, &host->pending_events)
++#define mci_set_dma_error_pending(host)                       \
++      set_bit(EVENT_DMA_ERROR, &host->pending_events)
++#define mci_set_card_detect_pending(host)             \
++      set_bit(EVENT_CARD_DETECT, &host->pending_events)
++
++/* Clear bit macros for pending events */
++#define mci_clear_cmd_pending(host)                   \
++      clear_bit(EVENT_CMD_COMPLETE, &host->pending_events)
++#define mci_clear_cmd_error_pending(host)             \
++      clear_bit(EVENT_CMD_ERROR, &host->pending_events)
++#define mci_clear_data_pending(host)                  \
++      clear_bit(EVENT_DATA_COMPLETE, &host->pending_events)
++#define mci_clear_data_error_pending(host)            \
++      clear_bit(EVENT_DATA_ERROR, &host->pending_events)
++#define mci_clear_stop_sent_pending(host)             \
++      clear_bit(EVENT_STOP_SENT, &host->pending_events)
++#define mci_clear_stop_pending(host)                  \
++      clear_bit(EVENT_STOP_COMPLETE, &host->pending_events)
++#define mci_clear_stop_error_pending(host)            \
++      clear_bit(EVENT_STOP_ERROR, &host->pending_events)
++#define mci_clear_dma_error_pending(host)             \
++      clear_bit(EVENT_DMA_ERROR, &host->pending_events)
++#define mci_clear_card_detect_pending(host)           \
++      clear_bit(EVENT_CARD_DETECT, &host->pending_events)
++
++
++#ifdef CONFIG_DEBUG_FS
++#include <linux/debugfs.h>
++
++#define DBG_REQ_BUF_SIZE      (4096 - sizeof(unsigned int))
++
++struct req_dbg_data {
++      unsigned int nbytes;
++      char str[DBG_REQ_BUF_SIZE];
++};
++
++static int req_dbg_open(struct inode *inode, struct file *file)
++{
++      struct atmel_mci *host;
++      struct mmc_request *mrq;
++      struct mmc_command *cmd, *stop;
++      struct mmc_data *data;
++      struct req_dbg_data *priv;
++      char *str;
++      unsigned long n = 0;
++
++      priv = kzalloc(DBG_REQ_BUF_SIZE, GFP_KERNEL);
++      if (!priv)
++              return -ENOMEM;
++      str = priv->str;
++
++      mutex_lock(&inode->i_mutex);
++      host = inode->i_private;
++
++      spin_lock_irq(&host->mmc->lock);
++      mrq = host->mrq;
++      if (mrq) {
++              cmd = mrq->cmd;
++              data = mrq->data;
++              stop = mrq->stop;
++              n = snprintf(str, DBG_REQ_BUF_SIZE,
++                           "CMD%u(0x%x) %x %x %x %x %x (err %u)\n",
++                           cmd->opcode, cmd->arg, cmd->flags,
++                           cmd->resp[0], cmd->resp[1], cmd->resp[2],
++                           cmd->resp[3], cmd->error);
++              if (n < DBG_REQ_BUF_SIZE && data)
++                      n += snprintf(str + n, DBG_REQ_BUF_SIZE - n,
++                                    "DATA %u * %u (%u) %x (err %u)\n",
++                                    data->blocks, data->blksz,
++                                    data->bytes_xfered, data->flags,
++                                    data->error);
++              if (n < DBG_REQ_BUF_SIZE && stop)
++                      n += snprintf(str + n, DBG_REQ_BUF_SIZE - n,
++                                    "CMD%u(0x%x) %x %x %x %x %x (err %u)\n",
++                                    stop->opcode, stop->arg, stop->flags,
++                                    stop->resp[0], stop->resp[1],
++                                    stop->resp[2], stop->resp[3],
++                                    stop->error);
++      }
++      spin_unlock_irq(&host->mmc->lock);
++      mutex_unlock(&inode->i_mutex);
++
++      priv->nbytes = min(n, DBG_REQ_BUF_SIZE);
++      file->private_data = priv;
++
++      return 0;
++}
++
++static ssize_t req_dbg_read(struct file *file, char __user *buf,
++                          size_t nbytes, loff_t *ppos)
++{
++      struct req_dbg_data *priv = file->private_data;
++
++      return simple_read_from_buffer(buf, nbytes, ppos,
++                                     priv->str, priv->nbytes);
++}
++
++static int req_dbg_release(struct inode *inode, struct file *file)
++{
++      kfree(file->private_data);
++      return 0;
++}
++
++static const struct file_operations req_dbg_fops = {
++      .owner          = THIS_MODULE,
++      .open           = req_dbg_open,
++      .llseek         = no_llseek,
++      .read           = req_dbg_read,
++      .release        = req_dbg_release,
++};
++
++static int regs_dbg_open(struct inode *inode, struct file *file)
++{
++      struct atmel_mci *host;
++      unsigned int i;
++      u32 *data;
++      int ret = -ENOMEM;
++
++      mutex_lock(&inode->i_mutex);
++      host = inode->i_private;
++      data = kmalloc(inode->i_size, GFP_KERNEL);
++      if (!data)
++              goto out;
++
++      spin_lock_irq(&host->mmc->lock);
++      for (i = 0; i < inode->i_size / 4; i++)
++              data[i] = __raw_readl(host->regs + i * 4);
++      spin_unlock_irq(&host->mmc->lock);
++
++      file->private_data = data;
++      ret = 0;
++
++out:
++      mutex_unlock(&inode->i_mutex);
++
++      return ret;
++}
++
++static ssize_t regs_dbg_read(struct file *file, char __user *buf,
++                           size_t nbytes, loff_t *ppos)
++{
++      struct inode *inode = file->f_dentry->d_inode;
++      int ret;
++
++      mutex_lock(&inode->i_mutex);
++      ret = simple_read_from_buffer(buf, nbytes, ppos,
++                                    file->private_data,
++                                    file->f_dentry->d_inode->i_size);
++      mutex_unlock(&inode->i_mutex);
++
++      return ret;
++}
++
++static int regs_dbg_release(struct inode *inode, struct file *file)
++{
++      kfree(file->private_data);
++      return 0;
++}
++
++static const struct file_operations regs_dbg_fops = {
++      .owner          = THIS_MODULE,
++      .open           = regs_dbg_open,
++      .llseek         = generic_file_llseek,
++      .read           = regs_dbg_read,
++      .release        = regs_dbg_release,
++};
++
++static void atmci_init_debugfs(struct atmel_mci *host)
++{
++      struct mmc_host *mmc;
++      struct dentry *root, *regs;
++      struct resource *res;
++
++      mmc = host->mmc;
++      root = debugfs_create_dir(mmc_hostname(mmc), NULL);
++      if (IS_ERR(root) || !root)
++              goto err_root;
++      host->debugfs_root = root;
++
++      regs = debugfs_create_file("regs", 0400, root, host, &regs_dbg_fops);
++      if (!regs)
++              goto err_regs;
++
++      res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
++      regs->d_inode->i_size = res->end - res->start + 1;
++      host->debugfs_regs = regs;
++
++      host->debugfs_req = debugfs_create_file("req", 0400, root,
++                                              host, &req_dbg_fops);
++      if (!host->debugfs_req)
++              goto err_req;
++
++      host->debugfs_pending_events
++              = debugfs_create_u32("pending_events", 0400, root,
++                                   (u32 *)&host->pending_events);
++      if (!host->debugfs_pending_events)
++              goto err_pending_events;
++
++      host->debugfs_completed_events
++              = debugfs_create_u32("completed_events", 0400, root,
++                                   (u32 *)&host->completed_events);
++      if (!host->debugfs_completed_events)
++              goto err_completed_events;
++
++      return;
++
++err_completed_events:
++      debugfs_remove(host->debugfs_pending_events);
++err_pending_events:
++      debugfs_remove(host->debugfs_req);
++err_req:
++      debugfs_remove(host->debugfs_regs);
++err_regs:
++      debugfs_remove(host->debugfs_root);
++err_root:
++      host->debugfs_root = NULL;
++      dev_err(&host->pdev->dev,
++              "failed to initialize debugfs for %s\n",
++              mmc_hostname(mmc));
++}
++
++static void atmci_cleanup_debugfs(struct atmel_mci *host)
++{
++      if (host->debugfs_root) {
++              debugfs_remove(host->debugfs_completed_events);
++              debugfs_remove(host->debugfs_pending_events);
++              debugfs_remove(host->debugfs_req);
++              debugfs_remove(host->debugfs_regs);
++              debugfs_remove(host->debugfs_root);
++              host->debugfs_root = NULL;
++      }
++}
++#else
++static inline void atmci_init_debugfs(struct atmel_mci *host)
++{
++
++}
++
++static inline void atmci_cleanup_debugfs(struct atmel_mci *host)
++{
++
++}
++#endif /* CONFIG_DEBUG_FS */
++
++static inline unsigned int ns_to_clocks(struct atmel_mci *host,
++                                      unsigned int ns)
++{
++      return (ns * (host->bus_hz / 1000000) + 999) / 1000;
++}
++
++static void atmci_set_timeout(struct atmel_mci *host,
++                            struct mmc_data *data)
++{
++      static unsigned dtomul_to_shift[] = {
++              0, 4, 7, 8, 10, 12, 16, 20
++      };
++      unsigned timeout;
++      unsigned dtocyc, dtomul;
++
++      timeout = ns_to_clocks(host, data->timeout_ns) + data->timeout_clks;
++
++      for (dtomul = 0; dtomul < 8; dtomul++) {
++              unsigned shift = dtomul_to_shift[dtomul];
++              dtocyc = (timeout + (1 << shift) - 1) >> shift;
++              if (dtocyc < 15)
++                      break;
++      }
++
++      if (dtomul >= 8) {
++              dtomul = 7;
++              dtocyc = 15;
++      }
++
++      pr_debug("%s: setting timeout to %u cycles\n",
++               mmc_hostname(host->mmc),
++               dtocyc << dtomul_to_shift[dtomul]);
++      mci_writel(host, DTOR, (MCI_BF(DTOMUL, dtomul)
++                              | MCI_BF(DTOCYC, dtocyc)));
++}
++
++/*
++ * Return mask with interrupt flags to be handled for this command.
++ */
++static u32 atmci_prepare_command(struct mmc_host *mmc,
++                               struct mmc_command *cmd,
++                               u32 *cmd_flags)
++{
++      u32 cmdr;
++      u32 iflags;
++
++      cmd->error = MMC_ERR_NONE;
++
++      cmdr = 0;
++      BUG_ON(MCI_BFEXT(CMDNB, cmdr) != 0);
++      cmdr = MCI_BFINS(CMDNB, cmd->opcode, cmdr);
++
++      if (cmd->flags & MMC_RSP_PRESENT) {
++              if (cmd->flags & MMC_RSP_136)
++                      cmdr |= MCI_BF(RSPTYP, MCI_RSPTYP_136_BIT);
++              else
++                      cmdr |= MCI_BF(RSPTYP, MCI_RSPTYP_48_BIT);
++      }
++
++      /*
++       * This should really be MAXLAT_5 for CMD2 and ACMD41, but
++       * it's too difficult to determine whether this is an ACMD or
++       * not. Better make it 64.
++       */
++      cmdr |= MCI_BIT(MAXLAT);
++
++      if (mmc->ios.bus_mode == MMC_BUSMODE_OPENDRAIN)
++              cmdr |= MCI_BIT(OPDCMD);
++
++      iflags = MCI_BIT(CMDRDY) | MCI_CMD_ERROR_FLAGS;
++      if (!(cmd->flags & MMC_RSP_CRC))
++              iflags &= ~MCI_BIT(RCRCE);
++
++      pr_debug("%s: cmd: op %02x arg %08x flags %08x, cmdflags %08lx\n",
++               mmc_hostname(mmc), cmd->opcode, cmd->arg, cmd->flags,
++               (unsigned long)cmdr);
++
++      *cmd_flags = cmdr;
++      return iflags;
++}
++
++static void atmci_start_command(struct atmel_mci *host,
++                              struct mmc_command *cmd,
++                              u32 cmd_flags)
++{
++      WARN_ON(host->cmd);
++      host->cmd = cmd;
++
++      mci_writel(host, ARGR, cmd->arg);
++      mci_writel(host, CMDR, cmd_flags);
++
++      if (cmd->data)
++              dma_start_request(host->dma.req.req.dmac,
++                                host->dma.req.req.channel);
++}
++
++/*
++ * Returns a mask of flags to be set in the command register when the
++ * command to start the transfer is to be sent.
++ */
++static u32 atmci_prepare_data(struct mmc_host *mmc, struct mmc_data *data)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++      u32 cmd_flags;
++
++      WARN_ON(host->data);
++      host->data = data;
++
++      atmci_set_timeout(host, data);
++      mci_writel(host, BLKR, (MCI_BF(BCNT, data->blocks)
++                              | MCI_BF(BLKLEN, data->blksz)));
++      host->dma.req.block_size = data->blksz;
++      host->dma.req.nr_blocks = data->blocks;
++
++      cmd_flags = MCI_BF(TRCMD, MCI_TRCMD_START_TRANS);
++      if (data->flags & MMC_DATA_STREAM)
++              cmd_flags |= MCI_BF(TRTYP, MCI_TRTYP_STREAM);
++      else if (data->blocks > 1)
++              cmd_flags |= MCI_BF(TRTYP, MCI_TRTYP_MULTI_BLOCK);
++      else
++              cmd_flags |= MCI_BF(TRTYP, MCI_TRTYP_BLOCK);
++
++      if (data->flags & MMC_DATA_READ) {
++              cmd_flags |= MCI_BIT(TRDIR);
++              host->dma.req.nr_sg
++                      = dma_map_sg(&host->pdev->dev, data->sg,
++                                   data->sg_len, DMA_FROM_DEVICE);
++              host->dma.req.periph_id = host->dma.rx_periph_id;
++              host->dma.req.direction = DMA_DIR_PERIPH_TO_MEM;
++              host->dma.req.data_reg = host->mapbase + MCI_RDR;
++      } else {
++              host->dma.req.nr_sg
++                      = dma_map_sg(&host->pdev->dev, data->sg,
++                                   data->sg_len, DMA_TO_DEVICE);
++              host->dma.req.periph_id = host->dma.tx_periph_id;
++              host->dma.req.direction = DMA_DIR_MEM_TO_PERIPH;
++              host->dma.req.data_reg = host->mapbase + MCI_TDR;
++      }
++      host->dma.req.sg = data->sg;
++
++      dma_prepare_request_sg(host->dma.req.req.dmac, &host->dma.req);
++
++      return cmd_flags;
++}
++
++static void atmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++      struct mmc_data *data = mrq->data;
++      u32 iflags;
++      u32 cmdflags = 0;
++
++      iflags = mci_readl(host, IMR);
++      if (iflags)
++              printk("WARNING: IMR=0x%08x\n", mci_readl(host, IMR));
++
++      WARN_ON(host->mrq != NULL);
++      host->mrq = mrq;
++      host->pending_events = 0;
++      host->completed_events = 0;
++
++      iflags = atmci_prepare_command(mmc, mrq->cmd, &cmdflags);
++
++      if (mrq->stop) {
++              BUG_ON(!data);
++
++              host->stop_iflags = atmci_prepare_command(mmc, mrq->stop,
++                                                        &host->stop_cmdr);
++              host->stop_cmdr |= MCI_BF(TRCMD, MCI_TRCMD_STOP_TRANS);
++              if (!(data->flags & MMC_DATA_WRITE))
++                      host->stop_cmdr |= MCI_BIT(TRDIR);
++              if (data->flags & MMC_DATA_STREAM)
++                      host->stop_cmdr |= MCI_BF(TRTYP, MCI_TRTYP_STREAM);
++              else
++                      host->stop_cmdr |= MCI_BF(TRTYP, MCI_TRTYP_MULTI_BLOCK);
++      }
++      if (data) {
++              cmdflags |= atmci_prepare_data(mmc, data);
++              iflags |= MCI_DATA_ERROR_FLAGS;
++      }
++
++      atmci_start_command(host, mrq->cmd, cmdflags);
++      mci_writel(host, IER, iflags);
++}
++
++static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      if (ios->clock) {
++              u32 clkdiv;
++
++              clkdiv = host->bus_hz / (2 * ios->clock) - 1;
++              if (clkdiv > 255)
++                      clkdiv = 255;
++              mci_writel(host, MR, (clkdiv
++                                    | MCI_BIT(WRPROOF)
++                                    | MCI_BIT(RDPROOF)));
++      }
++
++      switch (ios->bus_width) {
++      case MMC_BUS_WIDTH_1:
++              mci_writel(host, SDCR, 0);
++              break;
++      case MMC_BUS_WIDTH_4:
++              mci_writel(host, SDCR, MCI_BIT(SDCBUS));
++              break;
++      }
++
++      switch (ios->power_mode) {
++      case MMC_POWER_OFF:
++              mci_writel(host, CR, MCI_BIT(MCIDIS));
++              break;
++      case MMC_POWER_UP:
++              mci_writel(host, CR, MCI_BIT(SWRST));
++              break;
++      case MMC_POWER_ON:
++              mci_writel(host, CR, MCI_BIT(MCIEN));
++              break;
++      }
++}
++
++static int atmci_get_ro(struct mmc_host *mmc)
++{
++      int read_only = 0;
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      if (host->wp_pin >= 0) {
++              read_only = gpio_get_value(host->wp_pin);
++              pr_debug("%s: card is %s\n", mmc_hostname(mmc),
++                       read_only ? "read-only" : "read-write");
++      } else {
++              pr_debug("%s: no pin for checking read-only switch."
++                       " Assuming write-enable.\n", mmc_hostname(mmc));
++      }
++
++      return read_only;
++}
++
++static struct mmc_host_ops atmci_ops = {
++      .request        = atmci_request,
++      .set_ios        = atmci_set_ios,
++      .get_ro         = atmci_get_ro,
++};
++
++static void atmci_request_end(struct mmc_host *mmc, struct mmc_request *mrq)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      WARN_ON(host->cmd || host->data);
++      host->mrq = NULL;
++
++      mmc_request_done(mmc, mrq);
++}
++
++static void send_stop_cmd(struct mmc_host *mmc, struct mmc_data *data,
++                        u32 flags)
++{
++      struct atmel_mci *host = mmc_priv(mmc);
++
++      atmci_start_command(host, data->stop, host->stop_cmdr | flags);
++      mci_writel(host, IER, host->stop_iflags);
++}
++
++static void atmci_data_complete(struct atmel_mci *host, struct mmc_data *data)
++{
++      host->data = NULL;
++      dma_unmap_sg(&host->pdev->dev, data->sg, host->dma.req.nr_sg,
++                   ((data->flags & MMC_DATA_WRITE)
++                    ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
++
++      /*
++       * Data might complete before command for very short transfers
++       * (like READ_SCR)
++       */
++      if (mci_cmd_is_complete(host)
++          && (!data->stop || mci_stop_is_complete(host)))
++              atmci_request_end(host->mmc, data->mrq);
++}
++
++static void atmci_command_error(