Changeset 7945


Ignore:
Timestamp:
2007-07-12T16:11:31+02:00 (11 years ago)
Author:
kaloz
Message:

upgrade AVR32 to 2.6.22.1

Location:
trunk/target/linux/avr32-2.6
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/avr32-2.6/Makefile

    r7748 r7945  
    1212FEATURES:=squashfs 
    1313 
    14 LINUX_VERSION:=2.6.21.5 
     14LINUX_VERSION:=2.6.22.1 
    1515 
    1616define Target/Description 
  • trunk/target/linux/avr32-2.6/config/default

    r7644 r7945  
    77CONFIG_BOARD_ATNGW100=y 
    88# CONFIG_BOARD_ATSTK1000 is not set 
     9# CONFIG_BROADCOM_PHY is not set 
    910# CONFIG_BT is not set 
    1011CONFIG_CPU_AT32AP7000=y 
     12CONFIG_CPU_FREQ=y 
     13# CONFIG_CPU_FREQ_DEBUG is not set 
     14# CONFIG_CPU_FREQ_STAT is not set 
     15CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y 
     16# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set 
     17CONFIG_CPU_FREQ_GOV_PERFORMANCE=y 
     18# CONFIG_CPU_FREQ_GOV_POWERSAVE is not set 
     19# CONFIG_CPU_FREQ_GOV_USERSPACE is not set 
     20CONFIG_CPU_FREQ_GOV_ONDEMAND=y 
     21# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set 
     22CONFIG_CPU_FREQ_AT32AP=y 
    1123CONFIG_DW_DMAC=y 
    1224CONFIG_ENTRY_ADDRESS=0x90000000 
     25# CONFIG_FIXED_PHY is not set 
    1326# CONFIG_GEN_RTC is not set 
     27# CONFIG_GPIO_DEV is not set 
    1428# CONFIG_HZ_100 is not set 
    1529CONFIG_HZ=250 
     
    1933# CONFIG_IDE is not set 
    2034CONFIG_INITRAMFS_SOURCE="" 
     35CONFIG_LEDS_GPIO=y 
    2136CONFIG_MACB=y 
    2237# CONFIG_MTD_ABSENT is not set 
     
    7388CONFIG_PHYS_OFFSET=0x10000000 
    7489CONFIG_PLATFORM_AT32AP=y 
     90# CONFIG_QSEMI_PHY is not set 
    7591# CONFIG_RTC is not set 
    7692# CONFIG_SERIAL_8250 is not set 
     
    7894# CONFIG_SERIAL_ATMEL_TTYAT is not set 
    7995CONFIG_SERIAL_ATMEL=y 
     96# CONFIG_SMSC_PHY is not set 
    8097# CONFIG_SPI_AT25 is not set 
    8198CONFIG_SPI_ATMEL=y 
  • trunk/target/linux/avr32-2.6/patches/100-git_sync.patch

    r7533 r7945  
    1 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 
    2 --- linux-2.6.21.3/arch/avr32/boards/atngw100/flash.c   1970-01-01 01:00:00.000000000 +0100 
    3 +++ avr32-git/arch/avr32/boards/atngw100/flash.c        2007-06-06 11:33:46.000000000 +0200 
    4 @@ -0,0 +1,95 @@ 
    5 +/* 
    6 + * ATNGW100 board-specific flash initialization 
    7 + * 
    8 + * Copyright (C) 2005-2006 Atmel Corporation 
    9 + * 
    10 + * This program is free software; you can redistribute it and/or modify 
    11 + * it under the terms of the GNU General Public License version 2 as 
    12 + * published by the Free Software Foundation. 
    13 + */ 
    14 +#include <linux/init.h> 
    15 +#include <linux/platform_device.h> 
    16 +#include <linux/mtd/mtd.h> 
    17 +#include <linux/mtd/partitions.h> 
    18 +#include <linux/mtd/physmap.h> 
    19 + 
    20 +#include <asm/arch/smc.h> 
    21 + 
    22 +static struct smc_config flash_config __initdata = { 
    23 +       .ncs_read_setup         = 0, 
    24 +       .nrd_setup              = 40, 
    25 +       .ncs_write_setup        = 0, 
    26 +       .nwe_setup              = 10, 
    27 + 
    28 +       .ncs_read_pulse         = 80, 
    29 +       .nrd_pulse              = 40, 
    30 +       .ncs_write_pulse        = 65, 
    31 +       .nwe_pulse              = 55, 
    32 + 
    33 +       .read_cycle             = 120, 
    34 +       .write_cycle            = 120, 
    35 + 
    36 +       .bus_width              = 2, 
    37 +       .nrd_controlled         = 1, 
    38 +       .nwe_controlled         = 1, 
    39 +       .byte_write             = 1, 
    40 +}; 
    41 + 
    42 +static struct mtd_partition flash_parts[] = { 
    43 +       { 
    44 +               .name           = "u-boot", 
    45 +               .offset         = 0x00000000, 
    46 +               .size           = 0x00020000,           /* 128 KiB */ 
    47 +               .mask_flags     = MTD_WRITEABLE, 
    48 +       }, 
    49 +       { 
    50 +               .name           = "root", 
    51 +               .offset         = 0x00020000, 
    52 +               .size           = 0x007d0000, 
    53 +       }, 
    54 +       { 
    55 +               .name           = "env", 
    56 +               .offset         = 0x007f0000, 
    57 +               .size           = 0x00010000, 
    58 +               .mask_flags     = MTD_WRITEABLE, 
    59 +       }, 
    60 +}; 
    61 + 
    62 +static struct physmap_flash_data flash_data = { 
    63 +       .width          = 2, 
    64 +       .nr_parts       = ARRAY_SIZE(flash_parts), 
    65 +       .parts          = flash_parts, 
    66 +}; 
    67 + 
    68 +static struct resource flash_resource = { 
    69 +       .start          = 0x00000000, 
    70 +       .end            = 0x007fffff, 
    71 +       .flags          = IORESOURCE_MEM, 
    72 +}; 
    73 + 
    74 +static struct platform_device flash_device = { 
    75 +       .name           = "physmap-flash", 
    76 +       .id             = 0, 
    77 +       .resource       = &flash_resource, 
    78 +       .num_resources  = 1, 
    79 +       .dev            = { 
    80 +               .platform_data = &flash_data, 
    81 +       }, 
    82 +}; 
    83 + 
    84 +/* This needs to be called after the SMC has been initialized */ 
    85 +static int __init atngw100_flash_init(void) 
    86 +{ 
    87 +       int ret; 
    88 + 
    89 +       ret = smc_set_configuration(0, &flash_config); 
    90 +       if (ret < 0) { 
    91 +               printk(KERN_ERR "atngw100: failed to set NOR flash timing\n"); 
    92 +               return ret; 
    93 +       } 
    94 + 
    95 +       platform_device_register(&flash_device); 
    96 + 
    97 +       return 0; 
    98 +} 
    99 +device_initcall(atngw100_flash_init); 
    100 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/boards/atngw100/Makefile avr32-git/arch/avr32/boards/atngw100/Makefile 
    101 --- linux-2.6.21.3/arch/avr32/boards/atngw100/Makefile  1970-01-01 01:00:00.000000000 +0100 
    102 +++ avr32-git/arch/avr32/boards/atngw100/Makefile       2007-06-06 11:33:46.000000000 +0200 
    103 @@ -0,0 +1 @@ 
    104 +obj-y                          += setup.o flash.o 
    105 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 
    106 --- linux-2.6.21.3/arch/avr32/boards/atngw100/setup.c   1970-01-01 01:00:00.000000000 +0100 
    107 +++ avr32-git/arch/avr32/boards/atngw100/setup.c        2007-06-06 11:33:46.000000000 +0200 
    108 @@ -0,0 +1,131 @@ 
    109 +/* 
    110 + * Board-specific setup code for the ATNGW100 Network Gateway 
    111 + * 
    112 + * Copyright (C) 2005-2006 Atmel Corporation 
    113 + * 
    114 + * This program is free software; you can redistribute it and/or modify 
    115 + * it under the terms of the GNU General Public License version 2 as 
    116 + * published by the Free Software Foundation. 
    117 + */ 
    118 +#include <linux/clk.h> 
    119 +#include <linux/etherdevice.h> 
    120 +#include <linux/init.h> 
    121 +#include <linux/linkage.h> 
    122 +#include <linux/platform_device.h> 
    123 +#include <linux/types.h> 
    124 +#include <linux/spi/spi.h> 
    125 + 
    126 +#include <asm/io.h> 
    127 +#include <asm/setup.h> 
    128 + 
    129 +#include <asm/arch/at32ap7000.h> 
    130 +#include <asm/arch/board.h> 
    131 +#include <asm/arch/init.h> 
    132 + 
    133 +/* Initialized by bootloader-specific startup code. */ 
    134 +struct tag *bootloader_tags __initdata; 
    135 + 
    136 +struct eth_addr { 
    137 +       u8 addr[6]; 
    138 +}; 
    139 +static struct eth_addr __initdata hw_addr[2]; 
    140 +static struct eth_platform_data __initdata eth_data[2]; 
    141 + 
    142 +static struct spi_board_info spi0_board_info[] __initdata = { 
    143 +       { 
    144 +               .modalias       = "mtd_dataflash", 
    145 +               .max_speed_hz   = 10000000, 
    146 +               .chip_select    = 0, 
    147 +       }, 
    148 +}; 
    149 + 
     1diff -x .git -Nur linux-2.6.22.1/arch/avr32/boards/atngw100/setup.c linux-avr32.git/arch/avr32/boards/atngw100/setup.c 
     2--- linux-2.6.22.1/arch/avr32/boards/atngw100/setup.c   2007-07-10 20:56:30.000000000 +0200 
     3+++ linux-avr32.git/arch/avr32/boards/atngw100/setup.c  2007-07-12 13:59:49.000000000 +0200 
     4@@ -13,6 +13,7 @@ 
     5 #include <linux/linkage.h> 
     6 #include <linux/platform_device.h> 
     7 #include <linux/types.h> 
     8+#include <linux/leds.h> 
     9 #include <linux/spi/spi.h> 
     10  
     11 #include <asm/io.h> 
     12@@ -21,6 +22,7 @@ 
     13 #include <asm/arch/at32ap7000.h> 
     14 #include <asm/arch/board.h> 
     15 #include <asm/arch/init.h> 
     16+#include <asm/arch/portmux.h> 
     17  
     18 /* Initialized by bootloader-specific startup code. */ 
     19 struct tag *bootloader_tags __initdata; 
     20@@ -39,6 +41,11 @@ 
     21        }, 
     22 }; 
     23  
    15024+static struct mci_platform_data __initdata mci0_data = { 
    15125+       .detect_pin     = GPIO_PIN_PC(25), 
     
    15327+}; 
    15428+ 
    155 +/* 
    156 + * The next two functions should go away as the boot loader is 
    157 + * supposed to initialize the macb address registers with a valid 
    158 + * ethernet address. But we need to keep it around for a while until 
    159 + * we can be reasonably sure the boot loader does this. 
    160 + * 
    161 + * The phy_id is ignored as the driver will probe for it. 
    162 + */ 
    163 +static int __init parse_tag_ethernet(struct tag *tag) 
    164 +{ 
    165 +       int i; 
    166 + 
    167 +       i = tag->u.ethernet.mac_index; 
    168 +       if (i < ARRAY_SIZE(hw_addr)) 
    169 +               memcpy(hw_addr[i].addr, tag->u.ethernet.hw_address, 
    170 +                      sizeof(hw_addr[i].addr)); 
    171 + 
    172 +       return 0; 
    173 +} 
    174 +__tagtable(ATAG_ETHERNET, parse_tag_ethernet); 
    175 + 
    176 +static void __init set_hw_addr(struct platform_device *pdev) 
    177 +{ 
    178 +       struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
    179 +       const u8 *addr; 
    180 +       void __iomem *regs; 
    181 +       struct clk *pclk; 
    182 + 
    183 +       if (!res) 
    184 +               return; 
    185 +       if (pdev->id >= ARRAY_SIZE(hw_addr)) 
    186 +               return; 
    187 + 
    188 +       addr = hw_addr[pdev->id].addr; 
    189 +       if (!is_valid_ether_addr(addr)) 
    190 +               return; 
    191 + 
    192 +       /* 
    193 +        * Since this is board-specific code, we'll cheat and use the 
    194 +        * physical address directly as we happen to know that it's 
    195 +        * the same as the virtual address. 
    196 +        */ 
    197 +       regs = (void __iomem __force *)res->start; 
    198 +       pclk = clk_get(&pdev->dev, "pclk"); 
    199 +       if (!pclk) 
    200 +               return; 
    201 + 
    202 +       clk_enable(pclk); 
    203 +       __raw_writel((addr[3] << 24) | (addr[2] << 16) 
    204 +                    | (addr[1] << 8) | addr[0], regs + 0x98); 
    205 +       __raw_writel((addr[5] << 8) | addr[4], regs + 0x9c); 
    206 +       clk_disable(pclk); 
    207 +       clk_put(pclk); 
    208 +} 
    209 + 
    210 +struct platform_device *at32_usart_map[1]; 
    211 +unsigned int at32_nr_usarts = 1; 
    212 + 
    213 +void __init setup_board(void) 
    214 +{ 
    215 +       at32_map_usart(1, 0);   /* USART 1: /dev/ttyS0, DB9 */ 
    216 +       at32_setup_serial_console(0); 
    217 +} 
    218 + 
    219 +static int __init atngw100_init(void) 
    220 +{ 
    221 +       /* 
    222 +        * ATNGW100 uses 16-bit SDRAM interface, so we don't need to 
    223 +        * reserve any pins for it. 
    224 +        */ 
    225 + 
    226 +       at32_add_system_devices(); 
    227 + 
    228 +       at32_add_device_usart(0); 
    229 + 
    230 +       set_hw_addr(at32_add_device_eth(0, &eth_data[0])); 
    231 +       set_hw_addr(at32_add_device_eth(1, &eth_data[1])); 
    232 + 
    233 +       at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info)); 
     29 /* 
     30  * The next two functions should go away as the boot loader is 
     31  * supposed to initialize the macb address registers with a valid 
     32@@ -100,8 +107,31 @@ 
     33        at32_setup_serial_console(0); 
     34 } 
     35  
     36+static const struct gpio_led ngw_leds[] = { 
     37+       { .name = "sys", .gpio = GPIO_PIN_PA(16), .active_low = 1, 
     38+               .default_trigger = "heartbeat", 
     39+       }, 
     40+       { .name = "a", .gpio = GPIO_PIN_PA(19), .active_low = 1, }, 
     41+       { .name = "b", .gpio = GPIO_PIN_PE(19), .active_low = 1, }, 
     42+}; 
     43+ 
     44+static const struct gpio_led_platform_data ngw_led_data = { 
     45+       .num_leds =     ARRAY_SIZE(ngw_leds), 
     46+       .leds =         (void *) ngw_leds, 
     47+}; 
     48+ 
     49+static struct platform_device ngw_gpio_leds = { 
     50+       .name =         "leds-gpio", 
     51+       .id =           -1, 
     52+       .dev = { 
     53+               .platform_data = (void *) &ngw_led_data, 
     54+       } 
     55+}; 
     56+ 
     57 static int __init atngw100_init(void) 
     58 { 
     59+       unsigned        i; 
     60+ 
     61        /* 
     62         * ATNGW100 uses 16-bit SDRAM interface, so we don't need to 
     63         * reserve any pins for it. 
     64@@ -115,6 +145,14 @@ 
     65        set_hw_addr(at32_add_device_eth(1, &eth_data[1])); 
     66  
     67        at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info)); 
    23468+       at32_add_device_mci(0, &mci0_data); 
    235 +       at32_add_device_usba(0); 
    236 + 
    237 +       return 0; 
    238 +} 
    239 +postcore_initcall(atngw100_init); 
    240 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 
    241 --- linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1000.h      1970-01-01 01:00:00.000000000 +0100 
    242 +++ avr32-git/arch/avr32/boards/atstk1000/atstk1000.h   2007-06-06 11:33:46.000000000 +0200 
    243 @@ -0,0 +1,15 @@ 
    244 +/* 
    245 + * ATSTK1000 setup code: Daughterboard interface 
    246 + * 
    247 + * Copyright (C) 2007 Atmel Corporation 
    248 + * 
    249 + * This program is free software; you can redistribute it and/or modify 
    250 + * it under the terms of the GNU General Public License version 2 as 
    251 + * published by the Free Software Foundation. 
    252 + */ 
    253 +#ifndef __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H 
    254 +#define __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H 
    255 + 
    256 +extern struct atmel_lcdfb_info atstk1000_lcdc_data; 
    257 + 
    258 +#endif /* __ARCH_AVR32_BOARDS_ATSTK1000_ATSTK1000_H */ 
    259 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 
    260 --- linux-2.6.21.3/arch/avr32/boards/atstk1000/atstk1002.c      2007-05-24 23:22:47.000000000 +0200 
    261 +++ avr32-git/arch/avr32/boards/atstk1000/atstk1002.c   2007-06-06 11:33:46.000000000 +0200 
    262 @@ -16,6 +16,8 @@ 
     69+       at32_add_device_usba(0, NULL); 
     70+ 
     71+       for (i = 0; i < ARRAY_SIZE(ngw_leds); i++) { 
     72+               at32_select_gpio(ngw_leds[i].gpio, 
     73+                               AT32_GPIOF_OUTPUT | AT32_GPIOF_HIGH); 
     74+       } 
     75+       platform_device_register(&ngw_gpio_leds); 
     76  
     77        return 0; 
     78 } 
     79diff -x .git -Nur linux-2.6.22.1/arch/avr32/boards/atstk1000/atstk1002.c linux-avr32.git/arch/avr32/boards/atstk1000/atstk1002.c 
     80--- linux-2.6.22.1/arch/avr32/boards/atstk1000/atstk1002.c      2007-07-10 20:56:30.000000000 +0200 
     81+++ linux-avr32.git/arch/avr32/boards/atstk1000/atstk1002.c     2007-07-12 13:59:49.000000000 +0200 
     82@@ -11,6 +11,7 @@ 
     83 #include <linux/etherdevice.h> 
     84 #include <linux/init.h> 
     85 #include <linux/kernel.h> 
     86+#include <linux/leds.h> 
     87 #include <linux/platform_device.h> 
     88 #include <linux/string.h> 
    26389 #include <linux/types.h> 
    264  #include <linux/spi/spi.h> 
    265   
    266 +#include <video/atmel_lcdc.h> 
    267 + 
    268  #include <asm/io.h> 
    269  #include <asm/setup.h> 
    270  #include <asm/arch/at32ap7000.h> 
    271 @@ -23,6 +25,7 @@ 
    272  #include <asm/arch/init.h> 
    273  #include <asm/arch/portmux.h> 
    274   
    275 +#include "atstk1000.h" 
    276   
    277  #define        SW2_DEFAULT             /* MMCI and UART_A available */ 
    278   
    279 @@ -31,9 +34,7 @@ 
    280  }; 
    281   
     90@@ -27,7 +28,6 @@ 
     91  
     92 #include "atstk1000.h" 
     93  
     94-#define        SW2_DEFAULT             /* MMCI and UART_A available */ 
     95  
     96 struct eth_addr { 
     97        u8 addr[6]; 
     98@@ -36,6 +36,7 @@ 
    28299 static struct eth_addr __initdata hw_addr[2]; 
    283 - 
    284100 static struct eth_platform_data __initdata eth_data[2]; 
    285 -extern struct lcdc_platform_data atstk1000_fb0_data; 
    286   
     101  
     102+#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM 
    287103 static struct spi_board_info spi0_board_info[] __initdata = { 
    288104        { 
    289 @@ -41,9 +42,15 @@ 
    290                 .modalias       = "ltv350qv", 
    291                 .max_speed_hz   = 16000000, 
    292                 .chip_select    = 1, 
    293 +               .mode           = SPI_MODE_3, 
     105                /* QVGA display */ 
     106@@ -45,6 +46,18 @@ 
     107                .mode           = SPI_MODE_3, 
    294108        }, 
    295109 }; 
    296   
     110+#endif 
     111+ 
     112+#ifdef CONFIG_BOARD_ATSTK1002_SPI1 
     113+static struct spi_board_info spi1_board_info[] __initdata = { { 
     114+       /* patch in custom entries here */ 
     115+} }; 
     116+#endif 
     117+ 
    297118+static struct mci_platform_data __initdata mci0_data = { 
    298119+       .detect_pin     = GPIO_PIN_NONE, 
    299120+       .wp_pin         = GPIO_PIN_NONE, 
    300121+}; 
    301 + 
     122  
    302123 /* 
    303124  * The next two functions should go away as the boot loader is 
    304   * supposed to initialize the macb address registers with a valid 
    305 @@ -148,7 +155,12 @@ 
     125@@ -101,12 +114,71 @@ 
     126        clk_put(pclk); 
     127 } 
     128  
     129-void __init setup_board(void) 
     130+#ifdef CONFIG_BOARD_ATSTK1002_J2_LED 
     131+ 
     132+static struct gpio_led stk_j2_led[] = { 
     133+#ifdef CONFIG_BOARD_ATSTK1002_J2_LED8 
     134+#define LEDSTRING "J2 jumpered to LED8" 
     135+       { .name = "led0:amber", .gpio = GPIO_PIN_PB( 8), }, 
     136+       { .name = "led1:amber", .gpio = GPIO_PIN_PB( 9), }, 
     137+       { .name = "led2:amber", .gpio = GPIO_PIN_PB(10), }, 
     138+       { .name = "led3:amber", .gpio = GPIO_PIN_PB(13), }, 
     139+       { .name = "led4:amber", .gpio = GPIO_PIN_PB(14), }, 
     140+       { .name = "led5:amber", .gpio = GPIO_PIN_PB(15), }, 
     141+       { .name = "led6:amber", .gpio = GPIO_PIN_PB(16), }, 
     142+       { .name = "led7:amber", .gpio = GPIO_PIN_PB(30), 
     143+                       .default_trigger = "heartbeat", }, 
     144+#else  /* RGB */ 
     145+#define LEDSTRING "J2 jumpered to RGB LEDs" 
     146+       { .name = "r1:red",     .gpio = GPIO_PIN_PB( 8), }, 
     147+       { .name = "g1:green",   .gpio = GPIO_PIN_PB(10), }, 
     148+       { .name = "b1:blue",    .gpio = GPIO_PIN_PB(14), }, 
     149+ 
     150+       { .name = "r2:red",     .gpio = GPIO_PIN_PB( 9), 
     151+                       .default_trigger = "heartbeat", }, 
     152+       { .name = "g2:green",   .gpio = GPIO_PIN_PB(13), }, 
     153+       { .name = "b2:blue",    .gpio = GPIO_PIN_PB(15), 
     154+                       .default_trigger = "heartbeat", }, 
     155+       /* PB16, PB30 unused */ 
     156+#endif 
     157+}; 
     158+ 
     159+static struct gpio_led_platform_data stk_j2_led_data = { 
     160+       .num_leds       = ARRAY_SIZE(stk_j2_led), 
     161+       .leds           = stk_j2_led, 
     162+}; 
     163+ 
     164+static struct platform_device stk_j2_led_dev = { 
     165+       .name           = "leds-gpio", 
     166+       .id             = 2,    /* gpio block J2 */ 
     167+       .dev            = { 
     168+               .platform_data  = &stk_j2_led_data, 
     169+       }, 
     170+}; 
     171+ 
     172+static void setup_j2_leds(void) 
     173 { 
     174-#ifdef SW2_DEFAULT 
     175-       at32_map_usart(1, 0);   /* USART 1/A: /dev/ttyS0, DB9 */ 
     176+       unsigned        i; 
     177+ 
     178+       for (i = 0; i < ARRAY_SIZE(stk_j2_led); i++) 
     179+               at32_select_gpio(stk_j2_led[i].gpio, AT32_GPIOF_OUTPUT); 
     180+ 
     181+       printk("STK1002: " LEDSTRING "\n"); 
     182+       platform_device_register(&stk_j2_led_dev); 
     183+} 
     184+ 
     185 #else 
     186+static void setup_j2_leds(void) 
     187+{ 
     188+} 
     189+#endif 
     190+ 
     191+void __init setup_board(void) 
     192+{ 
     193+#ifdef CONFIG_BOARD_ATSTK1002_SW2_CUSTOM 
     194        at32_map_usart(0, 1);   /* USART 0/B: /dev/ttyS1, IRDA */ 
     195+#else 
     196+       at32_map_usart(1, 0);   /* USART 1/A: /dev/ttyS0, DB9 */ 
     197 #endif 
     198        /* USART 2/unused: expansion connector */ 
     199        at32_map_usart(3, 2);   /* USART 3/C: /dev/ttyS2, DB9 */ 
     200@@ -140,18 +212,40 @@ 
     201  
     202        at32_add_system_devices(); 
     203  
     204-#ifdef SW2_DEFAULT 
     205-       at32_add_device_usart(0); 
     206-#else 
     207+#ifdef CONFIG_BOARD_ATSTK1002_SW2_CUSTOM 
     208        at32_add_device_usart(1); 
     209+#else 
     210+       at32_add_device_usart(0); 
     211 #endif 
     212        at32_add_device_usart(2); 
     213  
     214+#ifndef CONFIG_BOARD_ATSTK1002_SW6_CUSTOM 
    306215        set_hw_addr(at32_add_device_eth(0, &eth_data[0])); 
    307   
    308         at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info)); 
    309 -       at32_add_device_lcdc(0, &atstk1000_fb0_data); 
     216- 
     217-       at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info)); 
     218+#endif 
     219+#ifdef CONFIG_BOARD_ATSTK1002_SW5_CUSTOM 
     220+       set_hw_addr(at32_add_device_eth(1, &eth_data[1])); 
     221+#else 
     222        at32_add_device_lcdc(0, &atstk1000_lcdc_data, 
     223                             fbmem_start, fbmem_size); 
     224+#endif 
     225+ 
     226+#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM 
     227+       at32_add_device_spi(0, spi0_board_info, ARRAY_SIZE(spi0_board_info)); 
     228+#endif 
     229+#ifdef CONFIG_BOARD_ATSTK1002_SPI1 
     230+       at32_add_device_spi(1, spi1_board_info, ARRAY_SIZE(spi1_board_info)); 
     231+#endif 
    310232+       at32_add_device_twi(0); 
     233+#ifndef CONFIG_BOARD_ATSTK1002_SW2_CUSTOM 
    311234+       at32_add_device_mci(0, &mci0_data); 
    312 +       at32_add_device_lcdc(0, &atstk1000_lcdc_data, 
    313 +                            fbmem_start, fbmem_size); 
    314 +       at32_add_device_usba(0); 
     235+#endif 
     236+       at32_add_device_usba(0, NULL); 
    315237+       at32_add_device_abdac(0); 
     238+#ifndef CONFIG_BOARD_ATSTK1002_SW3_CUSTOM 
     239+       at32_add_device_ssc(0, ATMEL_SSC_TX); 
     240+#endif 
     241+ 
     242+       setup_j2_leds(); 
    316243  
    317244        return 0; 
    318245 } 
    319 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 
    320 --- linux-2.6.21.3/arch/avr32/boards/atstk1000/setup.c  2007-05-24 23:22:47.000000000 +0200 
    321 +++ avr32-git/arch/avr32/boards/atstk1000/setup.c       2007-06-06 11:33:46.000000000 +0200 
    322 @@ -8,43 +8,56 @@ 
    323   * published by the Free Software Foundation. 
    324   */ 
    325  #include <linux/bootmem.h> 
    326 +#include <linux/fb.h> 
    327  #include <linux/init.h> 
    328  #include <linux/types.h> 
    329  #include <linux/linkage.h> 
    330   
    331 -#include <asm/setup.h> 
    332 +#include <video/atmel_lcdc.h> 
    333   
    334 +#include <asm/setup.h> 
    335  #include <asm/arch/board.h> 
    336   
    337 +#include "atstk1000.h" 
    338 + 
    339  /* Initialized by bootloader-specific startup code. */ 
    340  struct tag *bootloader_tags __initdata; 
    341   
    342 -struct lcdc_platform_data __initdata atstk1000_fb0_data; 
    343 - 
    344 -void __init board_setup_fbmem(unsigned long fbmem_start, 
    345 -                             unsigned long fbmem_size) 
    346 -{ 
    347 -       if (!fbmem_size) 
    348 -               return; 
    349 - 
    350 -       if (!fbmem_start) { 
    351 -               void *fbmem; 
    352 - 
    353 -               fbmem = alloc_bootmem_low_pages(fbmem_size); 
    354 -               fbmem_start = __pa(fbmem); 
    355 -       } else { 
    356 -               pg_data_t *pgdat; 
    357 - 
    358 -               for_each_online_pgdat(pgdat) { 
    359 -                       if (fbmem_start >= pgdat->bdata->node_boot_start 
    360 -                           && fbmem_start <= pgdat->bdata->node_low_pfn) 
    361 -                               reserve_bootmem_node(pgdat, fbmem_start, 
    362 -                                                    fbmem_size); 
    363 -               } 
    364 -       } 
    365 - 
    366 -       printk("%luKiB framebuffer memory at address 0x%08lx\n", 
    367 -              fbmem_size >> 10, fbmem_start); 
    368 -       atstk1000_fb0_data.fbmem_start = fbmem_start; 
    369 -       atstk1000_fb0_data.fbmem_size = fbmem_size; 
    370 -} 
    371 +static struct fb_videomode __initdata ltv350qv_modes[] = { 
    372 +       { 
    373 +               .name           = "320x240 @ 75", 
    374 +               .refresh        = 75, 
    375 +               .xres           = 320,          .yres           = 240, 
    376 +               .pixclock       = KHZ2PICOS(6891), 
    377 + 
    378 +               .left_margin    = 17,           .right_margin   = 33, 
    379 +               .upper_margin   = 10,           .lower_margin   = 10, 
    380 +               .hsync_len      = 16,           .vsync_len      = 1, 
    381 + 
    382 +               .sync           = 0, 
    383 +               .vmode          = FB_VMODE_NONINTERLACED, 
    384 +       }, 
    385 +}; 
    386 + 
    387 +static struct fb_monspecs __initdata atstk1000_default_monspecs = { 
    388 +       .manufacturer           = "SNG", 
    389 +       .monitor                = "LTV350QV", 
    390 +       .modedb                 = ltv350qv_modes, 
    391 +       .modedb_len             = ARRAY_SIZE(ltv350qv_modes), 
    392 +       .hfmin                  = 14820, 
    393 +       .hfmax                  = 22230, 
    394 +       .vfmin                  = 60, 
    395 +       .vfmax                  = 90, 
    396 +       .dclkmax                = 30000000, 
    397 +}; 
    398 + 
    399 +struct atmel_lcdfb_info __initdata atstk1000_lcdc_data = { 
    400 +       .default_bpp            = 24, 
    401 +       .default_dmacon         = ATMEL_LCDC_DMAEN | ATMEL_LCDC_DMA2DEN, 
    402 +       .default_lcdcon2        = (ATMEL_LCDC_DISTYPE_TFT 
    403 +                                  | ATMEL_LCDC_INVCLK 
    404 +                                  | ATMEL_LCDC_CLKMOD_ALWAYSACTIVE 
    405 +                                  | ATMEL_LCDC_MEMOR_BIG), 
    406 +       .default_monspecs       = &atstk1000_default_monspecs, 
    407 +       .guard_time             = 2, 
    408 +}; 
    409 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 
    410 --- linux-2.6.21.3/arch/avr32/drivers/dw-dmac.c 1970-01-01 01:00:00.000000000 +0100 
    411 +++ avr32-git/arch/avr32/drivers/dw-dmac.c      2007-06-06 11:33:46.000000000 +0200 
     246diff -x .git -Nur linux-2.6.22.1/arch/avr32/boards/atstk1000/Kconfig linux-avr32.git/arch/avr32/boards/atstk1000/Kconfig 
     247--- linux-2.6.22.1/arch/avr32/boards/atstk1000/Kconfig  1970-01-01 01:00:00.000000000 +0100 
     248+++ linux-avr32.git/arch/avr32/boards/atstk1000/Kconfig 2007-07-12 13:59:49.000000000 +0200 
     249@@ -0,0 +1,79 @@ 
     250+# STK1000 customization 
     251+ 
     252+if BOARD_ATSTK1002 
     253+ 
     254+config BOARD_ATSTK1002_CUSTOM 
     255+       bool "Non-default STK-1002 jumper settings" 
     256+       help 
     257+         You will normally leave the jumpers on the CPU card at their 
     258+         default settings.  If you need to use certain peripherals, 
     259+         you will need to change some of those jumpers. 
     260+ 
     261+if BOARD_ATSTK1002_CUSTOM 
     262+ 
     263+config BOARD_ATSTK1002_SW1_CUSTOM 
     264+       bool "SW1: use SSC1 (not SPI0)" 
     265+       help 
     266+         This also prevents using the external DAC as an audio interface, 
     267+         and means you can't initialize the on-board QVGA display. 
     268+ 
     269+config BOARD_ATSTK1002_SW2_CUSTOM 
     270+       bool "SW2: use IRDA or TIMER0 (not UART-A, MMC/SD, and PS2-A)" 
     271+       help 
     272+         If you change this you'll want an updated boot loader putting 
     273+         the console on UART-C not UART-A. 
     274+ 
     275+config BOARD_ATSTK1002_SW3_CUSTOM 
     276+       bool "SW3: use TIMER1 (not SSC0 and GCLK)" 
     277+       help 
     278+         This also prevents using the external DAC as an audio interface. 
     279+ 
     280+config BOARD_ATSTK1002_SW4_CUSTOM 
     281+       bool "SW4: use ISI/Camera (not GPIOs, SPI1, and PS2-B)" 
     282+       help 
     283+         To use the camera interface you'll need a custom card (on the 
     284+         PCI-format connector) connect a video sensor. 
     285+ 
     286+config BOARD_ATSTK1002_SW5_CUSTOM 
     287+       bool "SW5: use MACB1 (not LCDC)" 
     288+ 
     289+config BOARD_ATSTK1002_SW6_CUSTOM 
     290+       bool "SW6: more GPIOs (not MACB0)" 
     291+ 
     292+endif  # custom 
     293+ 
     294+config BOARD_ATSTK1002_SPI1 
     295+       bool "Configure SPI1 controller" 
     296+       depends on !BOARD_ATSTK1002_SW4_CUSTOM 
     297+       help 
     298+         All the signals for the second SPI controller are available on 
     299+         GPIO lines and accessed through the J1 jumper block.  Say "y" 
     300+         here to configure that SPI controller. 
     301+ 
     302+config BOARD_ATSTK1002_J2_LED 
     303+       bool 
     304+       default BOARD_ATSTK1002_J2_LED8 || BOARD_ATSTK1002_J2_RGB 
     305+ 
     306+choice 
     307+       prompt "LEDs connected to J2:" 
     308+       depends on LEDS_GPIO && !BOARD_ATSTK1002_SW4_CUSTOM 
     309+       optional 
     310+       help 
     311+         Select this if you have jumpered the J2 jumper block to the 
     312+         LED0..LED7 amber leds, or to the RGB leds, using a ten-pin 
     313+         IDC cable.  A default "heartbeat" trigger is provided, but 
     314+         you can of course override this. 
     315+ 
     316+config BOARD_ATSTK1002_J2_LED8 
     317+       bool "LED0..LED7" 
     318+       help 
     319+         Select this if J2 is jumpered to LED0..LED7 amber leds. 
     320+ 
     321+config BOARD_ATSTK1002_J2_RGB 
     322+       bool "RGB leds" 
     323+       help 
     324+         Select this if J2 is jumpered to the RGB leds. 
     325+ 
     326+endchoice 
     327+ 
     328+endif  # stk 1002 
     329diff -x .git -Nur linux-2.6.22.1/arch/avr32/configs/atngw100_defconfig linux-avr32.git/arch/avr32/configs/atngw100_defconfig 
     330--- linux-2.6.22.1/arch/avr32/configs/atngw100_defconfig        2007-07-10 20:56:30.000000000 +0200 
     331+++ linux-avr32.git/arch/avr32/configs/atngw100_defconfig       2007-07-12 13:59:49.000000000 +0200 
     332@@ -712,7 +712,21 @@ 
     333 # 
     334 # LED devices 
     335 # 
     336-# CONFIG_NEW_LEDS is not set 
     337+CONFIG_NEW_LEDS=y 
     338+CONFIG_LEDS_CLASS=y 
     339+ 
     340+# 
     341+# LED drivers 
     342+# 
     343+CONFIG_LEDS_GPIO=y 
     344+ 
     345+# 
     346+# LED Triggers 
     347+# 
     348+CONFIG_LEDS_TRIGGERS=y 
     349+CONFIG_LEDS_TRIGGER_TIMER=y 
     350+CONFIG_LEDS_TRIGGER_HEARTBEAT=y 
     351+ 
     352  
     353 # 
     354 # LED drivers 
     355diff -x .git -Nur linux-2.6.22.1/arch/avr32/drivers/dw-dmac.c linux-avr32.git/arch/avr32/drivers/dw-dmac.c 
     356--- linux-2.6.22.1/arch/avr32/drivers/dw-dmac.c 1970-01-01 01:00:00.000000000 +0100 
     357+++ linux-avr32.git/arch/avr32/drivers/dw-dmac.c        2007-06-06 11:33:46.000000000 +0200 
    412358@@ -0,0 +1,761 @@ 
    413359+/* 
     
    11231069+ 
    11241070+       ret = request_irq(platform_get_irq(pdev, 0), dmac_interrupt, 
    1125 +                         SA_SAMPLE_RANDOM, pdev->name, dmac); 
     1071+                         IRQF_SAMPLE_RANDOM, pdev->name, dmac); 
    11261072+       if (ret) 
    11271073+               goto out_unmap_regs; 
     
    11721118+MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>"); 
    11731119+MODULE_LICENSE("GPL"); 
    1174 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 
    1175 --- linux-2.6.21.3/arch/avr32/drivers/dw-dmac.h 1970-01-01 01:00:00.000000000 +0100 
    1176 +++ avr32-git/arch/avr32/drivers/dw-dmac.h      2007-06-06 11:33:46.000000000 +0200 
     1120diff -x .git -Nur linux-2.6.22.1/arch/avr32/drivers/dw-dmac.h linux-avr32.git/arch/avr32/drivers/dw-dmac.h 
     1121--- linux-2.6.22.1/arch/avr32/drivers/dw-dmac.h 1970-01-01 01:00:00.000000000 +0100 
     1122+++ linux-avr32.git/arch/avr32/drivers/dw-dmac.h        2007-06-06 11:33:46.000000000 +0200 
    11771123@@ -0,0 +1,42 @@ 
    11781124+/* 
     
    12181164+ 
    12191165+#endif /* __AVR32_DW_DMAC_H__ */ 
    1220 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/drivers/Makefile avr32-git/arch/avr32/drivers/Makefile 
    1221 --- linux-2.6.21.3/arch/avr32/drivers/Makefile  1970-01-01 01:00:00.000000000 +0100 
    1222 +++ avr32-git/arch/avr32/drivers/Makefile       2007-06-06 11:33:46.000000000 +0200 
     1166diff -x .git -Nur linux-2.6.22.1/arch/avr32/drivers/Makefile linux-avr32.git/arch/avr32/drivers/Makefile 
     1167--- linux-2.6.22.1/arch/avr32/drivers/Makefile  1970-01-01 01:00:00.000000000 +0100 
     1168+++ linux-avr32.git/arch/avr32/drivers/Makefile 2007-06-06 11:33:46.000000000 +0200 
    12231169@@ -0,0 +1 @@ 
    12241170+obj-$(CONFIG_DW_DMAC)                  += dw-dmac.o 
    1225 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Kconfig avr32-git/arch/avr32/Kconfig 
    1226 --- linux-2.6.21.3/arch/avr32/Kconfig   2007-05-24 23:22:47.000000000 +0200 
    1227 +++ avr32-git/arch/avr32/Kconfig        2007-06-06 11:33:46.000000000 +0200 
    1228 @@ -57,9 +57,6 @@ 
    1229         bool 
    1230         default n 
    1231   
    1232 -config GENERIC_BUST_SPINLOCK 
    1233 -       bool 
    1234 - 
    1235  config GENERIC_HWEIGHT 
    1236         bool 
    1237         default y 
    1238 @@ -68,6 +65,11 @@ 
    1239         bool 
    1240         default y 
    1241   
    1242 +config GENERIC_BUG 
    1243 +       bool 
    1244 +       default y 
    1245 +       depends on BUG 
    1246 + 
    1247  source "init/Kconfig" 
    1248   
    1249  menu "System Type and features" 
    1250 @@ -106,6 +108,9 @@ 
    1251  config BOARD_ATSTK1000 
    1252         bool "ATSTK1000 evaluation board" 
    1253         select BOARD_ATSTK1002 if CPU_AT32AP7000 
    1254 + 
    1255 +config BOARD_ATNGW100 
    1256 +       bool "ATNGW100 Network Gateway" 
     1171diff -x .git -Nur linux-2.6.22.1/arch/avr32/Kconfig linux-avr32.git/arch/avr32/Kconfig 
     1172--- linux-2.6.22.1/arch/avr32/Kconfig   2007-07-10 20:56:30.000000000 +0200 
     1173+++ linux-avr32.git/arch/avr32/Kconfig  2007-07-12 13:59:49.000000000 +0200 
     1174@@ -113,6 +113,10 @@ 
     1175        bool "ATNGW100 Network Gateway" 
    12571176 endchoice 
    12581177  
     1178+if BOARD_ATSTK1000 
     1179+source "arch/avr32/boards/atstk1000/Kconfig" 
     1180+endif 
     1181+ 
    12591182 choice 
    1260 @@ -116,6 +121,8 @@ 
    1261         bool "U-Boot (or similar) bootloader" 
    1262  endchoice 
    1263   
    1264 +source "arch/avr32/mach-at32ap/Kconfig" 
    1265 + 
    1266  config LOAD_ADDRESS 
    1267         hex 
    1268         default 0x10000000 if LOADER_U_BOOT=y && CPU_AT32AP7000=y 
    1269 @@ -164,6 +171,10 @@ 
     1183        prompt "Boot loader type" 
     1184        default LOADER_U_BOOT 
     1185@@ -171,6 +175,10 @@ 
    12701186          enabling Nexus-compliant debuggers to keep track of the PID of the 
    12711187          currently executing task. 
     
    12781194  
    12791195 source "kernel/Kconfig.hz" 
    1280 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/cpu.c avr32-git/arch/avr32/kernel/cpu.c 
    1281 --- linux-2.6.21.3/arch/avr32/kernel/cpu.c      2007-05-24 23:22:47.000000000 +0200 
    1282 +++ avr32-git/arch/avr32/kernel/cpu.c   2007-06-06 11:33:46.000000000 +0200 
    1283 @@ -209,16 +209,17 @@ 
    1284  void __init setup_processor(void) 
    1285  { 
    1286         unsigned long config0, config1; 
    1287 +       unsigned long features; 
    1288         unsigned cpu_id, cpu_rev, arch_id, arch_rev, mmu_type; 
    1289         unsigned tmp; 
    1290   
    1291 -       config0 = sysreg_read(CONFIG0); /* 0x0000013e; */ 
    1292 -       config1 = sysreg_read(CONFIG1); /* 0x01f689a2; */ 
    1293 -       cpu_id = config0 >> 24; 
    1294 -       cpu_rev = (config0 >> 16) & 0xff; 
    1295 -       arch_id = (config0 >> 13) & 0x07; 
    1296 -       arch_rev = (config0 >> 10) & 0x07; 
    1297 -       mmu_type = (config0 >> 7) & 0x03; 
    1298 +       config0 = sysreg_read(CONFIG0); 
    1299 +       config1 = sysreg_read(CONFIG1); 
    1300 +       cpu_id = SYSREG_BFEXT(PROCESSORID, config0); 
    1301 +       cpu_rev = SYSREG_BFEXT(PROCESSORREVISION, config0); 
    1302 +       arch_id = SYSREG_BFEXT(AT, config0); 
    1303 +       arch_rev = SYSREG_BFEXT(AR, config0); 
    1304 +       mmu_type = SYSREG_BFEXT(MMUT, config0); 
    1305   
    1306         boot_cpu_data.arch_type = arch_id; 
    1307         boot_cpu_data.cpu_type = cpu_id; 
    1308 @@ -226,16 +227,16 @@ 
    1309         boot_cpu_data.cpu_revision = cpu_rev; 
    1310         boot_cpu_data.tlb_config = mmu_type; 
    1311   
    1312 -       tmp = (config1 >> 13) & 0x07; 
    1313 +       tmp = SYSREG_BFEXT(ILSZ, config1); 
    1314         if (tmp) { 
    1315 -               boot_cpu_data.icache.ways = 1 << ((config1 >> 10) & 0x07); 
    1316 -               boot_cpu_data.icache.sets = 1 << ((config1 >> 16) & 0x0f); 
    1317 +               boot_cpu_data.icache.ways = 1 << SYSREG_BFEXT(IASS, config1); 
    1318 +               boot_cpu_data.icache.sets = 1 << SYSREG_BFEXT(ISET, config1); 
    1319                 boot_cpu_data.icache.linesz = 1 << (tmp + 1); 
    1320         } 
    1321 -       tmp = (config1 >> 3) & 0x07; 
    1322 +       tmp = SYSREG_BFEXT(DLSZ, config1); 
    1323         if (tmp) { 
    1324 -               boot_cpu_data.dcache.ways = 1 << (config1 & 0x07); 
    1325 -               boot_cpu_data.dcache.sets = 1 << ((config1 >> 6) & 0x0f); 
    1326 +               boot_cpu_data.dcache.ways = 1 << SYSREG_BFEXT(DASS, config1); 
    1327 +               boot_cpu_data.dcache.sets = 1 << SYSREG_BFEXT(DSET, config1); 
    1328                 boot_cpu_data.dcache.linesz = 1 << (tmp + 1); 
    1329         } 
    1330   
    1331 @@ -250,16 +251,39 @@ 
    1332                 cpu_names[cpu_id], cpu_id, cpu_rev, 
    1333                 arch_names[arch_id], arch_rev); 
    1334         printk ("CPU: MMU configuration: %s\n", mmu_types[mmu_type]); 
    1335 + 
    1336         printk ("CPU: features:"); 
    1337 -       if (config0 & (1 << 6)) 
    1338 -               printk(" fpu"); 
    1339 -       if (config0 & (1 << 5)) 
    1340 -               printk(" java"); 
    1341 -       if (config0 & (1 << 4)) 
    1342 -               printk(" perfctr"); 
    1343 -       if (config0 & (1 << 3)) 
    1344 +       features = 0; 
    1345 +       if (config0 & SYSREG_BIT(CONFIG0_R)) { 
    1346 +               features |= AVR32_FEATURE_RMW; 
    1347 +               printk(" rmw"); 
    1348 +       } 
    1349 +       if (config0 & SYSREG_BIT(CONFIG0_D)) { 
    1350 +               features |= AVR32_FEATURE_DSP; 
    1351 +               printk(" dsp"); 
    1352 +       } 
    1353 +       if (config0 & SYSREG_BIT(CONFIG0_S)) { 
    1354 +               features |= AVR32_FEATURE_SIMD; 
    1355 +               printk(" simd"); 
    1356 +       } 
    1357 +       if (config0 & SYSREG_BIT(CONFIG0_O)) { 
    1358 +               features |= AVR32_FEATURE_OCD; 
    1359                 printk(" ocd"); 
    1360 +       } 
    1361 +       if (config0 & SYSREG_BIT(CONFIG0_P)) { 
    1362 +               features |= AVR32_FEATURE_PCTR; 
    1363 +               printk(" perfctr"); 
    1364 +       } 
    1365 +       if (config0 & SYSREG_BIT(CONFIG0_J)) { 
    1366 +               features |= AVR32_FEATURE_JAVA; 
    1367 +               printk(" java"); 
    1368 +       } 
    1369 +       if (config0 & SYSREG_BIT(CONFIG0_F)) { 
    1370 +               features |= AVR32_FEATURE_FPU; 
    1371 +               printk(" fpu"); 
    1372 +       } 
    1373         printk("\n"); 
    1374 +       boot_cpu_data.features = features; 
    1375  } 
    1376   
    1377  #ifdef CONFIG_PROC_FS 
    1378 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 
    1379 --- linux-2.6.21.3/arch/avr32/kernel/dma-controller.c   1970-01-01 01:00:00.000000000 +0100 
    1380 +++ avr32-git/arch/avr32/kernel/dma-controller.c        2007-06-06 11:33:46.000000000 +0200 
     1196@@ -185,6 +193,27 @@ 
     1197  
     1198 endmenu 
     1199  
     1200+menu "Power managment options" 
     1201+ 
     1202+menu "CPU Frequency scaling" 
     1203+ 
     1204+source "drivers/cpufreq/Kconfig" 
     1205+ 
     1206+config CPU_FREQ_AT32AP 
     1207+       bool "CPU frequency driver for AT32AP" 
     1208+       depends on CPU_FREQ && PLATFORM_AT32AP 
     1209+       default n 
     1210+       help 
     1211+         This enables the CPU frequency driver for AT32AP processors. 
     1212+ 
     1213+         For details, take a look in <file:Documentation/cpu-freq>. 
     1214+ 
     1215+         If in doubt, say N. 
     1216+ 
     1217+endmenu 
     1218+ 
     1219+endmenu 
     1220+ 
     1221 menu "Bus options" 
     1222  
     1223 config PCI 
     1224diff -x .git -Nur linux-2.6.22.1/arch/avr32/kernel/dma-controller.c linux-avr32.git/arch/avr32/kernel/dma-controller.c 
     1225--- linux-2.6.22.1/arch/avr32/kernel/dma-controller.c   1970-01-01 01:00:00.000000000 +0100 
     1226+++ linux-avr32.git/arch/avr32/kernel/dma-controller.c  2007-06-06 11:33:46.000000000 +0200 
    13811227@@ -0,0 +1,34 @@ 
    13821228+/* 
     
    14141260+} 
    14151261+EXPORT_SYMBOL(find_dma_controller); 
    1416 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 
    1417 --- linux-2.6.21.3/arch/avr32/kernel/entry-avr32b.S     2007-05-24 23:22:47.000000000 +0200 
    1418 +++ avr32-git/arch/avr32/kernel/entry-avr32b.S  2007-06-06 11:33:46.000000000 +0200 
    1419 @@ -100,55 +100,49 @@ 
    1420   
    1421         .global tlb_miss_common 
    1422  tlb_miss_common: 
    1423 -       mfsr    r0, SYSREG_PTBR 
    1424 -       mfsr    r1, SYSREG_TLBEAR 
    1425 +       mfsr    r0, SYSREG_TLBEAR 
    1426 +       mfsr    r1, SYSREG_PTBR 
    1427   
    1428         /* Is it the vmalloc space? */ 
    1429 -       bld     r1, 31 
    1430 +       bld     r0, 31 
    1431         brcs    handle_vmalloc_miss 
    1432   
    1433         /* First level lookup */ 
    1434  pgtbl_lookup: 
    1435 -       lsr     r2, r1, PGDIR_SHIFT 
    1436 -       ld.w    r0, r0[r2 << 2] 
    1437 -       bld     r0, _PAGE_BIT_PRESENT 
    1438 +       lsr     r2, r0, PGDIR_SHIFT 
    1439 +       ld.w    r3, r1[r2 << 2] 
    1440 +       bfextu  r1, r0, PAGE_SHIFT, PGDIR_SHIFT - PAGE_SHIFT 
    1441 +       bld     r3, _PAGE_BIT_PRESENT 
    1442         brcc    page_table_not_present 
    1443   
    1444 -       /* TODO: Check access rights on page table if necessary */ 
    1445 - 
    1446         /* Translate to virtual address in P1. */ 
    1447 -       andl    r0, 0xf000 
    1448 -       sbr     r0, 31 
    1449 +       andl    r3, 0xf000 
    1450 +       sbr     r3, 31 
    1451   
    1452         /* Second level lookup */ 
    1453 -       lsl     r1, (32 - PGDIR_SHIFT) 
    1454 -       lsr     r1, (32 - PGDIR_SHIFT) + PAGE_SHIFT 
    1455 -       add     r2, r0, r1 << 2 
    1456 -       ld.w    r1, r2[0] 
    1457 -       bld     r1, _PAGE_BIT_PRESENT 
    1458 +       ld.w    r2, r3[r1 << 2] 
    1459 +       mfsr    r0, SYSREG_TLBARLO 
    1460 +       bld     r2, _PAGE_BIT_PRESENT 
    1461         brcc    page_not_present 
    1462   
    1463         /* Mark the page as accessed */ 
    1464 -       sbr     r1, _PAGE_BIT_ACCESSED 
    1465 -       st.w    r2[0], r1 
    1466 +       sbr     r2, _PAGE_BIT_ACCESSED 
    1467 +       st.w    r3[r1 << 2], r2 
    1468   
    1469         /* Drop software flags */ 
    1470 -       andl    r1, _PAGE_FLAGS_HARDWARE_MASK & 0xffff 
    1471 -       mtsr    SYSREG_TLBELO, r1 
    1472 +       andl    r2, _PAGE_FLAGS_HARDWARE_MASK & 0xffff 
    1473 +       mtsr    SYSREG_TLBELO, r2 
    1474   
    1475         /* Figure out which entry we want to replace */ 
    1476 -       mfsr    r0, SYSREG_TLBARLO 
    1477 +       mfsr    r1, SYSREG_MMUCR 
    1478         clz     r2, r0 
    1479         brcc    1f 
    1480 -       mov     r1, -1                  /* All entries have been accessed, */ 
    1481 -       mtsr    SYSREG_TLBARLO, r1      /* so reset TLBAR */ 
    1482 -       mov     r2, 0                   /* and start at 0 */ 
    1483 -1:     mfsr    r1, SYSREG_MMUCR 
    1484 -       lsl     r2, 14 
    1485 -       andl    r1, 0x3fff, COH 
    1486 -       or      r1, r2 
    1487 -       mtsr    SYSREG_MMUCR, r1 
    1488 +       mov     r3, -1                  /* All entries have been accessed, */ 
    1489 +       mov     r2, 0                   /* so start at 0 */ 
    1490 +       mtsr    SYSREG_TLBARLO, r3      /* and reset TLBAR */ 
    1491   
    1492 +1:     bfins   r1, r2, SYSREG_DRP_OFFSET, SYSREG_DRP_SIZE 
    1493 +       mtsr    SYSREG_MMUCR, r1 
    1494         tlbw 
    1495   
    1496         tlbmiss_restore 
    1497 @@ -156,8 +150,8 @@ 
    1498   
    1499  handle_vmalloc_miss: 
    1500         /* Simply do the lookup in init's page table */ 
    1501 -       mov     r0, lo(swapper_pg_dir) 
    1502 -       orh     r0, hi(swapper_pg_dir) 
    1503 +       mov     r1, lo(swapper_pg_dir) 
    1504 +       orh     r1, hi(swapper_pg_dir) 
    1505         rjmp    pgtbl_lookup 
    1506   
    1507   
    1508 @@ -340,12 +334,34 @@ 
    1509  do_nmi_ll: 
    1510         sub     sp, 4 
    1511         stmts   --sp, r0-lr 
    1512 -       /* FIXME: Make sure RAR_NMI and RSR_NMI are pushed instead of *_EX */ 
    1513 -       rcall   save_full_context_ex 
    1514 +       mfsr    r9, SYSREG_RSR_NMI 
    1515 +       mfsr    r8, SYSREG_RAR_NMI 
    1516 +       bfextu  r0, r9, MODE_SHIFT, 3 
    1517 +       brne    2f 
    1518 + 
    1519 +1:     pushm   r8, r9  /* PC and SR */ 
    1520         mfsr    r12, SYSREG_ECR 
    1521         mov     r11, sp 
    1522         rcall   do_nmi 
    1523 -       rjmp    bad_return 
    1524 +       popm    r8-r9 
    1525 +       mtsr    SYSREG_RAR_NMI, r8 
    1526 +       tst     r0, r0 
    1527 +       mtsr    SYSREG_RSR_NMI, r9 
    1528 +       brne    3f 
    1529 + 
    1530 +       ldmts   sp++, r0-lr 
    1531 +       sub     sp, -4          /* skip r12_orig */ 
    1532 +       rete 
    1533 + 
    1534 +2:     sub     r10, sp, -(FRAME_SIZE_FULL - REG_LR) 
    1535 +       stdsp   sp[4], r10      /* replace saved SP */ 
    1536 +       rjmp    1b 
    1537 + 
    1538 +3:     popm    lr 
    1539 +       sub     sp, -4          /* skip sp */ 
    1540 +       popm    r0-r12 
    1541 +       sub     sp, -4          /* skip r12_orig */ 
    1542 +       rete 
    1543   
    1544  handle_address_fault: 
    1545         sub     sp, 4 
    1546 @@ -630,9 +646,12 @@ 
    1547         rcall   do_IRQ 
    1548   
    1549         lddsp   r4, sp[REG_SR] 
    1550 -       andh    r4, (MODE_MASK >> 16), COH 
    1551 +       bfextu  r4, r4, SYSREG_M0_OFFSET, 3 
    1552 +       cp.w    r4, MODE_SUPERVISOR >> SYSREG_M0_OFFSET 
    1553 +       breq    2f 
    1554 +       cp.w    r4, MODE_USER >> SYSREG_M0_OFFSET 
    1555  #ifdef CONFIG_PREEMPT 
    1556 -       brne    2f 
    1557 +       brne    3f 
    1558  #else 
    1559         brne    1f 
    1560  #endif 
    1561 @@ -649,9 +668,18 @@ 
    1562         sub     sp, -4          /* ignore r12_orig */ 
    1563         rete 
    1564   
    1565 +2:     get_thread_info r0 
    1566 +       ld.w    r1, r0[TI_flags] 
    1567 +       bld     r1, TIF_CPU_GOING_TO_SLEEP 
    1568  #ifdef CONFIG_PREEMPT 
    1569 -2: 
    1570 -       get_thread_info r0 
    1571 +       brcc    3f 
    1572 +#else 
    1573 +       brcc    1b 
    1574 +#endif 
    1575 +       sub     r1, pc, . - cpu_idle_skip_sleep 
    1576 +       stdsp   sp[REG_PC], r1 
    1577 +#ifdef CONFIG_PREEMPT 
    1578 +3:     get_thread_info r0 
    1579         ld.w    r2, r0[TI_preempt_count] 
    1580         cp.w    r2, 0 
    1581         brne    1b 
    1582 @@ -662,12 +690,32 @@ 
    1583         bld     r4, SYSREG_GM_OFFSET 
    1584         brcs    1b 
    1585         rcall   preempt_schedule_irq 
    1586 -       rjmp    1b 
    1587  #endif 
    1588 +       rjmp    1b 
    1589         .endm 
    1590   
    1591         .section .irq.text,"ax",@progbits 
    1592   
    1593 +.global cpu_idle_sleep 
    1594 +cpu_idle_sleep: 
    1595 +       mask_interrupts 
    1596 +       get_thread_info r8 
    1597 +       ld.w    r9, r8[TI_flags] 
    1598 +       bld     r9, TIF_NEED_RESCHED 
    1599 +       brcs    cpu_idle_enable_int_and_exit 
    1600 +       sbr     r9, TIF_CPU_GOING_TO_SLEEP 
    1601 +       st.w    r8[TI_flags], r9 
    1602 +       unmask_interrupts 
    1603 +       sleep 0 
    1604 +cpu_idle_skip_sleep: 
    1605 +       mask_interrupts 
    1606 +       ld.w    r9, r8[TI_flags] 
    1607 +       cbr     r9, TIF_CPU_GOING_TO_SLEEP 
    1608 +       st.w    r8[TI_flags], r9 
    1609 +cpu_idle_enable_int_and_exit: 
    1610 +       unmask_interrupts 
    1611 +       retal   r12 
    1612 + 
    1613         .global irq_level0 
    1614         .global irq_level1 
    1615         .global irq_level2 
    1616 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/irq.c avr32-git/arch/avr32/kernel/irq.c 
    1617 --- linux-2.6.21.3/arch/avr32/kernel/irq.c      2007-05-24 23:22:47.000000000 +0200 
    1618 +++ avr32-git/arch/avr32/kernel/irq.c   2007-06-06 11:33:46.000000000 +0200 
    1619 @@ -7,15 +7,6 @@ 
    1620   * This program is free software; you can redistribute it and/or modify 
    1621   * it under the terms of the GNU General Public License version 2 as 
    1622   * published by the Free Software Foundation. 
    1623 - * 
    1624 - * This file contains the code used by various IRQ handling routines: 
    1625 - * asking for different IRQ's should be done through these routines 
    1626 - * instead of just grabbing them. Thus setups with different IRQ numbers 
    1627 - * shouldn't result in any weird surprises, and installing new handlers 
    1628 - * should be easier. 
    1629 - * 
    1630 - * IRQ's are in fact implemented a bit like signal handlers for the kernel. 
    1631 - * Naturally it's not a 1:1 relation, but there are similarities. 
    1632   */ 
    1633   
    1634  #include <linux/interrupt.h> 
    1635 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/kprobes.c avr32-git/arch/avr32/kernel/kprobes.c 
    1636 --- linux-2.6.21.3/arch/avr32/kernel/kprobes.c  2007-05-24 23:22:47.000000000 +0200 
    1637 +++ avr32-git/arch/avr32/kernel/kprobes.c       2007-06-06 11:33:46.000000000 +0200 
    1638 @@ -179,7 +179,7 @@ 
    1639         return 1; 
    1640  } 
    1641   
    1642 -static int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr) 
    1643 +int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr) 
    1644  { 
    1645         struct kprobe *cur = kprobe_running(); 
    1646   
    1647 @@ -216,11 +216,6 @@ 
    1648                 if (post_kprobe_handler(args->regs)) 
    1649                         ret = NOTIFY_STOP; 
    1650                 break; 
    1651 -       case DIE_FAULT: 
    1652 -               if (kprobe_running() 
    1653 -                   && kprobe_fault_handler(args->regs, args->trapnr)) 
    1654 -                       ret = NOTIFY_STOP; 
    1655 -               break; 
    1656         default: 
    1657                 break; 
    1658         } 
    1659 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/Makefile avr32-git/arch/avr32/kernel/Makefile 
    1660 --- linux-2.6.21.3/arch/avr32/kernel/Makefile   2007-05-24 23:22:47.000000000 +0200 
    1661 +++ avr32-git/arch/avr32/kernel/Makefile        2007-06-06 11:33:46.000000000 +0200 
     1262diff -x .git -Nur linux-2.6.22.1/arch/avr32/kernel/Makefile linux-avr32.git/arch/avr32/kernel/Makefile 
     1263--- linux-2.6.22.1/arch/avr32/kernel/Makefile   2007-07-10 20:56:30.000000000 +0200 
     1264+++ linux-avr32.git/arch/avr32/kernel/Makefile  2007-06-06 11:33:46.000000000 +0200 
    16621265@@ -9,6 +9,7 @@ 
    16631266 obj-y                          += setup.o traps.o semaphore.o ptrace.o 
     
    16681271 obj-$(CONFIG_KPROBES)          += kprobes.o 
    16691272  
    1670 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/module.c avr32-git/arch/avr32/kernel/module.c 
    1671 --- linux-2.6.21.3/arch/avr32/kernel/module.c   2007-05-24 23:22:47.000000000 +0200 
    1672 +++ avr32-git/arch/avr32/kernel/module.c        2007-06-06 11:33:46.000000000 +0200 
    1673 @@ -12,10 +12,11 @@ 
    1674   * published by the Free Software Foundation. 
    1675   */ 
    1676   
    1677 -#include <linux/moduleloader.h> 
    1678 -#include <linux/module.h> 
    1679 -#include <linux/kernel.h> 
    1680 +#include <linux/bug.h> 
    1681  #include <linux/elf.h> 
    1682 +#include <linux/kernel.h> 
    1683 +#include <linux/module.h> 
    1684 +#include <linux/moduleloader.h> 
    1685  #include <linux/vmalloc.h> 
    1686   
    1687  void *module_alloc(unsigned long size) 
    1688 @@ -315,10 +316,10 @@ 
    1689         vfree(module->arch.syminfo); 
    1690         module->arch.syminfo = NULL; 
    1691   
    1692 -       return 0; 
    1693 +       return module_bug_finalize(hdr, sechdrs, module); 
     1273diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap7000.c linux-avr32.git/arch/avr32/mach-at32ap/at32ap7000.c 
     1274--- linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap7000.c  2007-07-10 20:56:30.000000000 +0200 
     1275+++ linux-avr32.git/arch/avr32/mach-at32ap/at32ap7000.c 2007-07-12 13:59:49.000000000 +0200 
     1276@@ -17,14 +17,20 @@ 
     1277 #include <asm/arch/at32ap7000.h> 
     1278 #include <asm/arch/board.h> 
     1279 #include <asm/arch/portmux.h> 
     1280-#include <asm/arch/sm.h> 
     1281  
     1282 #include <video/atmel_lcdc.h> 
     1283  
     1284 #include "clock.h" 
     1285 #include "hmatrix.h" 
     1286 #include "pio.h" 
     1287-#include "sm.h" 
     1288+#include "pm.h" 
     1289+ 
     1290+/* 
     1291+ * We can reduce the code size a bit by using a constant here. Since 
     1292+ * this file is completely chip-specific, it's safe to not use 
     1293+ * ioremap. Generic drivers should of course never do this. 
     1294+ */ 
     1295+#define AT32_PM_BASE   0xfff00000 
     1296  
     1297 #define PBMEM(base)                                    \ 
     1298        {                                               \ 
     1299@@ -88,6 +94,8 @@ 
     1300        .index          = _index,                               \ 
    16941301 } 
    16951302  
    1696  void module_arch_cleanup(struct module *module) 
     1303+static DEFINE_SPINLOCK(pm_lock); 
     1304+ 
     1305 unsigned long at32ap7000_osc_rates[3] = { 
     1306        [0] = 32768, 
     1307        /* FIXME: these are ATSTK1002-specific */ 
     1308@@ -104,11 +112,11 @@ 
    16971309 { 
    1698 - 
    1699 +       module_bug_cleanup(module); 
     1310        unsigned long div, mul, rate; 
     1311  
     1312-       if (!(control & SM_BIT(PLLEN))) 
     1313+       if (!(control & PM_BIT(PLLEN))) 
     1314                return 0; 
     1315  
     1316-       div = SM_BFEXT(PLLDIV, control) + 1; 
     1317-       mul = SM_BFEXT(PLLMUL, control) + 1; 
     1318+       div = PM_BFEXT(PLLDIV, control) + 1; 
     1319+       mul = PM_BFEXT(PLLMUL, control) + 1; 
     1320  
     1321        rate = clk->parent->get_rate(clk->parent); 
     1322        rate = (rate + div / 2) / div; 
     1323@@ -121,7 +129,7 @@ 
     1324 { 
     1325        u32 control; 
     1326  
     1327-       control = sm_readl(&system_manager, PM_PLL0); 
     1328+       control = pm_readl(PLL0); 
     1329  
     1330        return pll_get_rate(clk, control); 
    17001331 } 
    1701 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/process.c avr32-git/arch/avr32/kernel/process.c 
    1702 --- linux-2.6.21.3/arch/avr32/kernel/process.c  2007-05-24 23:22:47.000000000 +0200 
    1703 +++ avr32-git/arch/avr32/kernel/process.c       2007-06-06 11:33:46.000000000 +0200 
    1704 @@ -11,6 +11,7 @@ 
    1705  #include <linux/fs.h> 
    1706  #include <linux/ptrace.h> 
    1707  #include <linux/reboot.h> 
    1708 +#include <linux/uaccess.h> 
    1709  #include <linux/unistd.h> 
    1710   
    1711  #include <asm/sysreg.h> 
    1712 @@ -19,6 +20,8 @@ 
    1713  void (*pm_power_off)(void) = NULL; 
    1714  EXPORT_SYMBOL(pm_power_off); 
    1715   
    1716 +extern void cpu_idle_sleep(void); 
    1717 + 
    1718  /* 
    1719   * This file handles the architecture-dependent parts of process handling.. 
    1720   */ 
    1721 @@ -27,9 +30,8 @@ 
     1332@@ -130,7 +138,7 @@ 
    17221333 { 
    1723         /* endless idle loop with no priority at all */ 
    1724         while (1) { 
    1725 -               /* TODO: Enter sleep mode */ 
    1726                 while (!need_resched()) 
    1727 -                       cpu_relax(); 
    1728 +                       cpu_idle_sleep(); 
    1729                 preempt_enable_no_resched(); 
    1730                 schedule(); 
    1731                 preempt_disable(); 
    1732 @@ -114,39 +116,178 @@ 
    1733         /* do nothing */ 
     1334        u32 control; 
     1335  
     1336-       control = sm_readl(&system_manager, PM_PLL1); 
     1337+       control = pm_readl(PLL1); 
     1338  
     1339        return pll_get_rate(clk, control); 
    17341340 } 
    1735   
    1736 +static void dump_mem(const char *str, const char *log_lvl, 
    1737 +                    unsigned long bottom, unsigned long top) 
    1738 +{ 
    1739 +       unsigned long p; 
    1740 +       int i; 
    1741 + 
    1742 +       printk("%s%s(0x%08lx to 0x%08lx)\n", log_lvl, str, bottom, top); 
    1743 + 
    1744 +       for (p = bottom & ~31; p < top; ) { 
    1745 +               printk("%s%04lx: ", log_lvl, p & 0xffff); 
    1746 + 
    1747 +               for (i = 0; i < 8; i++, p += 4) { 
    1748 +                       unsigned int val; 
    1749 + 
    1750 +                       if (p < bottom || p >= top) 
    1751 +                               printk("         "); 
    1752 +                       else { 
    1753 +                               if (__get_user(val, (unsigned int __user *)p)) { 
    1754 +                                       printk("\n"); 
    1755 +                                       goto out; 
    1756 +                               } 
    1757 +                               printk("%08x ", val); 
    1758 +                       } 
    1759 +               } 
    1760 +               printk("\n"); 
    1761 +       } 
    1762 + 
    1763 +out: 
    1764 +       return; 
    1765 +} 
    1766 + 
    1767 +static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p) 
    1768 +{ 
    1769 +       return (p > (unsigned long)tinfo) 
    1770 +               && (p < (unsigned long)tinfo + THREAD_SIZE - 3); 
    1771 +} 
    1772 + 
    1773 +#ifdef CONFIG_FRAME_POINTER 
    1774 +static void show_trace_log_lvl(struct task_struct *tsk, unsigned long *sp, 
    1775 +                              struct pt_regs *regs, const char *log_lvl) 
    1776 +{ 
    1777 +       unsigned long lr, fp; 
    1778 +       struct thread_info *tinfo; 
    1779 + 
    1780 +       if (regs) 
    1781 +               fp = regs->r7; 
    1782 +       else if (tsk == current) 
    1783 +               asm("mov %0, r7" : "=r"(fp)); 
     1341@@ -187,108 +195,139 @@ 
     1342  
     1343 static void cpu_clk_mode(struct clk *clk, int enabled) 
     1344 { 
     1345-       struct at32_sm *sm = &system_manager; 
     1346        unsigned long flags; 
     1347        u32 mask; 
     1348  
     1349-       spin_lock_irqsave(&sm->lock, flags); 
     1350-       mask = sm_readl(sm, PM_CPU_MASK); 
     1351+       spin_lock_irqsave(&pm_lock, flags); 
     1352+       mask = pm_readl(CPU_MASK); 
     1353        if (enabled) 
     1354                mask |= 1 << clk->index; 
     1355        else 
     1356                mask &= ~(1 << clk->index); 
     1357-       sm_writel(sm, PM_CPU_MASK, mask); 
     1358-       spin_unlock_irqrestore(&sm->lock, flags); 
     1359+       pm_writel(CPU_MASK, mask); 
     1360+       spin_unlock_irqrestore(&pm_lock, flags); 
     1361 } 
     1362  
     1363 static unsigned long cpu_clk_get_rate(struct clk *clk) 
     1364 { 
     1365        unsigned long cksel, shift = 0; 
     1366  
     1367-       cksel = sm_readl(&system_manager, PM_CKSEL); 
     1368-       if (cksel & SM_BIT(CPUDIV)) 
     1369-               shift = SM_BFEXT(CPUSEL, cksel) + 1; 
     1370+       cksel = pm_readl(CKSEL); 
     1371+       if (cksel & PM_BIT(CPUDIV)) 
     1372+               shift = PM_BFEXT(CPUSEL, cksel) + 1; 
     1373  
     1374        return bus_clk_get_rate(clk, shift); 
     1375 } 
     1376  
     1377+static long cpu_clk_set_rate(struct clk *clk, unsigned long rate, int apply) 
     1378+{ 
     1379+       u32 control; 
     1380+       unsigned long parent_rate, child_div, actual_rate, div; 
     1381+ 
     1382+       parent_rate = clk->parent->get_rate(clk->parent); 
     1383+       control = pm_readl(CKSEL); 
     1384+ 
     1385+       if (control & PM_BIT(HSBDIV)) 
     1386+               child_div = 1 << (PM_BFEXT(HSBSEL, control) + 1); 
    17841387+       else 
    1785 +               fp = tsk->thread.cpu_context.r7; 
    1786 + 
    1787 +       /* 
    1788 +        * Walk the stack as long as the frame pointer (a) is within 
    1789 +        * the kernel stack of the task, and (b) it doesn't move 
    1790 +        * downwards. 
    1791 +        */ 
    1792 +       tinfo = task_thread_info(tsk); 
    1793 +       printk("%sCall trace:\n", log_lvl); 
    1794 +       while (valid_stack_ptr(tinfo, fp)) { 
    1795 +               unsigned long new_fp; 
    1796 + 
    1797 +               lr = *(unsigned long *)fp; 
    1798 +#ifdef CONFIG_KALLSYMS 
    1799 +               printk("%s [<%08lx>] ", log_lvl, lr); 
    1800 +#else 
    1801 +               printk(" [<%08lx>] ", lr); 
    1802 +#endif 
    1803 +               print_symbol("%s\n", lr); 
    1804 + 
    1805 +               new_fp = *(unsigned long *)(fp + 4); 
    1806 +               if (new_fp <= fp) 
    1807 +                       break; 
    1808 +               fp = new_fp; 
    1809 +       } 
    1810 +       printk("\n"); 
    1811 +} 
    1812 +#else 
    1813 +static void show_trace_log_lvl(struct task_struct *tsk, unsigned long *sp, 
    1814 +                              struct pt_regs *regs, const char *log_lvl) 
    1815 +{ 
    1816 +       unsigned long addr; 
    1817 + 
    1818 +       printk("%sCall trace:\n", log_lvl); 
    1819 + 
    1820 +       while (!kstack_end(sp)) { 
    1821 +               addr = *sp++; 
    1822 +               if (kernel_text_address(addr)) { 
    1823 +#ifdef CONFIG_KALLSYMS 
    1824 +                       printk("%s [<%08lx>] ", log_lvl, addr); 
    1825 +#else 
    1826 +                       printk(" [<%08lx>] ", addr); 
    1827 +#endif 
    1828 +                       print_symbol("%s\n", addr); 
    1829 +               } 
    1830 +       } 
    1831 +       printk("\n"); 
    1832 +} 
    1833 +#endif 
    1834 + 
    1835 +void show_stack_log_lvl(struct task_struct *tsk, unsigned long sp, 
    1836 +                       struct pt_regs *regs, const char *log_lvl) 
    1837 +{ 
    1838 +       struct thread_info *tinfo; 
    1839 + 
    1840 +       if (sp == 0) { 
    1841 +               if (tsk) 
    1842 +                       sp = tsk->thread.cpu_context.ksp; 
    1843 +               else 
    1844 +                       sp = (unsigned long)&tinfo; 
    1845 +       } 
    1846 +       if (!tsk) 
    1847 +               tsk = current; 
    1848 + 
    1849 +       tinfo = task_thread_info(tsk); 
    1850 + 
    1851 +       if (valid_stack_ptr(tinfo, sp)) { 
    1852 +               dump_mem("Stack: ", log_lvl, sp, 
    1853 +                        THREAD_SIZE + (unsigned long)tinfo); 
    1854 +               show_trace_log_lvl(tsk, (unsigned long *)sp, regs, log_lvl); 
    1855 +       } 
    1856 +} 
    1857 + 
    1858 +void show_stack(struct task_struct *tsk, unsigned long *stack) 
    1859 +{ 
    1860 +       show_stack_log_lvl(tsk, (unsigned long)stack, NULL, ""); 
    1861 +} 
    1862 + 
    1863 +void dump_stack(void) 
    1864 +{ 
    1865 +       unsigned long stack; 
    1866 + 
    1867 +       show_trace_log_lvl(current, &stack, NULL, ""); 
    1868 +} 
    1869 +EXPORT_SYMBOL(dump_stack); 
    1870 + 
    1871  static const char *cpu_modes[] = { 
    1872         "Application", "Supervisor", "Interrupt level 0", "Interrupt level 1", 
    1873         "Interrupt level 2", "Interrupt level 3", "Exception", "NMI" 
     1388+               child_div = 1; 
     1389+ 
     1390+       if (rate > 3 * (parent_rate / 4) || child_div == 1) { 
     1391+               actual_rate = parent_rate; 
     1392+               control &= ~PM_BIT(CPUDIV); 
     1393+       } else { 
     1394+               unsigned int cpusel; 
     1395+               div = (parent_rate + rate / 2) / rate; 
     1396+               if (div > child_div) 
     1397+                       div = child_div; 
     1398+               cpusel = (div > 1) ? (fls(div) - 2) : 0; 
     1399+               control = PM_BIT(CPUDIV) | PM_BFINS(CPUSEL, cpusel, control); 
     1400+               actual_rate = parent_rate / (1 << (cpusel + 1)); 
     1401+       } 
     1402+ 
     1403+       pr_debug("clk %s: new rate %lu (actual rate %lu)\n", 
     1404+                       clk->name, rate, actual_rate); 
     1405+ 
     1406+       if (apply) 
     1407+               pm_writel(CKSEL, control); 
     1408+ 
     1409+       return actual_rate; 
     1410+} 
     1411+ 
     1412 static void hsb_clk_mode(struct clk *clk, int enabled) 
     1413 { 
     1414-       struct at32_sm *sm = &system_manager; 
     1415        unsigned long flags; 
     1416        u32 mask; 
     1417  
     1418-       spin_lock_irqsave(&sm->lock, flags); 
     1419-       mask = sm_readl(sm, PM_HSB_MASK); 
     1420+       spin_lock_irqsave(&pm_lock, flags); 
     1421+       mask = pm_readl(HSB_MASK); 
     1422        if (enabled) 
     1423                mask |= 1 << clk->index; 
     1424        else 
     1425                mask &= ~(1 << clk->index); 
     1426-       sm_writel(sm, PM_HSB_MASK, mask); 
     1427-       spin_unlock_irqrestore(&sm->lock, flags); 
     1428+       pm_writel(HSB_MASK, mask); 
     1429+       spin_unlock_irqrestore(&pm_lock, flags); 
     1430 } 
     1431  
     1432 static unsigned long hsb_clk_get_rate(struct clk *clk) 
     1433 { 
     1434        unsigned long cksel, shift = 0; 
     1435  
     1436-       cksel = sm_readl(&system_manager, PM_CKSEL); 
     1437-       if (cksel & SM_BIT(HSBDIV)) 
     1438-               shift = SM_BFEXT(HSBSEL, cksel) + 1; 
     1439+       cksel = pm_readl(CKSEL); 
     1440+       if (cksel & PM_BIT(HSBDIV)) 
     1441+               shift = PM_BFEXT(HSBSEL, cksel) + 1; 
     1442  
     1443        return bus_clk_get_rate(clk, shift); 
     1444 } 
     1445  
     1446 static void pba_clk_mode(struct clk *clk, int enabled) 
     1447 { 
     1448-       struct at32_sm *sm = &system_manager; 
     1449        unsigned long flags; 
     1450        u32 mask; 
     1451  
     1452-       spin_lock_irqsave(&sm->lock, flags); 
     1453-       mask = sm_readl(sm, PM_PBA_MASK); 
     1454+       spin_lock_irqsave(&pm_lock, flags); 
     1455+       mask = pm_readl(PBA_MASK); 
     1456        if (enabled) 
     1457                mask |= 1 << clk->index; 
     1458        else 
     1459                mask &= ~(1 << clk->index); 
     1460-       sm_writel(sm, PM_PBA_MASK, mask); 
     1461-       spin_unlock_irqrestore(&sm->lock, flags); 
     1462+       pm_writel(PBA_MASK, mask); 
     1463+       spin_unlock_irqrestore(&pm_lock, flags); 
     1464 } 
     1465  
     1466 static unsigned long pba_clk_get_rate(struct clk *clk) 
     1467 { 
     1468        unsigned long cksel, shift = 0; 
     1469  
     1470-       cksel = sm_readl(&system_manager, PM_CKSEL); 
     1471-       if (cksel & SM_BIT(PBADIV)) 
     1472-               shift = SM_BFEXT(PBASEL, cksel) + 1; 
     1473+       cksel = pm_readl(CKSEL); 
     1474+       if (cksel & PM_BIT(PBADIV)) 
     1475+               shift = PM_BFEXT(PBASEL, cksel) + 1; 
     1476  
     1477        return bus_clk_get_rate(clk, shift); 
     1478 } 
     1479  
     1480 static void pbb_clk_mode(struct clk *clk, int enabled) 
     1481 { 
     1482-       struct at32_sm *sm = &system_manager; 
     1483        unsigned long flags; 
     1484        u32 mask; 
     1485  
     1486-       spin_lock_irqsave(&sm->lock, flags); 
     1487-       mask = sm_readl(sm, PM_PBB_MASK); 
     1488+       spin_lock_irqsave(&pm_lock, flags); 
     1489+       mask = pm_readl(PBB_MASK); 
     1490        if (enabled) 
     1491                mask |= 1 << clk->index; 
     1492        else 
     1493                mask &= ~(1 << clk->index); 
     1494-       sm_writel(sm, PM_PBB_MASK, mask); 
     1495-       spin_unlock_irqrestore(&sm->lock, flags); 
     1496+       pm_writel(PBB_MASK, mask); 
     1497+       spin_unlock_irqrestore(&pm_lock, flags); 
     1498 } 
     1499  
     1500 static unsigned long pbb_clk_get_rate(struct clk *clk) 
     1501 { 
     1502        unsigned long cksel, shift = 0; 
     1503  
     1504-       cksel = sm_readl(&system_manager, PM_CKSEL); 
     1505-       if (cksel & SM_BIT(PBBDIV)) 
     1506-               shift = SM_BFEXT(PBBSEL, cksel) + 1; 
     1507+       cksel = pm_readl(CKSEL); 
     1508+       if (cksel & PM_BIT(PBBDIV)) 
     1509+               shift = PM_BFEXT(PBBSEL, cksel) + 1; 
     1510  
     1511        return bus_clk_get_rate(clk, shift); 
     1512 } 
     1513@@ -296,6 +335,7 @@ 
     1514 static struct clk cpu_clk = { 
     1515        .name           = "cpu", 
     1516        .get_rate       = cpu_clk_get_rate, 
     1517+       .set_rate       = cpu_clk_set_rate, 
     1518        .users          = 1, 
    18741519 }; 
    1875   
    1876 -void show_regs(struct pt_regs *regs) 
    1877 +void show_regs_log_lvl(struct pt_regs *regs, const char *log_lvl) 
     1520 static struct clk hsb_clk = { 
     1521@@ -327,12 +367,12 @@ 
    18781522 { 
    1879         unsigned long sp = regs->sp; 
    1880         unsigned long lr = regs->lr; 
    1881         unsigned long mode = (regs->sr & MODE_MASK) >> MODE_SHIFT; 
    1882   
    1883 -       if (!user_mode(regs)) 
    1884 +       if (!user_mode(regs)) { 
    1885                 sp = (unsigned long)regs + FRAME_SIZE_FULL; 
    1886   
    1887 -       print_symbol("PC is at %s\n", instruction_pointer(regs)); 
    1888 -       print_symbol("LR is at %s\n", lr); 
    1889 -       printk("pc : [<%08lx>]    lr : [<%08lx>]    %s\n" 
    1890 -              "sp : %08lx  r12: %08lx  r11: %08lx\n", 
    1891 -              instruction_pointer(regs), 
    1892 -              lr, print_tainted(), sp, regs->r12, regs->r11); 
    1893 -       printk("r10: %08lx  r9 : %08lx  r8 : %08lx\n", 
    1894 -              regs->r10, regs->r9, regs->r8); 
    1895 -       printk("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n", 
    1896 -              regs->r7, regs->r6, regs->r5, regs->r4); 
    1897 -       printk("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n", 
    1898 -              regs->r3, regs->r2, regs->r1, regs->r0); 
    1899 -       printk("Flags: %c%c%c%c%c\n", 
    1900 +               printk("%s", log_lvl); 
    1901 +               print_symbol("PC is at %s\n", instruction_pointer(regs)); 
    1902 +               printk("%s", log_lvl); 
    1903 +               print_symbol("LR is at %s\n", lr); 
    1904 +       } 
    1905 + 
    1906 +       printk("%spc : [<%08lx>]    lr : [<%08lx>]    %s\n" 
    1907 +              "%ssp : %08lx  r12: %08lx  r11: %08lx\n", 
    1908 +              log_lvl, instruction_pointer(regs), lr, print_tainted(), 
    1909 +              log_lvl, sp, regs->r12, regs->r11); 
    1910 +       printk("%sr10: %08lx  r9 : %08lx  r8 : %08lx\n", 
    1911 +              log_lvl, regs->r10, regs->r9, regs->r8); 
    1912 +       printk("%sr7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n", 
    1913 +              log_lvl, regs->r7, regs->r6, regs->r5, regs->r4); 
    1914 +       printk("%sr3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n", 
    1915 +              log_lvl, regs->r3, regs->r2, regs->r1, regs->r0); 
    1916 +       printk("%sFlags: %c%c%c%c%c\n", log_lvl, 
    1917                regs->sr & SR_Q ? 'Q' : 'q', 
    1918                regs->sr & SR_V ? 'V' : 'v', 
    1919                regs->sr & SR_N ? 'N' : 'n', 
    1920                regs->sr & SR_Z ? 'Z' : 'z', 
    1921                regs->sr & SR_C ? 'C' : 'c'); 
    1922 -       printk("Mode bits: %c%c%c%c%c%c%c%c%c\n", 
    1923 +       printk("%sMode bits: %c%c%c%c%c%c%c%c%c\n", log_lvl, 
    1924                regs->sr & SR_H ? 'H' : 'h', 
    1925                regs->sr & SR_R ? 'R' : 'r', 
    1926                regs->sr & SR_J ? 'J' : 'j', 
    1927 @@ -156,9 +297,21 @@ 
    1928                regs->sr & SR_I1M ? '1' : '.', 
    1929                regs->sr & SR_I0M ? '0' : '.', 
    1930                regs->sr & SR_GM ? 'G' : 'g'); 
    1931 -       printk("CPU Mode: %s\n", cpu_modes[mode]); 
    1932 +       printk("%sCPU Mode: %s\n", log_lvl, cpu_modes[mode]); 
    1933 +       printk("%sProcess: %s [%d] (task: %p thread: %p)\n", 
    1934 +              log_lvl, current->comm, current->pid, current, 
    1935 +              task_thread_info(current)); 
    1936 +} 
    1937 + 
    1938 +void show_regs(struct pt_regs *regs) 
    1939 +{ 
    1940 +       unsigned long sp = regs->sp; 
    1941 + 
    1942 +       if (!user_mode(regs)) 
    1943 +               sp = (unsigned long)regs + FRAME_SIZE_FULL; 
    1944   
    1945 -       show_trace(NULL, (unsigned long *)sp, regs); 
    1946 +       show_regs_log_lvl(regs, ""); 
    1947 +       show_trace_log_lvl(current, (unsigned long *)sp, regs, ""); 
     1523        u32 control; 
     1524  
     1525-       control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index); 
     1526+       control = pm_readl(GCCTRL(clk->index)); 
     1527        if (enabled) 
     1528-               control |= SM_BIT(CEN); 
     1529+               control |= PM_BIT(CEN); 
     1530        else 
     1531-               control &= ~SM_BIT(CEN); 
     1532-       sm_writel(&system_manager, PM_GCCTRL + 4 * clk->index, control); 
     1533+               control &= ~PM_BIT(CEN); 
     1534+       pm_writel(GCCTRL(clk->index), control); 
    19481535 } 
    1949  EXPORT_SYMBOL(show_regs); 
    1950   
    1951 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/setup.c avr32-git/arch/avr32/kernel/setup.c 
    1952 --- linux-2.6.21.3/arch/avr32/kernel/setup.c    2007-05-24 23:22:47.000000000 +0200 
    1953 +++ avr32-git/arch/avr32/kernel/setup.c 2007-06-06 11:33:46.000000000 +0200 
    1954 @@ -8,12 +8,14 @@ 
    1955   
    1956  #include <linux/clk.h> 
    1957  #include <linux/init.h> 
    1958 +#include <linux/initrd.h> 
    1959  #include <linux/sched.h> 
    1960  #include <linux/console.h> 
    1961  #include <linux/ioport.h> 
    1962  #include <linux/bootmem.h> 
    1963  #include <linux/fs.h> 
    1964  #include <linux/module.h> 
    1965 +#include <linux/pfn.h> 
    1966  #include <linux/root_dev.h> 
    1967  #include <linux/cpu.h> 
    1968  #include <linux/kernel.h> 
    1969 @@ -30,13 +32,6 @@ 
    1970  extern int root_mountflags; 
    1971   
    1972  /* 
    1973 - * Bootloader-provided information about physical memory 
    1974 - */ 
    1975 -struct tag_mem_range *mem_phys; 
    1976 -struct tag_mem_range *mem_reserved; 
    1977 -struct tag_mem_range *mem_ramdisk; 
    1978 - 
    1979 -/* 
    1980   * Initialize loops_per_jiffy as 5000000 (500MIPS). 
    1981   * Better make it too large than too small... 
    1982   */ 
    1983 @@ -48,48 +43,193 @@ 
    1984  static char __initdata command_line[COMMAND_LINE_SIZE]; 
    1985   
    1986  /* 
    1987 - * Should be more than enough, but if you have a _really_ complex 
    1988 - * setup, you might need to increase the size of this... 
    1989 + * Standard memory resources 
    1990   */ 
    1991 -static struct tag_mem_range __initdata mem_range_cache[32]; 
    1992 -static unsigned mem_range_next_free; 
    1993 +static struct resource __initdata kernel_data = { 
    1994 +       .name   = "Kernel data", 
    1995 +       .start  = 0, 
    1996 +       .end    = 0, 
    1997 +       .flags  = IORESOURCE_MEM, 
     1536  
     1537 static unsigned long genclk_get_rate(struct clk *clk) 
     1538@@ -340,9 +380,9 @@ 
     1539        u32 control; 
     1540        unsigned long div = 1; 
     1541  
     1542-       control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index); 
     1543-       if (control & SM_BIT(DIVEN)) 
     1544-               div = 2 * (SM_BFEXT(DIV, control) + 1); 
     1545+       control = pm_readl(GCCTRL(clk->index)); 
     1546+       if (control & PM_BIT(DIVEN)) 
     1547+               div = 2 * (PM_BFEXT(DIV, control) + 1); 
     1548  
     1549        return clk->parent->get_rate(clk->parent) / div; 
     1550 } 
     1551@@ -353,23 +393,22 @@ 
     1552        unsigned long parent_rate, actual_rate, div; 
     1553  
     1554        parent_rate = clk->parent->get_rate(clk->parent); 
     1555-       control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index); 
     1556+       control = pm_readl(GCCTRL(clk->index)); 
     1557  
     1558        if (rate > 3 * parent_rate / 4) { 
     1559                actual_rate = parent_rate; 
     1560-               control &= ~SM_BIT(DIVEN); 
     1561+               control &= ~PM_BIT(DIVEN); 
     1562        } else { 
     1563                div = (parent_rate + rate) / (2 * rate) - 1; 
     1564-               control = SM_BFINS(DIV, div, control) | SM_BIT(DIVEN); 
     1565+               control = PM_BFINS(DIV, div, control) | PM_BIT(DIVEN); 
     1566                actual_rate = parent_rate / (2 * (div + 1)); 
     1567        } 
     1568  
     1569-       printk("clk %s: new rate %lu (actual rate %lu)\n", 
     1570-              clk->name, rate, actual_rate); 
     1571+       dev_dbg(clk->dev, "clk %s: new rate %lu (actual rate %lu)\n", 
     1572+               clk->name, rate, actual_rate); 
     1573  
     1574        if (apply) 
     1575-               sm_writel(&system_manager, PM_GCCTRL + 4 * clk->index, 
     1576-                         control); 
     1577+               pm_writel(GCCTRL(clk->index), control); 
     1578  
     1579        return actual_rate; 
     1580 } 
     1581@@ -378,24 +417,24 @@ 
     1582 { 
     1583        u32 control; 
     1584  
     1585-       printk("clk %s: new parent %s (was %s)\n", 
     1586-              clk->name, parent->name, clk->parent->name); 
     1587+       dev_dbg(clk->dev, "clk %s: new parent %s (was %s)\n", 
     1588+               clk->name, parent->name, clk->parent->name); 
     1589  
     1590-       control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index); 
     1591+       control = pm_readl(GCCTRL(clk->index)); 
     1592  
     1593        if (parent == &osc1 || parent == &pll1) 
     1594-               control |= SM_BIT(OSCSEL); 
     1595+               control |= PM_BIT(OSCSEL); 
     1596        else if (parent == &osc0 || parent == &pll0) 
     1597-               control &= ~SM_BIT(OSCSEL); 
     1598+               control &= ~PM_BIT(OSCSEL); 
     1599        else 
     1600                return -EINVAL; 
     1601  
     1602        if (parent == &pll0 || parent == &pll1) 
     1603-               control |= SM_BIT(PLLSEL); 
     1604+               control |= PM_BIT(PLLSEL); 
     1605        else 
     1606-               control &= ~SM_BIT(PLLSEL); 
     1607+               control &= ~PM_BIT(PLLSEL); 
     1608  
     1609-       sm_writel(&system_manager, PM_GCCTRL + 4 * clk->index, control); 
     1610+       pm_writel(GCCTRL(clk->index), control); 
     1611        clk->parent = parent; 
     1612  
     1613        return 0; 
     1614@@ -408,11 +447,11 @@ 
     1615  
     1616        BUG_ON(clk->index > 7); 
     1617  
     1618-       control = sm_readl(&system_manager, PM_GCCTRL + 4 * clk->index); 
     1619-       if (control & SM_BIT(OSCSEL)) 
     1620-               parent = (control & SM_BIT(PLLSEL)) ? &pll1 : &osc1; 
     1621+       control = pm_readl(GCCTRL(clk->index)); 
     1622+       if (control & PM_BIT(OSCSEL)) 
     1623+               parent = (control & PM_BIT(PLLSEL)) ? &pll1 : &osc1; 
     1624        else 
     1625-               parent = (control & SM_BIT(PLLSEL)) ? &pll0 : &osc0; 
     1626+               parent = (control & PM_BIT(PLLSEL)) ? &pll0 : &osc0; 
     1627  
     1628        clk->parent = parent; 
     1629 } 
     1630@@ -420,21 +459,53 @@ 
     1631 /* -------------------------------------------------------------------- 
     1632  *  System peripherals 
     1633  * -------------------------------------------------------------------- */ 
     1634-static struct resource sm_resource[] = { 
     1635-       PBMEM(0xfff00000), 
     1636-       NAMED_IRQ(19, "eim"), 
     1637-       NAMED_IRQ(20, "pm"), 
     1638-       NAMED_IRQ(21, "rtc"), 
     1639+static struct resource at32_pm0_resource[] = { 
     1640+       { 
     1641+               .start  = 0xfff00000, 
     1642+               .end    = 0xfff0007f, 
     1643+               .flags  = IORESOURCE_MEM, 
     1644+       }, 
     1645+       IRQ(20), 
     1646 }; 
     1647-struct platform_device at32_sm_device = { 
     1648-       .name           = "sm", 
     1649-       .id             = 0, 
     1650-       .resource       = sm_resource, 
     1651-       .num_resources  = ARRAY_SIZE(sm_resource), 
     1652+ 
     1653+static struct resource at32ap700x_rtc0_resource[] = { 
     1654+       { 
     1655+               .start  = 0xfff00080, 
     1656+               .end    = 0xfff000af, 
     1657+               .flags  = IORESOURCE_MEM, 
     1658+       }, 
     1659+       IRQ(21), 
    19981660+}; 
    1999 +static struct resource __initdata kernel_code = { 
    2000 +       .name   = "Kernel code", 
    2001 +       .start  = 0, 
    2002 +       .end    = 0, 
    2003 +       .flags  = IORESOURCE_MEM, 
    2004 +       .sibling = &kernel_data, 
     1661+ 
     1662+static struct resource at32_wdt0_resource[] = { 
     1663+       { 
     1664+               .start  = 0xfff000b0, 
     1665+               .end    = 0xfff000bf, 
     1666+               .flags  = IORESOURCE_MEM, 
     1667+       }, 
    20051668+}; 
    2006   
    2007  /* 
    2008 - * Standard memory resources 
    2009 + * Available system RAM and reserved regions as singly linked 
    2010 + * lists. These lists are traversed using the sibling pointer in 
    2011 + * struct resource and are kept sorted at all times. 
    2012   */ 
    2013 -static struct resource mem_res[] = { 
    2014 -       { 
    2015 -               .name   = "Kernel code", 
    2016 -               .start  = 0, 
    2017 -               .end    = 0, 
    2018 -               .flags  = IORESOURCE_MEM 
    2019 -       }, 
    2020 -       { 
    2021 -               .name   = "Kernel data", 
    2022 -               .start  = 0, 
    2023 -               .end    = 0, 
    2024 -               .flags  = IORESOURCE_MEM, 
    2025 -       }, 
    2026 -}; 
    2027 +static struct resource *__initdata system_ram; 
    2028 +static struct resource *__initdata reserved = &kernel_code; 
     1669+ 
     1670+static struct resource at32_eic0_resource[] = { 
     1671+       { 
     1672+               .start  = 0xfff00100, 
     1673+               .end    = 0xfff0013f, 
     1674+               .flags  = IORESOURCE_MEM, 
     1675+       }, 
     1676+       IRQ(19), 
     1677 }; 
     1678-static struct clk at32_sm_pclk = { 
     1679+ 
     1680+DEFINE_DEV(at32_pm, 0); 
     1681+DEFINE_DEV(at32ap700x_rtc, 0); 
     1682+DEFINE_DEV(at32_wdt, 0); 
     1683+DEFINE_DEV(at32_eic, 0); 
    20291684+ 
    20301685+/* 
    2031 + * We need to allocate these before the bootmem allocator is up and 
    2032 + * running, so we need this "cache". 32 entries are probably enough 
    2033 + * for all but the most insanely complex systems. 
     1686+ * Peripheral clock for PM, RTC, WDT and EIC. PM will ensure that this 
     1687+ * is always running. 
    20341688+ */ 
    2035 +static struct resource __initdata res_cache[32]; 
    2036 +static unsigned int __initdata res_cache_next_free; 
    2037 + 
    2038 +static void __init resource_init(void) 
    2039 +{ 
    2040 +       struct resource *mem, *res; 
    2041 +       struct resource *new; 
    2042 + 
    2043 +       kernel_code.start = __pa(init_mm.start_code); 
    2044 + 
    2045 +       for (mem = system_ram; mem; mem = mem->sibling) { 
    2046 +               new = alloc_bootmem_low(sizeof(struct resource)); 
    2047 +               memcpy(new, mem, sizeof(struct resource)); 
    2048 + 
    2049 +               new->sibling = NULL; 
    2050 +               if (request_resource(&iomem_resource, new)) 
    2051 +                       printk(KERN_WARNING "Bad RAM resource %08x-%08x\n", 
    2052 +                              mem->start, mem->end); 
    2053 +       } 
    2054 + 
    2055 +       for (res = reserved; res; res = res->sibling) { 
    2056 +               new = alloc_bootmem_low(sizeof(struct resource)); 
    2057 +               memcpy(new, res, sizeof(struct resource)); 
    2058 + 
    2059 +               new->sibling = NULL; 
    2060 +               if (insert_resource(&iomem_resource, new)) 
    2061 +                       printk(KERN_WARNING 
    2062 +                              "Bad reserved resource %s (%08x-%08x)\n", 
    2063 +                              res->name, res->start, res->end); 
    2064 +       } 
    2065 +} 
    2066 + 
    2067 +static void __init 
    2068 +add_physical_memory(resource_size_t start, resource_size_t end) 
    2069 +{ 
    2070 +       struct resource *new, *next, **pprev; 
    2071 + 
    2072 +       for (pprev = &system_ram, next = system_ram; next; 
    2073 +            pprev = &next->sibling, next = next->sibling) { 
    2074 +               if (end < next->start) 
    2075 +                       break; 
    2076 +               if (start <= next->end) { 
    2077 +                       printk(KERN_WARNING 
    2078 +                              "Warning: Physical memory map is broken\n"); 
    2079 +                       printk(KERN_WARNING 
    2080 +                              "Warning: %08x-%08x overlaps %08x-%08x\n", 
    2081 +                              start, end, next->start, next->end); 
    2082 +                       return; 
    2083 +               } 
    2084 +       } 
    2085 + 
    2086 +       if (res_cache_next_free >= ARRAY_SIZE(res_cache)) { 
    2087 +               printk(KERN_WARNING 
    2088 +                      "Warning: Failed to add physical memory %08x-%08x\n", 
    2089 +                      start, end); 
    2090 +               return; 
    2091 +       } 
    2092 + 
    2093 +       new = &res_cache[res_cache_next_free++]; 
    2094 +       new->start = start; 
    2095 +       new->end = end; 
    2096 +       new->name = "System RAM"; 
    2097 +       new->flags = IORESOURCE_MEM; 
    2098 + 
    2099 +       *pprev = new; 
    2100 +} 
    2101 + 
    2102 +static int __init 
    2103 +add_reserved_region(resource_size_t start, resource_size_t end, 
    2104 +                   const char *name) 
    2105 +{ 
    2106 +       struct resource *new, *next, **pprev; 
    2107 + 
    2108 +       if (end < start) 
    2109 +               return -EINVAL; 
    2110 + 
    2111 +       if (res_cache_next_free >= ARRAY_SIZE(res_cache)) 
    2112 +               return -ENOMEM; 
    2113 + 
    2114 +       for (pprev = &reserved, next = reserved; next; 
    2115 +            pprev = &next->sibling, next = next->sibling) { 
    2116 +               if (end < next->start) 
    2117 +                       break; 
    2118 +               if (start <= next->end) 
    2119 +                       return -EBUSY; 
    2120 +       } 
    2121 + 
    2122 +       new = &res_cache[res_cache_next_free++]; 
    2123 +       new->start = start; 
    2124 +       new->end = end; 
    2125 +       new->name = name; 
    2126 +       new->flags = IORESOURCE_MEM; 
    2127   
    2128 -#define kernel_code    mem_res[0] 
    2129 -#define kernel_data    mem_res[1] 
    2130 +       *pprev = new; 
    2131 + 
    2132 +       return 0; 
    2133 +} 
    2134 + 
    2135 +static unsigned long __init 
    2136 +find_free_region(const struct resource *mem, resource_size_t size, 
    2137 +                resource_size_t align) 
    2138 +{ 
    2139 +       struct resource *res; 
    2140 +       unsigned long target; 
    2141 + 
    2142 +       target = ALIGN(mem->start, align); 
    2143 +       for (res = reserved; res; res = res->sibling) { 
    2144 +               if ((target + size) <= res->start) 
    2145 +                       break; 
    2146 +               if (target <= res->end) 
    2147 +                       target = ALIGN(res->end + 1, align); 
    2148 +       } 
    2149 + 
    2150 +       if ((target + size) > (mem->end + 1)) 
    2151 +               return mem->end + 1; 
    2152 + 
    2153 +       return target; 
    2154 +} 
    2155 + 
    2156 +static int __init 
    2157 +alloc_reserved_region(resource_size_t *start, resource_size_t size, 
    2158 +                     resource_size_t align, const char *name) 
    2159 +{ 
    2160 +       struct resource *mem; 
    2161 +       resource_size_t target; 
    2162 +       int ret; 
    2163 + 
    2164 +       for (mem = system_ram; mem; mem = mem->sibling) { 
    2165 +               target = find_free_region(mem, size, align); 
    2166 +               if (target <= mem->end) { 
    2167 +                       ret = add_reserved_region(target, target + size - 1, 
    2168 +                                                 name); 
    2169 +                       if (!ret) 
    2170 +                               *start = target; 
    2171 +                       return ret; 
    2172 +               } 
    2173 +       } 
    2174 + 
    2175 +       return -ENOMEM; 
    2176 +} 
    2177   
    2178  /* 
    2179   * Early framebuffer allocation. Works as follows: 
    2180   *   - If fbmem_size is zero, nothing will be allocated or reserved. 
    2181   *   - If fbmem_start is zero when setup_bootmem() is called, 
    2182 - *     fbmem_size bytes will be allocated from the bootmem allocator. 
    2183 + *     a block of fbmem_size bytes will be reserved before bootmem 
    2184 + *     initialization. It will be aligned to the largest page size 
    2185 + *     that fbmem_size is a multiple of. 
    2186   *   - If fbmem_start is nonzero, an area of size fbmem_size will be 
    2187 - *     reserved at the physical address fbmem_start if necessary. If 
    2188 - *     the area isn't in a memory region known to the kernel, it will 
    2189 - *     be left alone. 
    2190 + *     reserved at the physical address fbmem_start if possible. If 
    2191 + *     it collides with other reserved memory, a different block of 
    2192 + *     same size will be allocated, just as if fbmem_start was zero. 
    2193   * 
    2194   * Board-specific code may use these variables to set up platform data 
    2195   * for the framebuffer driver if fbmem_size is nonzero. 
    2196   */ 
    2197 -static unsigned long __initdata fbmem_start; 
    2198 -static unsigned long __initdata fbmem_size; 
    2199 +resource_size_t __initdata fbmem_start; 
    2200 +resource_size_t __initdata fbmem_size; 
    2201   
    2202  /* 
    2203   * "fbmem=xxx[kKmM]" allocates the specified amount of boot memory for 
    2204 @@ -103,48 +243,42 @@ 
    2205   */ 
    2206  static int __init early_parse_fbmem(char *p) 
    2207  { 
    2208 +       int ret; 
    2209 +       unsigned long align; 
    2210 + 
    2211         fbmem_size = memparse(p, &p); 
    2212 -       if (*p == '@') 
    2213 +       if (*p == '@') { 
    2214                 fbmem_start = memparse(p, &p); 
    2215 -       return 0; 
    2216 -} 
    2217 -early_param("fbmem", early_parse_fbmem); 
    2218 - 
    2219 -static inline void __init resource_init(void) 
    2220 -{ 
    2221 -       struct tag_mem_range *region; 
    2222 - 
    2223 -       kernel_code.start = __pa(init_mm.start_code); 
    2224 -       kernel_code.end = __pa(init_mm.end_code - 1); 
    2225 -       kernel_data.start = __pa(init_mm.end_code); 
    2226 -       kernel_data.end = __pa(init_mm.brk - 1); 
    2227 +               ret = add_reserved_region(fbmem_start, 
    2228 +                                         fbmem_start + fbmem_size - 1, 
    2229 +                                         "Framebuffer"); 
    2230 +               if (ret) { 
    2231 +                       printk(KERN_WARNING 
    2232 +                              "Failed to reserve framebuffer memory\n"); 
    2233 +                       fbmem_start = 0; 
    2234 +               } 
    2235 +       } 
    2236   
    2237 -       for (region = mem_phys; region; region = region->next) { 
    2238 -               struct resource *res; 
    2239 -               unsigned long phys_start, phys_end; 
    2240 - 
    2241 -               if (region->size == 0) 
    2242 -                       continue; 
    2243 - 
    2244 -               phys_start = region->addr; 
    2245 -               phys_end = phys_start + region->size - 1; 
    2246 - 
    2247 -               res = alloc_bootmem_low(sizeof(*res)); 
    2248 -               res->name = "System RAM"; 
    2249 -               res->start = phys_start; 
    2250 -               res->end = phys_end; 
    2251 -               res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 
    2252 - 
    2253 -               request_resource (&iomem_resource, res); 
    2254 - 
    2255 -               if (kernel_code.start >= res->start && 
    2256 -                   kernel_code.end <= res->end) 
    2257 -                       request_resource (res, &kernel_code); 
    2258 -               if (kernel_data.start >= res->start && 
    2259 -                   kernel_data.end <= res->end) 
    2260 -                       request_resource (res, &kernel_data); 
    2261 +       if (!fbmem_start) { 
    2262 +               if ((fbmem_size & 0x000fffffUL) == 0) 
    2263 +                       align = 0x100000;       /* 1 MiB */ 
    2264 +               else if ((fbmem_size & 0x0000ffffUL) == 0) 
    2265 +                       align = 0x10000;        /* 64 KiB */ 
    2266 +               else 
    2267 +                       align = 0x1000;         /* 4 KiB */ 
    2268 + 
    2269 +               ret = alloc_reserved_region(&fbmem_start, fbmem_size, 
    2270 +                                           align, "Framebuffer"); 
    2271 +               if (ret) { 
    2272 +                       printk(KERN_WARNING 
    2273 +                              "Failed to allocate framebuffer memory\n"); 
    2274 +                       fbmem_size = 0; 
    2275 +               } 
    2276         } 
    2277 + 
    2278 +       return 0; 
    2279  } 
    2280 +early_param("fbmem", early_parse_fbmem); 
    2281   
    2282  static int __init parse_tag_core(struct tag *tag) 
    2283  { 
    2284 @@ -157,11 +291,9 @@ 
    2285  } 
    2286  __tagtable(ATAG_CORE, parse_tag_core); 
    2287   
    2288 -static int __init parse_tag_mem_range(struct tag *tag, 
    2289 -                                     struct tag_mem_range **root) 
    2290 +static int __init parse_tag_mem(struct tag *tag) 
    2291  { 
    2292 -       struct tag_mem_range *cur, **pprev; 
    2293 -       struct tag_mem_range *new; 
    2294 +       unsigned long start, end; 
    2295   
    2296         /* 
    2297          * Ignore zero-sized entries. If we're running standalone, the 
    2298 @@ -171,34 +303,53 @@ 
    2299         if (tag->u.mem_range.size == 0) 
    2300                 return 0; 
    2301   
    2302 -       /* 
    2303 -        * Copy the data so the bootmem init code doesn't need to care 
    2304 -        * about it. 
    2305 -        */ 
    2306 -       if (mem_range_next_free >= ARRAY_SIZE(mem_range_cache)) 
    2307 -               panic("Physical memory map too complex!\n"); 
    2308 +       start = tag->u.mem_range.addr; 
    2309 +       end = tag->u.mem_range.addr + tag->u.mem_range.size - 1; 
    2310   
    2311 -       new = &mem_range_cache[mem_range_next_free++]; 
    2312 -       *new = tag->u.mem_range; 
    2313 +       add_physical_memory(start, end); 
    2314 +       return 0; 
    2315 +} 
    2316 +__tagtable(ATAG_MEM, parse_tag_mem); 
    2317   
    2318 -       pprev = root; 
    2319 -       cur = *root; 
    2320 -       while (cur) { 
    2321 -               pprev = &cur->next; 
    2322 -               cur = cur->next; 
    2323 +static int __init parse_tag_rdimg(struct tag *tag) 
    2324 +{ 
    2325 +#ifdef CONFIG_INITRD 
    2326 +       struct tag_mem_range *mem = &tag->u.mem_range; 
    2327 +       int ret; 
    2328 + 
    2329 +       if (initrd_start) { 
    2330 +               printk(KERN_WARNING 
    2331 +                      "Warning: Only the first initrd image will be used\n"); 
    2332 +               return 0; 
    2333         } 
    2334   
    2335 -       *pprev = new; 
    2336 -       new->next = NULL; 
    2337 +       ret = add_reserved_region(mem->start, mem->start + mem->size - 1, 
    2338 +                                 "initrd"); 
    2339 +       if (ret) { 
    2340 +               printk(KERN_WARNING 
    2341 +                      "Warning: Failed to reserve initrd memory\n"); 
    2342 +               return ret; 
    2343 +       } 
    2344 + 
    2345 +       initrd_start = (unsigned long)__va(mem->addr); 
    2346 +       initrd_end = initrd_start + mem->size; 
    2347 +#else 
    2348 +       printk(KERN_WARNING "RAM disk image present, but " 
    2349 +              "no initrd support in kernel, ignoring\n"); 
    2350 +#endif 
    2351   
    2352         return 0; 
    2353  } 
    2354 +__tagtable(ATAG_RDIMG, parse_tag_rdimg); 
    2355   
    2356 -static int __init parse_tag_mem(struct tag *tag) 
    2357 +static int __init parse_tag_rsvd_mem(struct tag *tag) 
    2358  { 
    2359 -       return parse_tag_mem_range(tag, &mem_phys); 
    2360 +       struct tag_mem_range *mem = &tag->u.mem_range; 
    2361 + 
    2362 +       return add_reserved_region(mem->addr, mem->addr + mem->size - 1, 
    2363 +                                  "Reserved"); 
    2364  } 
    2365 -__tagtable(ATAG_MEM, parse_tag_mem); 
    2366 +__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem); 
    2367   
    2368  static int __init parse_tag_cmdline(struct tag *tag) 
    2369  { 
    2370 @@ -207,12 +358,6 @@ 
    2371  } 
    2372  __tagtable(ATAG_CMDLINE, parse_tag_cmdline); 
    2373   
    2374 -static int __init parse_tag_rdimg(struct tag *tag) 
    2375 -{ 
    2376 -       return parse_tag_mem_range(tag, &mem_ramdisk); 
    2377 -} 
    2378 -__tagtable(ATAG_RDIMG, parse_tag_rdimg); 
    2379 - 
    2380  static int __init parse_tag_clock(struct tag *tag) 
    2381  { 
    2382         /* 
    2383 @@ -223,12 +368,6 @@ 
    2384  } 
    2385  __tagtable(ATAG_CLOCK, parse_tag_clock); 
    2386   
    2387 -static int __init parse_tag_rsvd_mem(struct tag *tag) 
    2388 -{ 
    2389 -       return parse_tag_mem_range(tag, &mem_reserved); 
    2390 -} 
    2391 -__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem); 
    2392 - 
    2393  /* 
    2394   * Scan the tag table for this tag, and call its parse function. The 
    2395   * tag table is built by the linker from all the __tagtable 
    2396 @@ -260,10 +399,137 @@ 
    2397                                t->hdr.tag); 
    2398  } 
    2399   
    2400 +/* 
    2401 + * Find a free memory region large enough for storing the 
    2402 + * bootmem bitmap. 
    2403 + */ 
    2404 +static unsigned long __init 
    2405 +find_bootmap_pfn(const struct resource *mem) 
    2406 +{ 
    2407 +       unsigned long bootmap_pages, bootmap_len; 
    2408 +       unsigned long node_pages = PFN_UP(mem->end - mem->start + 1); 
    2409 +       unsigned long bootmap_start; 
    2410 + 
    2411 +       bootmap_pages = bootmem_bootmap_pages(node_pages); 
    2412 +       bootmap_len = bootmap_pages << PAGE_SHIFT; 
    2413 + 
    2414 +       /* 
    2415 +        * Find a large enough region without reserved pages for 
    2416 +        * storing the bootmem bitmap. We can take advantage of the 
    2417 +        * fact that all lists have been sorted. 
    2418 +        * 
    2419 +        * We have to check that we don't collide with any reserved 
    2420 +        * regions, which includes the kernel image and any RAMDISK 
    2421 +        * images. 
    2422 +        */ 
    2423 +       bootmap_start = find_free_region(mem, bootmap_len, PAGE_SIZE); 
    2424 + 
    2425 +       return bootmap_start >> PAGE_SHIFT; 
    2426 +} 
    2427 + 
    2428 +#define MAX_LOWMEM     HIGHMEM_START 
    2429 +#define MAX_LOWMEM_PFN PFN_DOWN(MAX_LOWMEM) 
    2430 + 
    2431 +static void __init setup_bootmem(void) 
    2432 +{ 
    2433 +       unsigned bootmap_size; 
    2434 +       unsigned long first_pfn, bootmap_pfn, pages; 
    2435 +       unsigned long max_pfn, max_low_pfn; 
    2436 +       unsigned node = 0; 
    2437 +       struct resource *res; 
    2438 + 
    2439 +       printk(KERN_INFO "Physical memory:\n"); 
    2440 +       for (res = system_ram; res; res = res->sibling) 
    2441 +               printk("  %08x-%08x\n", res->start, res->end); 
    2442 +       printk(KERN_INFO "Reserved memory:\n"); 
    2443 +       for (res = reserved; res; res = res->sibling) 
    2444 +               printk("  %08x-%08x: %s\n", 
    2445 +                      res->start, res->end, res->name); 
    2446 + 
    2447 +       nodes_clear(node_online_map); 
    2448 + 
    2449 +       if (system_ram->sibling) 
    2450 +               printk(KERN_WARNING "Only using first memory bank\n"); 
    2451 + 
    2452 +       for (res = system_ram; res; res = NULL) { 
    2453 +               first_pfn = PFN_UP(res->start); 
    2454 +               max_low_pfn = max_pfn = PFN_DOWN(res->end + 1); 
    2455 +               bootmap_pfn = find_bootmap_pfn(res); 
    2456 +               if (bootmap_pfn > max_pfn) 
    2457 +                       panic("No space for bootmem bitmap!\n"); 
    2458 + 
    2459 +               if (max_low_pfn > MAX_LOWMEM_PFN) { 
    2460 +                       max_low_pfn = MAX_LOWMEM_PFN; 
    2461 +#ifndef CONFIG_HIGHMEM 
    2462 +                       /* 
    2463 +                        * Lowmem is memory that can be addressed 
    2464 +                        * directly through P1/P2 
    2465 +                        */ 
    2466 +                       printk(KERN_WARNING 
    2467 +                              "Node %u: Only %ld MiB of memory will be used.\n", 
    2468 +                              node, MAX_LOWMEM >> 20); 
    2469 +                       printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n"); 
    2470 +#else 
    2471 +#error HIGHMEM is not supported by AVR32 yet 
    2472 +#endif 
    2473 +               } 
    2474 + 
    2475 +               /* Initialize the boot-time allocator with low memory only. */ 
    2476 +               bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn, 
    2477 +                                                first_pfn, max_low_pfn); 
    2478 + 
    2479 +               /* 
    2480 +                * Register fully available RAM pages with the bootmem 
    2481 +                * allocator. 
    2482 +                */ 
    2483 +               pages = max_low_pfn - first_pfn; 
    2484 +               free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn), 
    2485 +                                  PFN_PHYS(pages)); 
    2486 + 
    2487 +               /* Reserve space for the bootmem bitmap... */ 
    2488 +               reserve_bootmem_node(NODE_DATA(node), 
    2489 +                                    PFN_PHYS(bootmap_pfn), 
    2490 +                                    bootmap_size); 
    2491 + 
    2492 +               /* ...and any other reserved regions. */ 
    2493 +               for (res = reserved; res; res = res->sibling) { 
    2494 +                       if (res->start > PFN_PHYS(max_pfn)) 
    2495 +                               break; 
    2496 + 
    2497 +                       /* 
    2498 +                        * resource_init will complain about partial 
    2499 +                        * overlaps, so we'll just ignore such 
    2500 +                        * resources for now. 
    2501 +                        */ 
    2502 +                       if (res->start >= PFN_PHYS(first_pfn) 
    2503 +                           && res->end < PFN_PHYS(max_pfn)) 
    2504 +                               reserve_bootmem_node( 
    2505 +                                       NODE_DATA(node), res->start, 
    2506 +                                       res->end - res->start + 1); 
    2507 +               } 
    2508 + 
    2509 +               node_set_online(node); 
    2510 +       } 
    2511 +} 
    2512 + 
    2513  void __init setup_arch (char **cmdline_p) 
    2514  { 
    2515         struct clk *cpu_clk; 
    2516   
    2517 +       init_mm.start_code = (unsigned long)_text; 
    2518 +       init_mm.end_code = (unsigned long)_etext; 
    2519 +       init_mm.end_data = (unsigned long)_edata; 
    2520 +       init_mm.brk = (unsigned long)_end; 
    2521 + 
    2522 +       /* 
    2523 +        * Include .init section to make allocations easier. It will 
    2524 +        * be removed before the resource is actually requested. 
    2525 +        */ 
    2526 +       kernel_code.start = __pa(__init_begin); 
    2527 +       kernel_code.end = __pa(init_mm.end_code - 1); 
    2528 +       kernel_data.start = __pa(init_mm.end_code); 
    2529 +       kernel_data.end = __pa(init_mm.brk - 1); 
    2530 + 
    2531         parse_tags(bootloader_tags); 
    2532   
    2533         setup_processor(); 
    2534 @@ -289,24 +555,16 @@ 
    2535                        ((cpu_hz + 500) / 1000) % 1000); 
    2536         } 
    2537   
    2538 -       init_mm.start_code = (unsigned long) &_text; 
    2539 -       init_mm.end_code = (unsigned long) &_etext; 
    2540 -       init_mm.end_data = (unsigned long) &_edata; 
    2541 -       init_mm.brk = (unsigned long) &_end; 
    2542 - 
    2543         strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); 
    2544         *cmdline_p = command_line; 
    2545         parse_early_param(); 
    2546   
    2547         setup_bootmem(); 
    2548   
    2549 -       board_setup_fbmem(fbmem_start, fbmem_size); 
    2550 - 
    2551  #ifdef CONFIG_VT 
    2552         conswitchp = &dummy_con; 
    2553  #endif 
    2554   
    2555         paging_init(); 
    2556 - 
    2557         resource_init(); 
    2558  } 
    2559 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/time.c avr32-git/arch/avr32/kernel/time.c 
    2560 --- linux-2.6.21.3/arch/avr32/kernel/time.c     2007-05-24 23:22:47.000000000 +0200 
    2561 +++ avr32-git/arch/avr32/kernel/time.c  2007-06-06 11:33:46.000000000 +0200 
    2562 @@ -1,5 +1,5 @@ 
    2563  /* 
    2564 - * Copyright (C) 2004-2006 Atmel Corporation 
    2565 + * Copyright (C) 2004-2007 Atmel Corporation 
    2566   * 
    2567   * Based on MIPS implementation arch/mips/kernel/time.c 
    2568   *   Copyright 2001 MontaVista Software Inc. 
    2569 @@ -20,18 +20,25 @@ 
    2570  #include <linux/init.h> 
    2571  #include <linux/profile.h> 
    2572  #include <linux/sysdev.h> 
    2573 +#include <linux/err.h> 
    2574   
    2575  #include <asm/div64.h> 
    2576  #include <asm/sysreg.h> 
    2577  #include <asm/io.h> 
    2578  #include <asm/sections.h> 
    2579   
    2580 -static cycle_t read_cycle_count(void) 
    2581 +/* how many counter cycles in a jiffy? */ 
    2582 +static u32 cycles_per_jiffy; 
    2583 + 
    2584 +/* the count value for the next timer interrupt */ 
    2585 +static u32 expirelo; 
    2586 + 
    2587 +cycle_t __weak read_cycle_count(void) 
    2588  { 
    2589         return (cycle_t)sysreg_read(COUNT); 
    2590  } 
    2591   
    2592 -static struct clocksource clocksource_avr32 = { 
    2593 +struct clocksource __weak clocksource_avr32 = { 
    2594         .name           = "avr32", 
    2595         .rating         = 350, 
    2596         .read           = read_cycle_count, 
    2597 @@ -40,12 +47,20 @@ 
    2598         .flags          = CLOCK_SOURCE_IS_CONTINUOUS, 
    2599  }; 
    2600   
    2601 +irqreturn_t __weak timer_interrupt(int irq, void *dev_id); 
    2602 + 
    2603 +struct irqaction timer_irqaction = { 
    2604 +       .handler        = timer_interrupt, 
    2605 +       .flags          = IRQF_DISABLED, 
    2606 +       .name           = "timer", 
    2607 +}; 
    2608 + 
    2609  /* 
    2610   * By default we provide the null RTC ops 
    2611   */ 
    2612  static unsigned long null_rtc_get_time(void) 
    2613  { 
    2614 -       return mktime(2004, 1, 1, 0, 0, 0); 
    2615 +       return mktime(2007, 1, 1, 0, 0, 0); 
    2616  } 
    2617   
    2618  static int null_rtc_set_time(unsigned long sec) 
    2619 @@ -56,23 +71,14 @@ 
    2620  static unsigned long (*rtc_get_time)(void) = null_rtc_get_time; 
    2621  static int (*rtc_set_time)(unsigned long) = null_rtc_set_time; 
    2622   
    2623 -/* how many counter cycles in a jiffy? */ 
    2624 -static unsigned long cycles_per_jiffy; 
    2625 - 
    2626 -/* cycle counter value at the previous timer interrupt */ 
    2627 -static unsigned int timerhi, timerlo; 
    2628 - 
    2629 -/* the count value for the next timer interrupt */ 
    2630 -static unsigned int expirelo; 
    2631 - 
    2632  static void avr32_timer_ack(void) 
    2633  { 
    2634 -       unsigned int count; 
    2635 +       u32 count; 
    2636   
    2637         /* Ack this timer interrupt and set the next one */ 
    2638         expirelo += cycles_per_jiffy; 
    2639 +       /* setting COMPARE to 0 stops the COUNT-COMPARE */ 
    2640         if (expirelo == 0) { 
    2641 -               printk(KERN_DEBUG "expirelo == 0\n"); 
    2642                 sysreg_write(COMPARE, expirelo + 1); 
    2643         } else { 
    2644                 sysreg_write(COMPARE, expirelo); 
    2645 @@ -86,27 +92,56 @@ 
    2646         } 
    2647  } 
    2648   
    2649 -static unsigned int avr32_hpt_read(void) 
    2650 +int __weak avr32_hpt_init(void) 
    2651  { 
    2652 -       return sysreg_read(COUNT); 
    2653 +       int ret; 
    2654 +       unsigned long mult, shift, count_hz; 
    2655 + 
    2656 +       count_hz = clk_get_rate(boot_cpu_data.clk); 
    2657 +       shift = clocksource_avr32.shift; 
    2658 +       mult = clocksource_hz2mult(count_hz, shift); 
    2659 +       clocksource_avr32.mult = mult; 
    2660 + 
    2661 +       { 
    2662 +               u64 tmp; 
    2663 + 
    2664 +               tmp = TICK_NSEC; 
    2665 +               tmp <<= shift; 
    2666 +               tmp += mult / 2; 
    2667 +               do_div(tmp, mult); 
    2668 + 
    2669 +               cycles_per_jiffy = tmp; 
    2670 +       } 
    2671 + 
    2672 +       ret = setup_irq(0, &timer_irqaction); 
    2673 +       if (ret) { 
    2674 +               pr_debug("timer: could not request IRQ 0: %d\n", ret); 
    2675 +               return -ENODEV; 
    2676 +       } 
    2677 + 
    2678 +       printk(KERN_INFO "timer: AT32AP COUNT-COMPARE at irq 0, " 
    2679 +                       "%lu.%03lu MHz\n", 
    2680 +                       ((count_hz + 500) / 1000) / 1000, 
    2681 +                       ((count_hz + 500) / 1000) % 1000); 
    2682 + 
    2683 +       return 0; 
    2684  } 
    2685   
    2686  /* 
    2687   * Taken from MIPS c0_hpt_timer_init(). 
    2688   * 
    2689 - * Why is it so complicated, and what is "count"?  My assumption is 
    2690 - * that `count' specifies the "reference cycle", i.e. the cycle since 
    2691 - * reset that should mean "zero". The reason COUNT is written twice is 
    2692 - * probably to make sure we don't get any timer interrupts while we 
    2693 - * are messing with the counter. 
    2694 + * The reason COUNT is written twice is probably to make sure we don't get any 
    2695 + * timer interrupts while we are messing with the counter. 
    2696   */ 
    2697 -static void avr32_hpt_init(unsigned int count) 
    2698 +int __weak avr32_hpt_start(void) 
    2699  { 
    2700 -       count = sysreg_read(COUNT) - count; 
    2701 +       u32 count = sysreg_read(COUNT); 
    2702         expirelo = (count / cycles_per_jiffy + 1) * cycles_per_jiffy; 
    2703         sysreg_write(COUNT, expirelo - cycles_per_jiffy); 
    2704         sysreg_write(COMPARE, expirelo); 
    2705         sysreg_write(COUNT, count); 
    2706 + 
    2707 +       return 0; 
    2708  } 
    2709   
    2710  /* 
    2711 @@ -115,26 +150,18 @@ 
    2712   * 
    2713   * In UP mode, it is invoked from the (global) timer_interrupt. 
    2714   */ 
    2715 -static void local_timer_interrupt(int irq, void *dev_id) 
    2716 +void local_timer_interrupt(int irq, void *dev_id) 
    2717  { 
    2718         if (current->pid) 
    2719                 profile_tick(CPU_PROFILING); 
    2720         update_process_times(user_mode(get_irq_regs())); 
    2721  } 
    2722   
    2723 -static irqreturn_t 
    2724 -timer_interrupt(int irq, void *dev_id) 
    2725 +irqreturn_t __weak timer_interrupt(int irq, void *dev_id) 
    2726  { 
    2727 -       unsigned int count; 
    2728 - 
    2729         /* ack timer interrupt and try to set next interrupt */ 
    2730 -       count = avr32_hpt_read(); 
    2731         avr32_timer_ack(); 
    2732   
    2733 -       /* Update timerhi/timerlo for intra-jiffy calibration */ 
    2734 -       timerhi += count < timerlo;     /* Wrap around */ 
    2735 -       timerlo = count; 
    2736 - 
    2737         /* 
    2738          * Call the generic timer interrupt handler 
    2739          */ 
    2740 @@ -153,60 +180,37 @@ 
    2741         return IRQ_HANDLED; 
    2742  } 
    2743   
    2744 -static struct irqaction timer_irqaction = { 
    2745 -       .handler        = timer_interrupt, 
    2746 -       .flags          = IRQF_DISABLED, 
    2747 -       .name           = "timer", 
    2748 -}; 
    2749 - 
    2750  void __init time_init(void) 
    2751  { 
    2752 -       unsigned long mult, shift, count_hz; 
    2753         int ret; 
    2754   
    2755 +       /* 
    2756 +        * Make sure we don't get any COMPARE interrupts before we can 
    2757 +        * handle them. 
    2758 +        */ 
    2759 +       sysreg_write(COMPARE, 0); 
    2760 + 
    2761         xtime.tv_sec = rtc_get_time(); 
    2762         xtime.tv_nsec = 0; 
    2763   
    2764         set_normalized_timespec(&wall_to_monotonic, 
    2765                                 -xtime.tv_sec, -xtime.tv_nsec); 
    2766   
    2767 -       printk("Before time_init: count=%08lx, compare=%08lx\n", 
    2768 -              (unsigned long)sysreg_read(COUNT), 
    2769 -              (unsigned long)sysreg_read(COMPARE)); 
    2770 - 
    2771 -       count_hz = clk_get_rate(boot_cpu_data.clk); 
    2772 -       shift = clocksource_avr32.shift; 
    2773 -       mult = clocksource_hz2mult(count_hz, shift); 
    2774 -       clocksource_avr32.mult = mult; 
    2775 - 
    2776 -       printk("Cycle counter: mult=%lu, shift=%lu\n", mult, shift); 
    2777 - 
    2778 -       { 
    2779 -               u64 tmp; 
    2780 - 
    2781 -               tmp = TICK_NSEC; 
    2782 -               tmp <<= shift; 
    2783 -               tmp += mult / 2; 
    2784 -               do_div(tmp, mult); 
    2785 - 
    2786 -               cycles_per_jiffy = tmp; 
    2787 +       ret = avr32_hpt_init(); 
    2788 +       if (ret) { 
    2789 +               pr_debug("timer: failed setup: %d\n", ret); 
    2790 +               return; 
    2791         } 
    2792   
    2793 -       /* This sets up the high precision timer for the first interrupt. */ 
    2794 -       avr32_hpt_init(avr32_hpt_read()); 
    2795 - 
    2796 -       printk("After time_init: count=%08lx, compare=%08lx\n", 
    2797 -              (unsigned long)sysreg_read(COUNT), 
    2798 -              (unsigned long)sysreg_read(COMPARE)); 
    2799 - 
    2800         ret = clocksource_register(&clocksource_avr32); 
    2801         if (ret) 
    2802 -               printk(KERN_ERR 
    2803 -                      "timer: could not register clocksource: %d\n", ret); 
    2804 +               pr_debug("timer: could not register clocksource: %d\n", ret); 
    2805   
    2806 -       ret = setup_irq(0, &timer_irqaction); 
    2807 -       if (ret) 
    2808 -               printk("timer: could not request IRQ 0: %d\n", ret); 
    2809 +       ret = avr32_hpt_start(); 
    2810 +       if (ret) { 
    2811 +               pr_debug("timer: failed starting: %d\n", ret); 
    2812 +               return; 
    2813 +       } 
    2814  } 
    2815   
    2816  static struct sysdev_class timer_class = { 
    2817 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/kernel/traps.c avr32-git/arch/avr32/kernel/traps.c 
    2818 --- linux-2.6.21.3/arch/avr32/kernel/traps.c    2007-05-24 23:22:47.000000000 +0200 
    2819 +++ avr32-git/arch/avr32/kernel/traps.c 2007-06-06 11:33:46.000000000 +0200 
    2820 @@ -5,158 +5,25 @@ 
    2821   * it under the terms of the GNU General Public License version 2 as 
    2822   * published by the Free Software Foundation. 
    2823   */ 
    2824 -#undef DEBUG 
    2825 -#include <linux/sched.h> 
    2826 + 
    2827 +#include <linux/bug.h> 
    2828  #include <linux/init.h> 
    2829 -#include <linux/module.h> 
    2830  #include <linux/kallsyms.h> 
    2831 +#include <linux/module.h> 
    2832  #include <linux/notifier.h> 
    2833 +#include <linux/sched.h> 
    2834 +#include <linux/uaccess.h> 
    2835   
    2836 -#include <asm/traps.h> 
    2837 -#include <asm/sysreg.h> 
    2838  #include <asm/addrspace.h> 
    2839 -#include <asm/ocd.h> 
    2840  #include <asm/mmu_context.h> 
    2841 -#include <asm/uaccess.h> 
    2842 - 
    2843 -static void dump_mem(const char *str, unsigned long bottom, unsigned long top) 
    2844 -{ 
    2845 -       unsigned long p; 
    2846 -       int i; 
    2847 - 
    2848 -       printk("%s(0x%08lx to 0x%08lx)\n", str, bottom, top); 
    2849 - 
    2850 -       for (p = bottom & ~31; p < top; ) { 
    2851 -               printk("%04lx: ", p & 0xffff); 
    2852 - 
    2853 -               for (i = 0; i < 8; i++, p += 4) { 
    2854 -                       unsigned int val; 
    2855 - 
    2856 -                       if (p < bottom || p >= top) 
    2857 -                               printk("         "); 
    2858 -                       else { 
    2859 -                               if (__get_user(val, (unsigned int __user *)p)) { 
    2860 -                                       printk("\n"); 
    2861 -                                       goto out; 
    2862 -                               } 
    2863 -                               printk("%08x ", val); 
    2864 -                       } 
    2865 -               } 
    2866 -               printk("\n"); 
    2867 -       } 
    2868 - 
    2869 -out: 
    2870 -       return; 
    2871 -} 
    2872 - 
    2873 -static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p) 
    2874 -{ 
    2875 -       return (p > (unsigned long)tinfo) 
    2876 -               && (p < (unsigned long)tinfo + THREAD_SIZE - 3); 
    2877 -} 
    2878 - 
    2879 -#ifdef CONFIG_FRAME_POINTER 
    2880 -static inline void __show_trace(struct task_struct *tsk, unsigned long *sp, 
    2881 -                               struct pt_regs *regs) 
    2882 -{ 
    2883 -       unsigned long lr, fp; 
    2884 -       struct thread_info *tinfo; 
    2885 - 
    2886 -       tinfo = (struct thread_info *) 
    2887 -               ((unsigned long)sp & ~(THREAD_SIZE - 1)); 
    2888 - 
    2889 -       if (regs) 
    2890 -               fp = regs->r7; 
    2891 -       else if (tsk == current) 
    2892 -               asm("mov %0, r7" : "=r"(fp)); 
    2893 -       else 
    2894 -               fp = tsk->thread.cpu_context.r7; 
    2895 - 
    2896 -       /* 
    2897 -        * Walk the stack as long as the frame pointer (a) is within 
    2898 -        * the kernel stack of the task, and (b) it doesn't move 
    2899 -        * downwards. 
    2900 -        */ 
    2901 -       while (valid_stack_ptr(tinfo, fp)) { 
    2902 -               unsigned long new_fp; 
    2903 - 
    2904 -               lr = *(unsigned long *)fp; 
    2905 -               printk(" [<%08lx>] ", lr); 
    2906 -               print_symbol("%s\n", lr); 
    2907 - 
    2908 -               new_fp = *(unsigned long *)(fp + 4); 
    2909 -               if (new_fp <= fp) 
    2910 -                       break; 
    2911 -               fp = new_fp; 
    2912 -       } 
    2913 -       printk("\n"); 
    2914 -} 
    2915 -#else 
    2916 -static inline void __show_trace(struct task_struct *tsk, unsigned long *sp, 
    2917 -                               struct pt_regs *regs) 
    2918 -{ 
    2919 -       unsigned long addr; 
    2920 - 
    2921 -       while (!kstack_end(sp)) { 
    2922 -               addr = *sp++; 
    2923 -               if (kernel_text_address(addr)) { 
    2924 -                       printk(" [<%08lx>] ", addr); 
    2925 -                       print_symbol("%s\n", addr); 
    2926 -               } 
    2927 -       } 
    2928 -} 
    2929 -#endif 
    2930 - 
    2931 -void show_trace(struct task_struct *tsk, unsigned long *sp, 
    2932 -                      struct pt_regs *regs) 
    2933 -{ 
    2934 -       if (regs && 
    2935 -           (((regs->sr & MODE_MASK) == MODE_EXCEPTION) || 
    2936 -            ((regs->sr & MODE_MASK) == MODE_USER))) 
    2937 -               return; 
    2938 - 
    2939 -       printk ("Call trace:"); 
    2940 -#ifdef CONFIG_KALLSYMS 
    2941 -       printk("\n"); 
    2942 -#endif 
    2943 - 
    2944 -       __show_trace(tsk, sp, regs); 
    2945 -       printk("\n"); 
    2946 -} 
    2947 - 
    2948 -void show_stack(struct task_struct *tsk, unsigned long *sp) 
    2949 -{ 
    2950 -       unsigned long stack; 
    2951 - 
    2952 -       if (!tsk) 
    2953 -               tsk = current; 
    2954 -       if (sp == 0) { 
    2955 -               if (tsk == current) { 
    2956 -                       register unsigned long *real_sp __asm__("sp"); 
    2957 -                       sp = real_sp; 
    2958 -               } else { 
    2959 -                       sp = (unsigned long *)tsk->thread.cpu_context.ksp; 
    2960 -               } 
    2961 -       } 
    2962 - 
    2963 -       stack = (unsigned long)sp; 
    2964 -       dump_mem("Stack: ", stack, 
    2965 -                THREAD_SIZE + (unsigned long)tsk->thread_info); 
    2966 -       show_trace(tsk, sp, NULL); 
    2967 -} 
    2968 - 
    2969 -void dump_stack(void) 
    2970 -{ 
    2971 -       show_stack(NULL, NULL); 
    2972 -} 
    2973 -EXPORT_SYMBOL(dump_stack); 
    2974 +#include <asm/ocd.h> 
    2975 +#include <asm/sysreg.h> 
    2976 +#include <asm/traps.h> 
    2977   
    2978  ATOMIC_NOTIFIER_HEAD(avr32_die_chain); 
    2979   
    2980  int register_die_notifier(struct notifier_block *nb) 
    2981  { 
    2982 -       pr_debug("register_die_notifier: %p\n", nb); 
    2983 - 
    2984         return atomic_notifier_chain_register(&avr32_die_chain, nb); 
    2985  } 
    2986  EXPORT_SYMBOL(register_die_notifier); 
    2987 @@ -169,98 +36,108 @@ 
    2988   
    2989  static DEFINE_SPINLOCK(die_lock); 
    2990   
    2991 -void __die(const char *str, struct pt_regs *regs, unsigned long err, 
    2992 -          const char *file, const char *func, unsigned long line) 
    2993 +void NORET_TYPE die(const char *str, struct pt_regs *regs, long err) 
    2994  { 
    2995 -       struct task_struct *tsk = current; 
    2996         static int die_counter; 
    2997   
    2998         console_verbose(); 
    2999         spin_lock_irq(&die_lock); 
    3000         bust_spinlocks(1); 
    3001   
    3002 -       printk(KERN_ALERT "%s", str); 
    3003 -       if (file && func) 
    3004 -               printk(" in %s:%s, line %ld", file, func, line); 
    3005 -       printk("[#%d]:\n", ++die_counter); 
    3006 -       print_modules(); 
    3007 -       show_regs(regs); 
    3008 -       printk("Process %s (pid: %d, stack limit = 0x%p)\n", 
    3009 -              tsk->comm, tsk->pid, tsk->thread_info + 1); 
    3010 - 
    3011 -       if (!user_mode(regs) || in_interrupt()) { 
    3012 -               dump_mem("Stack: ", regs->sp, 
    3013 -                        THREAD_SIZE + (unsigned long)tsk->thread_info); 
    3014 +       printk(KERN_ALERT "Oops: %s, sig: %ld [#%d]\n" KERN_EMERG, 
    3015 +              str, err, ++die_counter); 
    3016 +#ifdef CONFIG_PREEMPT 
    3017 +       printk("PREEMPT "); 
    3018 +#endif 
    3019 +#ifdef CONFIG_FRAME_POINTER 
    3020 +       printk("FRAME_POINTER "); 
    3021 +#endif 
    3022 +       if (current_cpu_data.features & AVR32_FEATURE_OCD) { 
    3023 +               unsigned long did = __mfdr(DBGREG_DID); 
    3024 +               printk("chip: 0x%03lx:0x%04lx rev %lu\n", 
    3025 +                      (did >> 1) & 0x7ff, 
    3026 +                      (did >> 12) & 0x7fff, 
    3027 +                      (did >> 28) & 0xf); 
    3028 +       } else { 
    3029 +               printk("cpu: arch %u r%u / core %u r%u\n", 
    3030 +                      current_cpu_data.arch_type, 
    3031 +                      current_cpu_data.arch_revision, 
    3032 +                      current_cpu_data.cpu_type, 
    3033 +                      current_cpu_data.cpu_revision); 
    3034         } 
    3035   
    3036 +       print_modules(); 
    3037 +       show_regs_log_lvl(regs, KERN_EMERG); 
    3038 +       show_stack_log_lvl(current, regs->sp, regs, KERN_EMERG); 
    3039         bust_spinlocks(0); 
    3040         spin_unlock_irq(&die_lock); 
    3041 -       do_exit(SIGSEGV); 
    3042 + 
    3043 +       if (in_interrupt()) 
    3044 +               panic("Fatal exception in interrupt"); 
    3045 + 
    3046 +       if (panic_on_oops) 
    3047 +               panic("Fatal exception"); 
    3048 + 
    3049 +       do_exit(err); 
    3050  } 
    3051   
    3052 -void __die_if_kernel(const char *str, struct pt_regs *regs, unsigned long err, 
    3053 -                    const char *file, const char *func, unsigned long line) 
    3054 +void _exception(long signr, struct pt_regs *regs, int code, 
    3055 +               unsigned long addr) 
    3056  { 
    3057 +       siginfo_t info; 
    3058 + 
    3059         if (!user_mode(regs)) 
    3060 -               __die(str, regs, err, file, func, line); 
    3061 -} 
    3062 +               die("Unhandled exception in kernel mode", regs, signr); 
    3063 + 
    3064 +       memset(&info, 0, sizeof(info)); 
    3065 +       info.si_signo = signr; 
    3066 +       info.si_code = code; 
    3067 +       info.si_addr = (void __user *)addr; 
    3068 +       force_sig_info(signr, &info, current); 
    3069   
    3070 -asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs) 
    3071 -{ 
    3072 -#ifdef CONFIG_SUBARCH_AVR32B 
    3073         /* 
    3074 -        * The exception entry always saves RSR_EX. For NMI, this is 
    3075 -        * wrong; it should be RSR_NMI 
    3076 +        * Init gets no signals that it doesn't have a handler for. 
    3077 +        * That's all very well, but if it has caused a synchronous 
    3078 +        * exception and we ignore the resulting signal, it will just 
    3079 +        * generate the same exception over and over again and we get 
    3080 +        * nowhere.  Better to kill it and let the kernel panic. 
    3081          */ 
    3082 -       regs->sr = sysreg_read(RSR_NMI); 
    3083 -#endif 
    3084 +       if (is_init(current)) { 
    3085 +               __sighandler_t handler; 
    3086   
    3087 -       printk("NMI taken!!!!\n"); 
    3088 -       die("NMI", regs, ecr); 
    3089 -       BUG(); 
    3090 +               spin_lock_irq(&current->sighand->siglock); 
    3091 +               handler = current->sighand->action[signr-1].sa.sa_handler; 
    3092 +               spin_unlock_irq(&current->sighand->siglock); 
    3093 +               if (handler == SIG_DFL) { 
    3094 +                       /* init has generated a synchronous exception 
    3095 +                          and it doesn't have a handler for the signal */ 
    3096 +                       printk(KERN_CRIT "init has generated signal %ld " 
    3097 +                              "but has no handler for it\n", signr); 
    3098 +                       do_exit(signr); 
    3099 +               } 
    3100 +       } 
    3101 +} 
    3102 + 
    3103 +asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs) 
    3104 +{ 
    3105 +       printk(KERN_ALERT "Got Non-Maskable Interrupt, dumping regs\n"); 
    3106 +       show_regs_log_lvl(regs, KERN_ALERT); 
    3107 +       show_stack_log_lvl(current, regs->sp, regs, KERN_ALERT); 
    3108  } 
    3109   
    3110  asmlinkage void do_critical_exception(unsigned long ecr, struct pt_regs *regs) 
    3111  { 
    3112 -       printk("Unable to handle critical exception %lu at pc = %08lx!\n", 
    3113 -              ecr, regs->pc); 
    3114 -       die("Oops", regs, ecr); 
    3115 -       BUG(); 
    3116 +       die("Critical exception", regs, SIGKILL); 
    3117  } 
    3118   
    3119  asmlinkage void do_address_exception(unsigned long ecr, struct pt_regs *regs) 
    3120  { 
    3121 -       siginfo_t info; 
    3122 - 
    3123 -       die_if_kernel("Oops: Address exception in kernel mode", regs, ecr); 
    3124 - 
    3125 -#ifdef DEBUG 
    3126 -       if (ecr == ECR_ADDR_ALIGN_X) 
    3127 -               pr_debug("Instruction Address Exception at pc = %08lx\n", 
    3128 -                        regs->pc); 
    3129 -       else if (ecr == ECR_ADDR_ALIGN_R) 
    3130 -               pr_debug("Data Address Exception (Read) at pc = %08lx\n", 
    3131 -                        regs->pc); 
    3132 -       else if (ecr == ECR_ADDR_ALIGN_W) 
    3133 -               pr_debug("Data Address Exception (Write) at pc = %08lx\n", 
    3134 -                        regs->pc); 
    3135 -       else 
    3136 -               BUG(); 
    3137 - 
    3138 -       show_regs(regs); 
    3139 -#endif 
    3140 - 
    3141 -       info.si_signo = SIGBUS; 
    3142 -       info.si_errno = 0; 
    3143 -       info.si_code = BUS_ADRALN; 
    3144 -       info.si_addr = (void __user *)regs->pc; 
    3145 - 
    3146 -       force_sig_info(SIGBUS, &info, current); 
    3147 +       _exception(SIGBUS, regs, BUS_ADRALN, regs->pc); 
    3148  } 
    3149   
    3150  /* This way of handling undefined instructions is stolen from ARM */ 
    3151  static LIST_HEAD(undef_hook); 
    3152 -static spinlock_t undef_lock = SPIN_LOCK_UNLOCKED; 
    3153 +static DEFINE_SPINLOCK(undef_lock); 
    3154   
    3155  void register_undef_hook(struct undef_hook *hook) 
    3156  { 
    3157 @@ -280,7 +157,8 @@ 
    3158  { 
    3159         int cop_nr; 
    3160         u32 cpucr; 
    3161 -       if ( (insn & 0xfdf00000) == 0xf1900000 ) 
    3162 + 
    3163 +       if ((insn & 0xfdf00000) == 0xf1900000) 
    3164                 /* LDC0 */ 
    3165                 cop_nr = 0; 
    3166         else 
    3167 @@ -292,136 +170,91 @@ 
    3168         sysreg_write(CPUCR, cpucr); 
    3169   
    3170         cpucr = sysreg_read(CPUCR); 
    3171 -       if ( !(cpucr & (1 << (24 + cop_nr))) ){ 
    3172 -               printk("Coprocessor #%i not found!\n", cop_nr); 
    3173 -               return -1; 
    3174 -       } 
    3175 +       if (!(cpucr & (1 << (24 + cop_nr)))) 
    3176 +               return -ENODEV; 
    3177   
    3178         return 0; 
    3179  } 
    3180   
    3181 -#ifdef CONFIG_BUG 
    3182 -#ifdef CONFIG_DEBUG_BUGVERBOSE 
    3183 -static inline void do_bug_verbose(struct pt_regs *regs, u32 insn) 
    3184 -{ 
    3185 -       char *file; 
    3186 -       u16 line; 
    3187 -       char c; 
    3188 - 
    3189 -       if (__get_user(line, (u16 __user *)(regs->pc + 2))) 
    3190 -               return; 
    3191 -       if (__get_user(file, (char * __user *)(regs->pc + 4)) 
    3192 -           || (unsigned long)file < PAGE_OFFSET 
    3193 -           || __get_user(c, file)) 
    3194 -               file = "<bad filename>"; 
    3195 - 
    3196 -       printk(KERN_ALERT "kernel BUG at %s:%d!\n", file, line); 
    3197 -} 
    3198 -#else 
    3199 -static inline void do_bug_verbose(struct pt_regs *regs, u32 insn) 
    3200 +int is_valid_bugaddr(unsigned long pc) 
    3201  { 
    3202 +       unsigned short opcode; 
    3203 + 
    3204 +       if (pc < PAGE_OFFSET) 
    3205 +               return 0; 
    3206 +       if (probe_kernel_address((u16 *)pc, opcode)) 
    3207 +               return 0; 
    3208   
    3209 +       return opcode == AVR32_BUG_OPCODE; 
    3210  } 
    3211 -#endif 
    3212 -#endif 
    3213   
    3214  asmlinkage void do_illegal_opcode(unsigned long ecr, struct pt_regs *regs) 
    3215  { 
    3216         u32 insn; 
    3217         struct undef_hook *hook; 
    3218 -       siginfo_t info; 
    3219         void __user *pc; 
    3220 +       long code; 
    3221   
    3222 -       if (!user_mode(regs)) 
    3223 -               goto kernel_trap; 
    3224 +       if (!user_mode(regs) && (ecr == ECR_ILLEGAL_OPCODE)) { 
    3225 +               enum bug_trap_type type; 
    3226 + 
    3227 +               type = report_bug(regs->pc); 
    3228 +               switch (type) { 
    3229 +               case BUG_TRAP_TYPE_NONE: 
    3230 +                       break; 
    3231 +               case BUG_TRAP_TYPE_WARN: 
    3232 +                       regs->pc += 2; 
    3233 +                       return; 
    3234 +               case BUG_TRAP_TYPE_BUG: 
    3235 +                       die("Kernel BUG", regs, SIGKILL); 
    3236 +               } 
    3237 +       } 
    3238   
    3239         local_irq_enable(); 
    3240   
    3241 -       pc = (void __user *)instruction_pointer(regs); 
    3242 -       if (__get_user(insn, (u32 __user *)pc)) 
    3243 -               goto invalid_area; 
    3244 +       if (user_mode(regs)) { 
    3245 +               pc = (void __user *)instruction_pointer(regs); 
    3246 +               if (get_user(insn, (u32 __user *)pc)) 
    3247 +                       goto invalid_area; 
    3248   
    3249 -        if (ecr == ECR_COPROC_ABSENT) { 
    3250 -               if (do_cop_absent(insn) == 0) 
    3251 +               if (ecr == ECR_COPROC_ABSENT && !do_cop_absent(insn)) 
    3252                         return; 
    3253 -        } 
    3254   
    3255 -       spin_lock_irq(&undef_lock); 
    3256 -       list_for_each_entry(hook, &undef_hook, node) { 
    3257 -               if ((insn & hook->insn_mask) == hook->insn_val) { 
    3258 -                       if (hook->fn(regs, insn) == 0) { 
    3259 -                               spin_unlock_irq(&undef_lock); 
    3260 -                               return; 
    3261 +               spin_lock_irq(&undef_lock); 
    3262 +               list_for_each_entry(hook, &undef_hook, node) { 
    3263 +                       if ((insn & hook->insn_mask) == hook->insn_val) { 
    3264 +                               if (hook->fn(regs, insn) == 0) { 
    3265 +                                       spin_unlock_irq(&undef_lock); 
    3266 +                                       return; 
    3267 +                               } 
    3268                         } 
    3269                 } 
    3270 +               spin_unlock_irq(&undef_lock); 
    3271         } 
    3272 -       spin_unlock_irq(&undef_lock); 
    3273 - 
    3274 -invalid_area: 
    3275   
    3276 -#ifdef DEBUG 
    3277 -       printk("Illegal instruction at pc = %08lx\n", regs->pc); 
    3278 -       if (regs->pc < TASK_SIZE) { 
    3279 -               unsigned long ptbr, pgd, pte, *p; 
    3280 - 
    3281 -               ptbr = sysreg_read(PTBR); 
    3282 -               p = (unsigned long *)ptbr; 
    3283 -               pgd = p[regs->pc >> 22]; 
    3284 -               p = (unsigned long *)((pgd & 0x1ffff000) | 0x80000000); 
    3285 -               pte = p[(regs->pc >> 12) & 0x3ff]; 
    3286 -               printk("page table: 0x%08lx -> 0x%08lx -> 0x%08lx\n", ptbr, pgd, pte); 
    3287 -       } 
    3288 -#endif 
    3289 - 
    3290 -       info.si_signo = SIGILL; 
    3291 -       info.si_errno = 0; 
    3292 -       info.si_addr = (void __user *)regs->pc; 
    3293         switch (ecr) { 
    3294 -       case ECR_ILLEGAL_OPCODE: 
    3295 -       case ECR_UNIMPL_INSTRUCTION: 
    3296 -               info.si_code = ILL_ILLOPC; 
    3297 -               break; 
    3298         case ECR_PRIVILEGE_VIOLATION: 
    3299 -               info.si_code = ILL_PRVOPC; 
    3300 +               code = ILL_PRVOPC; 
    3301                 break; 
    3302         case ECR_COPROC_ABSENT: 
    3303 -               info.si_code = ILL_COPROC; 
    3304 +               code = ILL_COPROC; 
    3305                 break; 
    3306         default: 
    3307 -               BUG(); 
    3308 +               code = ILL_ILLOPC; 
    3309 +               break; 
    3310         } 
    3311   
    3312 -       force_sig_info(SIGILL, &info, current); 
    3313 +       _exception(SIGILL, regs, code, regs->pc); 
    3314         return; 
    3315   
    3316 -kernel_trap: 
    3317 -#ifdef CONFIG_BUG 
    3318 -       if (__kernel_text_address(instruction_pointer(regs))) { 
    3319 -               insn = *(u16 *)instruction_pointer(regs); 
    3320 -               if (insn == AVR32_BUG_OPCODE) { 
    3321 -                       do_bug_verbose(regs, insn); 
    3322 -                       die("Kernel BUG", regs, 0); 
    3323 -                       return; 
    3324 -               } 
    3325 -       } 
    3326 -#endif 
    3327 - 
    3328 -       die("Oops: Illegal instruction in kernel code", regs, ecr); 
    3329 +invalid_area: 
    3330 +       _exception(SIGSEGV, regs, SEGV_MAPERR, regs->pc); 
    3331  } 
    3332   
    3333  asmlinkage void do_fpe(unsigned long ecr, struct pt_regs *regs) 
    3334  { 
    3335 -       siginfo_t info; 
    3336 - 
    3337 -       printk("Floating-point exception at pc = %08lx\n", regs->pc); 
    3338 - 
    3339 -       /* We have no FPU... */ 
    3340 -       info.si_signo = SIGILL; 
    3341 -       info.si_errno = 0; 
    3342 -       info.si_addr = (void __user *)regs->pc; 
    3343 -       info.si_code = ILL_COPROC; 
    3344 - 
    3345 -       force_sig_info(SIGILL, &info, current); 
    3346 +       /* We have no FPU yet */ 
    3347 +       _exception(SIGILL, regs, ILL_COPROC, regs->pc); 
    3348  } 
    3349   
    3350   
    3351 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 
    3352 --- linux-2.6.21.3/arch/avr32/kernel/vmlinux.lds.c      2007-05-24 23:22:47.000000000 +0200 
    3353 +++ avr32-git/arch/avr32/kernel/vmlinux.lds.c   2007-06-06 11:33:46.000000000 +0200 
    3354 @@ -26,10 +26,16 @@ 
    3355                         _sinittext = .; 
    3356                         *(.text.reset) 
    3357                         *(.init.text) 
    3358 +                       /* 
    3359 +                        * .exit.text is discarded at runtime, not 
    3360 +                        * link time, to deal with references from 
    3361 +                        * __bug_table 
    3362 +                        */ 
    3363 +                       *(.exit.text) 
    3364                         _einittext = .; 
    3365                 . = ALIGN(4); 
    3366                 __tagtable_begin = .; 
    3367 -                       *(.taglist) 
    3368 +                       *(.taglist.init) 
    3369                 __tagtable_end = .; 
    3370                         *(.init.data) 
    3371                 . = ALIGN(16); 
    3372 @@ -86,6 +92,8 @@ 
    3373                 __stop___ex_table = .; 
    3374         } 
    3375   
    3376 +       BUG_TABLE 
    3377 + 
    3378         RODATA 
    3379   
    3380         . = ALIGN(8192); 
    3381 @@ -126,7 +134,6 @@ 
    3382          * thrown away, as cleanup code is never called unless it's a module. 
    3383          */ 
    3384         /DISCARD/               : { 
    3385 -               *(.exit.text) 
    3386                 *(.exit.data) 
    3387                 *(.exitcall.exit) 
    3388         } 
    3389 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 
    3390 --- linux-2.6.21.3/arch/avr32/mach-at32ap/at32ap7000.c  2007-05-24 23:22:47.000000000 +0200 
    3391 +++ avr32-git/arch/avr32/mach-at32ap/at32ap7000.c       2007-06-06 11:33:46.000000000 +0200 
    3392 @@ -6,6 +6,7 @@ 
    3393   * published by the Free Software Foundation. 
    3394   */ 
    3395  #include <linux/clk.h> 
    3396 +#include <linux/fb.h> 
    3397  #include <linux/init.h> 
    3398  #include <linux/platform_device.h> 
    3399  #include <linux/spi/spi.h> 
    3400 @@ -17,7 +18,10 @@ 
    3401  #include <asm/arch/portmux.h> 
    3402  #include <asm/arch/sm.h> 
    3403   
    3404 +#include <video/atmel_lcdc.h> 
    3405 + 
    3406  #include "clock.h" 
    3407 +#include "hmatrix.h" 
    3408  #include "pio.h" 
    3409  #include "sm.h" 
    3410   
    3411 @@ -416,7 +420,15 @@ 
    3412         .resource       = sm_resource, 
    3413         .num_resources  = ARRAY_SIZE(sm_resource), 
    3414  }; 
    3415 -DEV_CLK(pclk, at32_sm, pbb, 0); 
    3416 +static struct clk at32_sm_pclk = { 
    3417 +       .name           = "pclk", 
    3418 +       .dev            = &at32_sm_device.dev, 
    3419 +       .parent         = &pbb_clk, 
    3420 +       .mode           = pbb_clk_mode, 
    3421 +       .get_rate       = pbb_clk_get_rate, 
    3422 +       .users          = 1, 
    3423 +       .index          = 0, 
    3424 +}; 
    3425   
    3426  static struct resource intc0_resource[] = { 
    3427         PBMEM(0xfff00400), 
    3428 @@ -442,6 +454,7 @@ 
    3429         .mode           = hsb_clk_mode, 
    3430         .get_rate       = hsb_clk_get_rate, 
    3431         .users          = 1, 
    3432 +       .index          = 3, 
    3433  }; 
    3434   
    3435  static struct resource smc0_resource[] = { 
    3436 @@ -466,6 +479,68 @@ 
     1689+static struct clk at32_pm_pclk = { 
     1690        .name           = "pclk", 
     1691-       .dev            = &at32_sm_device.dev, 
     1692+       .dev            = &at32_pm0_device.dev, 
     1693        .parent         = &pbb_clk, 
     1694        .mode           = pbb_clk_mode, 
     1695        .get_rate       = pbb_clk_get_rate, 
     1696@@ -491,6 +562,17 @@ 
    34371697        .users          = 1, 
    34381698 }; 
     
    34491709+DEV_CLK(hclk, dmaca0, hsb, 10); 
    34501710+ 
    3451 +/* -------------------------------------------------------------------- 
    3452 + * HMATRIX 
    3453 + * -------------------------------------------------------------------- */ 
    3454 + 
    3455 +static struct clk hmatrix_clk = { 
    3456 +       .name           = "hmatrix_clk", 
    3457 +       .parent         = &pbb_clk, 
    3458 +       .mode           = pbb_clk_mode, 
    3459 +       .get_rate       = pbb_clk_get_rate, 
    3460 +       .index          = 2, 
    3461 +       .users          = 1, 
    3462 +}; 
    3463 +#define HMATRIX_BASE   ((void __iomem *)0xfff00800) 
    3464 + 
    3465 +#define hmatrix_readl(reg)                                     \ 
    3466 +       __raw_readl((HMATRIX_BASE) + HMATRIX_##reg) 
    3467 +#define hmatrix_writel(reg,value)                              \ 
    3468 +       __raw_writel((value), (HMATRIX_BASE) + HMATRIX_##reg) 
    3469 + 
    3470 +/* 
    3471 + * Set bits in the HMATRIX Special Function Register (SFR) used by the 
    3472 + * External Bus Interface (EBI). This can be used to enable special 
    3473 + * features like CompactFlash support, NAND Flash support, etc. on 
    3474 + * certain chipselects. 
    3475 + */ 
    3476 +static inline void set_ebi_sfr_bits(u32 mask) 
    3477 +{ 
    3478 +       u32 sfr; 
    3479 + 
    3480 +       clk_enable(&hmatrix_clk); 
    3481 +       sfr = hmatrix_readl(SFR4); 
    3482 +       sfr |= mask; 
    3483 +       hmatrix_writel(SFR4, sfr); 
    3484 +       clk_disable(&hmatrix_clk); 
    3485 +} 
    3486 + 
    3487 +/* -------------------------------------------------------------------- 
    3488 + *  System Timer/Counter (TC) 
    3489 + * -------------------------------------------------------------------- */ 
    3490 +static struct resource at32_systc0_resource[] = { 
    3491 +       PBMEM(0xfff00c00), 
    3492 +       IRQ(22), 
    3493 +}; 
    3494 +struct platform_device at32_systc0_device = { 
    3495 +       .name           = "systc", 
    3496 +       .id             = 0, 
    3497 +       .resource       = at32_systc0_resource, 
    3498 +       .num_resources  = ARRAY_SIZE(at32_systc0_resource), 
    3499 +}; 
    3500 +DEV_CLK(pclk, at32_systc0, pbb, 3); 
    3501 + 
    35021711 /* -------------------------------------------------------------------- 
    3503   *  PIO 
     1712  * HMATRIX 
    35041713  * -------------------------------------------------------------------- */ 
    3505 @@ -513,6 +588,9 @@ 
     1714@@ -583,12 +665,14 @@ 
     1715  
     1716 void __init at32_add_system_devices(void) 
     1717 { 
     1718-       system_manager.eim_first_irq = EIM_IRQ_BASE; 
     1719- 
     1720-       platform_device_register(&at32_sm_device); 
     1721+       platform_device_register(&at32_pm0_device); 
    35061722        platform_device_register(&at32_intc0_device); 
     1723+       platform_device_register(&at32ap700x_rtc0_device); 
     1724+       platform_device_register(&at32_wdt0_device); 
     1725+       platform_device_register(&at32_eic0_device); 
    35071726        platform_device_register(&smc0_device); 
    35081727        platform_device_register(&pdc_device); 
    35091728+       platform_device_register(&dmaca0_device); 
    3510 + 
    3511 +       platform_device_register(&at32_systc0_device); 
    3512   
    3513         platform_device_register(&pio0_device); 
    3514         platform_device_register(&pio1_device); 
    3515 @@ -816,22 +894,105 @@ 
     1729  
     1730        platform_device_register(&at32_systc0_device); 
     1731  
     1732@@ -894,6 +978,83 @@ 
    35161733 } 
    35171734  
     
    35961813  *  LCDC 
    35971814  * -------------------------------------------------------------------- */ 
    3598 -static struct lcdc_platform_data lcdc0_data; 
    3599 -static struct resource lcdc0_resource[] = { 
    3600 +static struct atmel_lcdfb_info atmel_lcdfb0_data; 
    3601 +static struct resource atmel_lcdfb0_resource[] = { 
    3602         { 
    3603                 .start          = 0xff000000, 
    3604                 .end            = 0xff000fff, 
    3605                 .flags          = IORESOURCE_MEM, 
    3606         }, 
    3607         IRQ(1), 
    3608 +       { 
    3609 +               /* Placeholder for pre-allocated fb memory */ 
    3610 +               .start          = 0x00000000, 
    3611 +               .end            = 0x00000000, 
    3612 +               .flags          = 0, 
    3613 +       }, 
    3614  }; 
    3615 -DEFINE_DEV_DATA(lcdc, 0); 
    3616 -DEV_CLK(hclk, lcdc0, hsb, 7); 
    3617 -static struct clk lcdc0_pixclk = { 
    3618 -       .name           = "pixclk", 
    3619 -       .dev            = &lcdc0_device.dev, 
    3620 +DEFINE_DEV_DATA(atmel_lcdfb, 0); 
    3621 +DEV_CLK(hck1, atmel_lcdfb0, hsb, 7); 
    3622 +static struct clk atmel_lcdfb0_pixclk = { 
    3623 +       .name           = "lcdc_clk", 
    3624 +       .dev            = &atmel_lcdfb0_device.dev, 
    3625         .mode           = genclk_mode, 
    3626         .get_rate       = genclk_get_rate, 
    3627         .set_rate       = genclk_set_rate, 
    3628 @@ -840,13 +1001,34 @@ 
    3629  }; 
    3630   
    3631  struct platform_device *__init 
    3632 -at32_add_device_lcdc(unsigned int id, struct lcdc_platform_data *data) 
    3633 +at32_add_device_lcdc(unsigned int id, struct atmel_lcdfb_info *data, 
    3634 +                    unsigned long fbmem_start, unsigned long fbmem_len) 
    3635  { 
    3636         struct platform_device *pdev; 
    3637 +       struct atmel_lcdfb_info *info; 
    3638 +       struct fb_monspecs *monspecs; 
    3639 +       struct fb_videomode *modedb; 
    3640 +       unsigned int modedb_size; 
    3641 + 
    3642 +       /* 
    3643 +        * Do a deep copy of the fb data, monspecs and modedb. Make 
    3644 +        * sure all allocations are done before setting up the 
    3645 +        * portmux. 
    3646 +        */ 
    3647 +       monspecs = kmemdup(data->default_monspecs, 
    3648 +                          sizeof(struct fb_monspecs), GFP_KERNEL); 
    3649 +       if (!monspecs) 
    3650 +               return NULL; 
    3651 + 
    3652 +       modedb_size = sizeof(struct fb_videomode) * monspecs->modedb_len; 
    3653 +       modedb = kmemdup(monspecs->modedb, modedb_size, GFP_KERNEL); 
    3654 +       if (!modedb) 
    3655 +               goto err_dup_modedb; 
    3656 +       monspecs->modedb = modedb; 
    3657   
    3658         switch (id) { 
    3659         case 0: 
    3660 -               pdev = &lcdc0_device; 
    3661 +               pdev = &atmel_lcdfb0_device; 
    3662                 select_peripheral(PC(19), PERIPH_A, 0); /* CC     */ 
    3663                 select_peripheral(PC(20), PERIPH_A, 0); /* HSYNC  */ 
    3664                 select_peripheral(PC(21), PERIPH_A, 0); /* PCLK   */ 
    3665 @@ -879,16 +1061,133 @@ 
    3666                 select_peripheral(PD(16), PERIPH_A, 0); /* DATA22 */ 
    3667                 select_peripheral(PD(17), PERIPH_A, 0); /* DATA23 */ 
    3668   
    3669 -               clk_set_parent(&lcdc0_pixclk, &pll0); 
    3670 -               clk_set_rate(&lcdc0_pixclk, clk_get_rate(&pll0)); 
    3671 +               clk_set_parent(&atmel_lcdfb0_pixclk, &pll0); 
    3672 +               clk_set_rate(&atmel_lcdfb0_pixclk, clk_get_rate(&pll0)); 
    3673 +               break; 
    3674 + 
    3675 +       default: 
    3676 +               goto err_invalid_id; 
    3677 +       } 
    3678 + 
    3679 +       if (fbmem_len) { 
    3680 +               pdev->resource[2].start = fbmem_start; 
    3681 +               pdev->resource[2].end = fbmem_start + fbmem_len - 1; 
    3682 +               pdev->resource[2].flags = IORESOURCE_MEM; 
    3683 +       } 
    3684 + 
    3685 +       info = pdev->dev.platform_data; 
    3686 +       memcpy(info, data, sizeof(struct atmel_lcdfb_info)); 
    3687 +       info->default_monspecs = monspecs; 
    3688 + 
    3689 +       platform_device_register(pdev); 
    3690 +       return pdev; 
    3691 + 
    3692 +err_invalid_id: 
    3693 +       kfree(modedb); 
    3694 +err_dup_modedb: 
    3695 +       kfree(monspecs); 
    3696 +       return NULL; 
    3697 +} 
    3698 + 
    3699 +/* -------------------------------------------------------------------- 
     1815 static struct atmel_lcdfb_info atmel_lcdfb0_data; 
     1816@@ -1013,6 +1174,228 @@ 
     1817 } 
     1818  
     1819 /* -------------------------------------------------------------------- 
    37001820+ *  USB Device Controller 
    37011821+ * -------------------------------------------------------------------- */ 
    3702 +static struct resource usba0_resource[] = { 
     1822+static struct resource usba0_resource[] __initdata = { 
    37031823+       { 
     1824+               .name           = "fifo", 
    37041825+               .start          = 0xff300000, 
    37051826+               .end            = 0xff3fffff, 
    37061827+               .flags          = IORESOURCE_MEM, 
     1828+       }, { 
     1829+               .name           = "regs", 
     1830+               .start          = 0xfff03000, 
     1831+               .end            = 0xfff033ff, 
     1832+               .flags          = IORESOURCE_MEM, 
    37071833+       }, 
    3708 +       PBMEM(0xfff03000), 
    37091834+       IRQ(31), 
    37101835+}; 
    3711 +DEFINE_DEV(usba, 0); 
    3712 +DEV_CLK(pclk, usba0, pbb, 12); 
    3713 +DEV_CLK(hclk, usba0, hsb, 6); 
    3714 + 
    3715 +struct platform_device *__init at32_add_device_usba(unsigned int id) 
     1836+static struct clk usba0_pclk = { 
     1837+       .name           = "pclk", 
     1838+       .parent         = &pbb_clk, 
     1839+       .mode           = pbb_clk_mode, 
     1840+       .get_rate       = pbb_clk_get_rate, 
     1841+       .index          = 12, 
     1842+}; 
     1843+static struct clk usba0_hclk = { 
     1844+       .name           = "hclk", 
     1845+       .parent         = &hsb_clk, 
     1846+       .mode           = hsb_clk_mode, 
     1847+       .get_rate       = hsb_clk_get_rate, 
     1848+       .index          = 6, 
     1849+}; 
     1850+ 
     1851+struct platform_device *__init 
     1852+at32_add_device_usba(unsigned int id, struct usba_platform_data *data) 
     1853+{ 
     1854+       struct platform_device *pdev; 
     1855+ 
     1856+       if (id != 0) 
     1857+               return NULL; 
     1858+ 
     1859+       pdev = platform_device_alloc("atmel_usba_udc", 0); 
     1860+       if (!pdev) 
     1861+               return NULL; 
     1862+ 
     1863+       if (platform_device_add_resources(pdev, usba0_resource, 
     1864+                                         ARRAY_SIZE(usba0_resource))) 
     1865+               goto out_free_pdev; 
     1866+ 
     1867+       if (data) { 
     1868+               if (platform_device_add_data(pdev, data, sizeof(*data))) 
     1869+                       goto out_free_pdev; 
     1870+ 
     1871+               if (data->vbus_pin != GPIO_PIN_NONE) 
     1872+                       at32_select_gpio(data->vbus_pin, 0); 
     1873+       } 
     1874+ 
     1875+       usba0_pclk.dev = &pdev->dev; 
     1876+       usba0_hclk.dev = &pdev->dev; 
     1877+ 
     1878+       platform_device_add(pdev); 
     1879+ 
     1880+       return pdev; 
     1881+ 
     1882+out_free_pdev: 
     1883+       platform_device_put(pdev); 
     1884+       return NULL; 
     1885+} 
     1886+ 
     1887+/* -------------------------------------------------------------------- 
     1888+ *  SSC 
     1889+ * -------------------------------------------------------------------- */ 
     1890+static struct resource ssc0_resource[] = { 
     1891+       PBMEM(0xffe01c00), 
     1892+       IRQ(10), 
     1893+}; 
     1894+DEFINE_DEV(ssc, 0); 
     1895+DEV_CLK(pclk, ssc0, pba, 7); 
     1896+ 
     1897+static struct resource ssc1_resource[] = { 
     1898+       PBMEM(0xffe02000), 
     1899+       IRQ(11), 
     1900+}; 
     1901+DEFINE_DEV(ssc, 1); 
     1902+DEV_CLK(pclk, ssc1, pba, 8); 
     1903+ 
     1904+static struct resource ssc2_resource[] = { 
     1905+       PBMEM(0xffe02400), 
     1906+       IRQ(12), 
     1907+}; 
     1908+DEFINE_DEV(ssc, 2); 
     1909+DEV_CLK(pclk, ssc2, pba, 9); 
     1910+ 
     1911+struct platform_device *__init 
     1912+at32_add_device_ssc(unsigned int id, unsigned int flags) 
    37161913+{ 
    37171914+       struct platform_device *pdev; 
     
    37191916+       switch (id) { 
    37201917+       case 0: 
    3721 +               pdev = &usba0_device; 
    3722 +               /* USB pads are not multiplexed */ 
    3723                 break; 
     1918+               pdev = &ssc0_device; 
     1919+               if (flags & ATMEL_SSC_RF) 
     1920+                       select_peripheral(PA(21), PERIPH_A, 0); /* RF */ 
     1921+               if (flags & ATMEL_SSC_RK) 
     1922+                       select_peripheral(PA(22), PERIPH_A, 0); /* RK */ 
     1923+               if (flags & ATMEL_SSC_TK) 
     1924+                       select_peripheral(PA(23), PERIPH_A, 0); /* TK */ 
     1925+               if (flags & ATMEL_SSC_TF) 
     1926+                       select_peripheral(PA(24), PERIPH_A, 0); /* TF */ 
     1927+               if (flags & ATMEL_SSC_TD) 
     1928+                       select_peripheral(PA(25), PERIPH_A, 0); /* TD */ 
     1929+               if (flags & ATMEL_SSC_RD) 
     1930+                       select_peripheral(PA(26), PERIPH_A, 0); /* RD */ 
     1931+               break; 
     1932+       case 1: 
     1933+               pdev = &ssc1_device; 
     1934+               if (flags & ATMEL_SSC_RF) 
     1935+                       select_peripheral(PA(0), PERIPH_B, 0);  /* RF */ 
     1936+               if (flags & ATMEL_SSC_RK) 
     1937+                       select_peripheral(PA(1), PERIPH_B, 0);  /* RK */ 
     1938+               if (flags & ATMEL_SSC_TK) 
     1939+                       select_peripheral(PA(2), PERIPH_B, 0);  /* TK */ 
     1940+               if (flags & ATMEL_SSC_TF) 
     1941+                       select_peripheral(PA(3), PERIPH_B, 0);  /* TF */ 
     1942+               if (flags & ATMEL_SSC_TD) 
     1943+                       select_peripheral(PA(4), PERIPH_B, 0);  /* TD */ 
     1944+               if (flags & ATMEL_SSC_RD) 
     1945+                       select_peripheral(PA(5), PERIPH_B, 0);  /* RD */ 
     1946+               break; 
     1947+       case 2: 
     1948+               pdev = &ssc2_device; 
     1949+               if (flags & ATMEL_SSC_TD) 
     1950+                       select_peripheral(PB(13), PERIPH_A, 0); /* TD */ 
     1951+               if (flags & ATMEL_SSC_RD) 
     1952+                       select_peripheral(PB(14), PERIPH_A, 0); /* RD */ 
     1953+               if (flags & ATMEL_SSC_TK) 
     1954+                       select_peripheral(PB(15), PERIPH_A, 0); /* TK */ 
     1955+               if (flags & ATMEL_SSC_TF) 
     1956+                       select_peripheral(PB(16), PERIPH_A, 0); /* TF */ 
     1957+               if (flags & ATMEL_SSC_RF) 
     1958+                       select_peripheral(PB(17), PERIPH_A, 0); /* RF */ 
     1959+               if (flags & ATMEL_SSC_RK) 
     1960+                       select_peripheral(PB(18), PERIPH_A, 0); /* RK */ 
     1961+               break; 
    37241962+       default: 
    37251963+               return NULL; 
     
    37391977+DEFINE_DEV(atmel_ac97c, 0); 
    37401978+DEV_CLK(pclk, atmel_ac97c0, pbb, 10); 
    3741   
     1979+ 
    37421980+struct platform_device *__init 
    37431981+at32_add_device_ac97c(unsigned int id) 
     
    37531991+               select_peripheral(PB(23), PERIPH_B, 0); /* SCLK */ 
    37541992+               break; 
    3755         default: 
    3756                 return NULL; 
    3757         } 
    3758   
    3759 -       memcpy(pdev->dev.platform_data, data, 
    3760 -              sizeof(struct lcdc_platform_data)); 
     1993+       default: 
     1994+               return NULL; 
     1995+       } 
     1996+ 
    37611997+       platform_device_register(pdev); 
    37621998+       return pdev; 
     
    37982034+               return NULL; 
    37992035+       } 
    3800   
    3801         platform_device_register(pdev); 
    3802         return pdev; 
    3803 @@ -950,18 +1249,21 @@ 
     2036+ 
     2037+       platform_device_register(pdev); 
     2038+       return pdev; 
     2039+} 
     2040+ 
     2041+/* -------------------------------------------------------------------- 
     2042  *  GCLK 
     2043  * -------------------------------------------------------------------- */ 
     2044 static struct clk gclk0 = { 
     2045@@ -1066,7 +1449,7 @@ 
     2046        &hsb_clk, 
     2047        &pba_clk, 
    38042048        &pbb_clk, 
    3805         &at32_sm_pclk, 
     2049-       &at32_sm_pclk, 
     2050+       &at32_pm_pclk, 
    38062051        &at32_intc0_pclk, 
    3807 +       &hmatrix_clk, 
     2052        &hmatrix_clk, 
    38082053        &ebi_clk, 
    3809         &hramc_clk, 
    3810         &smc0_pclk, 
     2054@@ -1075,6 +1458,7 @@ 
    38112055        &smc0_mck, 
    38122056        &pdc_hclk, 
     
    38162060        &pio0_mck, 
    38172061        &pio1_mck, 
    3818         &pio2_mck, 
    3819         &pio3_mck, 
    3820         &pio4_mck, 
    3821 +       &at32_systc0_pclk, 
    3822         &atmel_usart0_usart, 
    3823         &atmel_usart1_usart, 
    3824         &atmel_usart2_usart, 
    3825 @@ -972,8 +1274,15 @@ 
     2062@@ -1092,8 +1476,18 @@ 
    38262063        &macb1_pclk, 
    38272064        &atmel_spi0_spi_clk, 
    38282065        &atmel_spi1_spi_clk, 
    3829 -       &lcdc0_hclk, 
    3830 -       &lcdc0_pixclk, 
    38312066+       &atmel_twi0_pclk, 
    38322067+       &atmel_mci0_mci_clk, 
    3833 +       &atmel_lcdfb0_hck1, 
    3834 +       &atmel_lcdfb0_pixclk, 
     2068        &atmel_lcdfb0_hck1, 
     2069        &atmel_lcdfb0_pixclk, 
    38352070+       &usba0_pclk, 
    38362071+       &usba0_hclk, 
     2072+       &ssc0_pclk, 
     2073+       &ssc1_pclk, 
     2074+       &ssc2_pclk, 
    38372075+       &atmel_ac97c0_pclk, 
    38382076+       &abdac0_pclk, 
     
    38412079        &gclk1, 
    38422080        &gclk2, 
    3843 @@ -1012,7 +1321,8 @@ 
    3844         genclk_init_parent(&gclk2); 
     2081@@ -1113,18 +1507,20 @@ 
     2082  
     2083 void __init at32_clock_init(void) 
     2084 { 
     2085-       struct at32_sm *sm = &system_manager; 
     2086        u32 cpu_mask = 0, hsb_mask = 0, pba_mask = 0, pbb_mask = 0; 
     2087        int i; 
     2088  
     2089-       if (sm_readl(sm, PM_MCCTRL) & SM_BIT(PLLSEL)) 
     2090+       if (pm_readl(MCCTRL) & PM_BIT(PLLSEL)) { 
     2091                main_clock = &pll0; 
     2092-       else 
     2093+               cpu_clk.parent = &pll0; 
     2094+       } else { 
     2095                main_clock = &osc0; 
     2096+               cpu_clk.parent = &osc0; 
     2097+       } 
     2098  
     2099-       if (sm_readl(sm, PM_PLL0) & SM_BIT(PLLOSC)) 
     2100+       if (pm_readl(PLL0) & PM_BIT(PLLOSC)) 
     2101                pll0.parent = &osc1; 
     2102-       if (sm_readl(sm, PM_PLL1) & SM_BIT(PLLOSC)) 
     2103+       if (pm_readl(PLL1) & PM_BIT(PLLOSC)) 
     2104                pll1.parent = &osc1; 
     2105  
     2106        genclk_init_parent(&gclk0); 
     2107@@ -1133,6 +1529,7 @@ 
    38452108        genclk_init_parent(&gclk3); 
    38462109        genclk_init_parent(&gclk4); 
    3847 -       genclk_init_parent(&lcdc0_pixclk); 
    3848 +       genclk_init_parent(&atmel_lcdfb0_pixclk); 
     2110        genclk_init_parent(&atmel_lcdfb0_pixclk); 
    38492111+       genclk_init_parent(&abdac0_sample_clk); 
    38502112  
    38512113        /* 
    38522114         * Turn on all clocks that have at least one user already, and 
    3853 @@ -1024,6 +1334,9 @@ 
    3854         for (i = 0; i < ARRAY_SIZE(at32_clock_list); i++) { 
    3855                 struct clk *clk = at32_clock_list[i]; 
    3856   
    3857 +               if (clk->users == 0) 
    3858 +                       continue; 
    3859 + 
    3860                 if (clk->mode == &cpu_clk_mode) 
    3861                         cpu_mask |= 1 << clk->index; 
    3862                 else if (clk->mode == &hsb_clk_mode) 
    3863 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 
    3864 --- linux-2.6.21.3/arch/avr32/mach-at32ap/clock.c       2007-05-24 23:22:47.000000000 +0200 
    3865 +++ avr32-git/arch/avr32/mach-at32ap/clock.c    2007-06-06 11:33:46.000000000 +0200 
    3866 @@ -18,7 +18,7 @@ 
    3867   
    3868  #include "clock.h" 
    3869   
    3870 -static spinlock_t clk_lock = SPIN_LOCK_UNLOCKED; 
    3871 +static DEFINE_SPINLOCK(clk_lock); 
    3872   
    3873  struct clk *clk_get(struct device *dev, const char *id) 
     2115@@ -1157,8 +1554,8 @@ 
     2116                        pbb_mask |= 1 << clk->index; 
     2117        } 
     2118  
     2119-       sm_writel(sm, PM_CPU_MASK, cpu_mask); 
     2120-       sm_writel(sm, PM_HSB_MASK, hsb_mask); 
     2121-       sm_writel(sm, PM_PBA_MASK, pba_mask); 
     2122-       sm_writel(sm, PM_PBB_MASK, pbb_mask); 
     2123+       pm_writel(CPU_MASK, cpu_mask); 
     2124+       pm_writel(HSB_MASK, hsb_mask); 
     2125+       pm_writel(PBA_MASK, pba_mask); 
     2126+       pm_writel(PBB_MASK, pbb_mask); 
     2127 } 
     2128diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap.c linux-avr32.git/arch/avr32/mach-at32ap/at32ap.c 
     2129--- linux-2.6.22.1/arch/avr32/mach-at32ap/at32ap.c      2007-07-10 20:56:30.000000000 +0200 
     2130+++ linux-avr32.git/arch/avr32/mach-at32ap/at32ap.c     2007-07-12 13:59:49.000000000 +0200 
     2131@@ -11,41 +11,10 @@ 
     2132 #include <linux/init.h> 
     2133 #include <linux/platform_device.h> 
     2134  
     2135-#include <asm/io.h> 
     2136- 
     2137 #include <asm/arch/init.h> 
     2138-#include <asm/arch/sm.h> 
     2139- 
     2140-struct at32_sm system_manager; 
     2141- 
     2142-static int __init at32_sm_init(void) 
     2143-{ 
     2144-       struct resource *regs; 
     2145-       struct at32_sm *sm = &system_manager; 
     2146-       int ret = -ENXIO; 
     2147- 
     2148-       regs = platform_get_resource(&at32_sm_device, IORESOURCE_MEM, 0); 
     2149-       if (!regs) 
     2150-               goto fail; 
     2151- 
     2152-       spin_lock_init(&sm->lock); 
     2153-       sm->pdev = &at32_sm_device; 
     2154- 
     2155-       ret = -ENOMEM; 
     2156-       sm->regs = ioremap(regs->start, regs->end - regs->start + 1); 
     2157-       if (!sm->regs) 
     2158-               goto fail; 
     2159- 
     2160-       return 0; 
     2161- 
     2162-fail: 
     2163-       printk(KERN_ERR "Failed to initialize System Manager: %d\n", ret); 
     2164-       return ret; 
     2165-} 
     2166  
     2167 void __init setup_platform(void) 
    38742168 { 
    3875 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 
    3876 --- linux-2.6.21.3/arch/avr32/mach-at32ap/hmatrix.h     1970-01-01 01:00:00.000000000 +0100 
    3877 +++ avr32-git/arch/avr32/mach-at32ap/hmatrix.h  2007-06-06 11:33:46.000000000 +0200 
    3878 @@ -0,0 +1,182 @@ 
    3879 +/* 
    3880 + * Register definitions for High-Speed Bus Matrix 
    3881 + */ 
    3882 +#ifndef __HMATRIX_H 
    3883 +#define __HMATRIX_H 
    3884 + 
    3885 +/* HMATRIX register offsets */ 
    3886 +#define HMATRIX_MCFG0                          0x0000 
    3887 +#define HMATRIX_MCFG1                          0x0004 
    3888 +#define HMATRIX_MCFG2                          0x0008 
    3889 +#define HMATRIX_MCFG3                          0x000c 
    3890 +#define HMATRIX_MCFG4                          0x0010 
    3891 +#define HMATRIX_MCFG5                          0x0014 
    3892 +#define HMATRIX_MCFG6                          0x0018 
    3893 +#define HMATRIX_MCFG7                          0x001c 
    3894 +#define HMATRIX_MCFG8                          0x0020 
    3895 +#define HMATRIX_MCFG9                          0x0024 
    3896 +#define HMATRIX_MCFG10                         0x0028 
    3897 +#define HMATRIX_MCFG11                         0x002c 
    3898 +#define HMATRIX_MCFG12                         0x0030 
    3899 +#define HMATRIX_MCFG13                         0x0034 
    3900 +#define HMATRIX_MCFG14                         0x0038 
    3901 +#define HMATRIX_MCFG15                         0x003c 
    3902 +#define HMATRIX_SCFG0                          0x0040 
    3903 +#define HMATRIX_SCFG1                          0x0044 
    3904 +#define HMATRIX_SCFG2                          0x0048 
    3905 +#define HMATRIX_SCFG3                          0x004c 
    3906 +#define HMATRIX_SCFG4                          0x0050 
    3907 +#define HMATRIX_SCFG5                          0x0054 
    3908 +#define HMATRIX_SCFG6                          0x0058 
    3909 +#define HMATRIX_SCFG7                          0x005c 
    3910 +#define HMATRIX_SCFG8                          0x0060 
    3911 +#define HMATRIX_SCFG9                          0x0064 
    3912 +#define HMATRIX_SCFG10                         0x0068 
    3913 +#define HMATRIX_SCFG11                         0x006c 
    3914 +#define HMATRIX_SCFG12                         0x0070 
    3915 +#define HMATRIX_SCFG13                         0x0074 
    3916 +#define HMATRIX_SCFG14                         0x0078 
    3917 +#define HMATRIX_SCFG15                         0x007c 
    3918 +#define HMATRIX_PRAS0                          0x0080 
    3919 +#define HMATRIX_PRBS0                          0x0084 
    3920 +#define HMATRIX_PRAS1                          0x0088 
    3921 +#define HMATRIX_PRBS1                          0x008c 
    3922 +#define HMATRIX_PRAS2                          0x0090 
    3923 +#define HMATRIX_PRBS2                          0x0094 
    3924 +#define HMATRIX_PRAS3                          0x0098 
    3925 +#define HMATRIX_PRBS3                          0x009c 
    3926 +#define HMATRIX_PRAS4                          0x00a0 
    3927 +#define HMATRIX_PRBS4                          0x00a4 
    3928 +#define HMATRIX_PRAS5                          0x00a8 
    3929 +#define HMATRIX_PRBS5                          0x00ac 
    3930 +#define HMATRIX_PRAS6                          0x00b0 
    3931 +#define HMATRIX_PRBS6                          0x00b4 
    3932 +#define HMATRIX_PRAS7                          0x00b8 
    3933 +#define HMATRIX_PRBS7                          0x00bc 
    3934 +#define HMATRIX_PRAS8                          0x00c0 
    3935 +#define HMATRIX_PRBS8                          0x00c4 
    3936 +#define HMATRIX_PRAS9                          0x00c8 
    3937 +#define HMATRIX_PRBS9                          0x00cc 
    3938 +#define HMATRIX_PRAS10                         0x00d0 
    3939 +#define HMATRIX_PRBS10                         0x00d4 
    3940 +#define HMATRIX_PRAS11                         0x00d8 
    3941 +#define HMATRIX_PRBS11                         0x00dc 
    3942 +#define HMATRIX_PRAS12                         0x00e0 
    3943 +#define HMATRIX_PRBS12                         0x00e4 
    3944 +#define HMATRIX_PRAS13                         0x00e8 
    3945 +#define HMATRIX_PRBS13                         0x00ec 
    3946 +#define HMATRIX_PRAS14                         0x00f0 
    3947 +#define HMATRIX_PRBS14                         0x00f4 
    3948 +#define HMATRIX_PRAS15                         0x00f8 
    3949 +#define HMATRIX_PRBS15                         0x00fc 
    3950 +#define HMATRIX_MRCR                           0x0100 
    3951 +#define HMATRIX_SFR0                           0x0110 
    3952 +#define HMATRIX_SFR1                           0x0114 
    3953 +#define HMATRIX_SFR2                           0x0118 
    3954 +#define HMATRIX_SFR3                           0x011c 
    3955 +#define HMATRIX_SFR4                           0x0120 
    3956 +#define HMATRIX_SFR5                           0x0124 
    3957 +#define HMATRIX_SFR6                           0x0128 
    3958 +#define HMATRIX_SFR7                           0x012c 
    3959 +#define HMATRIX_SFR8                           0x0130 
    3960 +#define HMATRIX_SFR9                           0x0134 
    3961 +#define HMATRIX_SFR10                          0x0138 
    3962 +#define HMATRIX_SFR11                          0x013c 
    3963 +#define HMATRIX_SFR12                          0x0140 
    3964 +#define HMATRIX_SFR13                          0x0144 
    3965 +#define HMATRIX_SFR14                          0x0148 
    3966 +#define HMATRIX_SFR15                          0x014c 
    3967 + 
    3968 +/* Bitfields in MCFGx */ 
    3969 +#define HMATRIX_ULBT_OFFSET                    0 
    3970 +#define HMATRIX_ULBT_SIZE                      3 
    3971 + 
    3972 +/* Bitfields in SCFGx */ 
    3973 +#define HMATRIX_SLOT_CYCLE_OFFSET              0 
    3974 +#define HMATRIX_SLOT_CYCLE_SIZE                        8 
    3975 +#define HMATRIX_DEFMSTR_TYPE_OFFSET            16 
    3976 +#define HMATRIX_DEFMSTR_TYPE_SIZE              2 
    3977 +#define HMATRIX_FIXED_DEFMSTR_OFFSET           18 
    3978 +#define HMATRIX_FIXED_DEFMSTR_SIZE             4 
    3979 +#define HMATRIX_ARBT_OFFSET                    24 
    3980 +#define HMATRIX_ARBT_SIZE                      2 
    3981 + 
    3982 +/* Bitfields in PRASx */ 
    3983 +#define HMATRIX_M0PR_OFFSET                    0 
    3984 +#define HMATRIX_M0PR_SIZE                      4 
    3985 +#define HMATRIX_M1PR_OFFSET                    4 
    3986 +#define HMATRIX_M1PR_SIZE                      4 
    3987 +#define HMATRIX_M2PR_OFFSET                    8 
    3988 +#define HMATRIX_M2PR_SIZE                      4 
    3989 +#define HMATRIX_M3PR_OFFSET                    12 
    3990 +#define HMATRIX_M3PR_SIZE                      4 
    3991 +#define HMATRIX_M4PR_OFFSET                    16 
    3992 +#define HMATRIX_M4PR_SIZE                      4 
    3993 +#define HMATRIX_M5PR_OFFSET                    20 
    3994 +#define HMATRIX_M5PR_SIZE                      4 
    3995 +#define HMATRIX_M6PR_OFFSET                    24 
    3996 +#define HMATRIX_M6PR_SIZE                      4 
    3997 +#define HMATRIX_M7PR_OFFSET                    28 
    3998 +#define HMATRIX_M7PR_SIZE                      4 
    3999 + 
    4000 +/* Bitfields in PRBSx */ 
    4001 +#define HMATRIX_M8PR_OFFSET                    0 
    4002 +#define HMATRIX_M8PR_SIZE                      4 
    4003 +#define HMATRIX_M9PR_OFFSET                    4 
    4004 +#define HMATRIX_M9PR_SIZE                      4 
    4005 +#define HMATRIX_M10PR_OFFSET                   8 
    4006 +#define HMATRIX_M10PR_SIZE                     4 
    4007 +#define HMATRIX_M11PR_OFFSET                   12 
    4008 +#define HMATRIX_M11PR_SIZE                     4 
    4009 +#define HMATRIX_M12PR_OFFSET                   16 
    4010 +#define HMATRIX_M12PR_SIZE                     4 
    4011 +#define HMATRIX_M13PR_OFFSET                   20 
    4012 +#define HMATRIX_M13PR_SIZE                     4 
    4013 +#define HMATRIX_M14PR_OFFSET                   24 
    4014 +#define HMATRIX_M14PR_SIZE                     4 
    4015 +#define HMATRIX_M15PR_OFFSET                   28 
    4016 +#define HMATRIX_M15PR_SIZE                     4 
    4017 + 
    4018 +/* Bitfields in SFR4 */ 
    4019 +#define HMATRIX_CS1A_OFFSET                    1 
    4020 +#define HMATRIX_CS1A_SIZE                      1 
    4021 +#define HMATRIX_CS3A_OFFSET                    3 
    4022 +#define HMATRIX_CS3A_SIZE                      1 
    4023 +#define HMATRIX_CS4A_OFFSET                    4 
    4024 +#define HMATRIX_CS4A_SIZE                      1 
    4025 +#define HMATRIX_CS5A_OFFSET                    5 
    4026 +#define HMATRIX_CS5A_SIZE                      1 
    4027 +#define HMATRIX_DBPUC_OFFSET                   8 
    4028 +#define HMATRIX_DBPUC_SIZE                     1 
    4029 + 
    4030 +/* Constants for ULBT */ 
    4031 +#define HMATRIX_ULBT_INFINITE                  0 
    4032 +#define HMATRIX_ULBT_SINGLE                    1 
    4033 +#define HMATRIX_ULBT_FOUR_BEAT                 2 
    4034 +#define HMATRIX_ULBT_EIGHT_BEAT                        3 
    4035 +#define HMATRIX_ULBT_SIXTEEN_BEAT              4 
    4036 + 
    4037 +/* Constants for DEFMSTR_TYPE */ 
    4038 +#define HMATRIX_DEFMSTR_TYPE_NO_DEFAULT                0 
    4039 +#define HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT      1 
    4040 +#define HMATRIX_DEFMSTR_TYPE_FIXED_DEFAULT     2 
    4041 + 
    4042 +/* Constants for ARBT */ 
    4043 +#define HMATRIX_ARBT_ROUND_ROBIN               0 
    4044 +#define HMATRIX_ARBT_FIXED_PRIORITY            1 
    4045 + 
    4046 +/* Bit manipulation macros */ 
    4047 +#define HMATRIX_BIT(name)                                      \ 
    4048 +       (1 << HMATRIX_##name##_OFFSET) 
    4049 +#define HMATRIX_BF(name,value)                                 \ 
    4050 +       (((value) & ((1 << HMATRIX_##name##_SIZE) - 1))         \ 
    4051 +        << HMATRIX_##name##_OFFSET) 
    4052 +#define HMATRIX_BFEXT(name,value)                              \ 
    4053 +       (((value) >> HMATRIX_##name##_OFFSET)                   \ 
    4054 +        & ((1 << HMATRIX_##name##_SIZE) - 1)) 
    4055 +#define HMATRIX_BFINS(name,value,old)                          \ 
    4056 +       (((old) & ~(((1 << HMATRIX_##name##_SIZE) - 1)          \ 
    4057 +                   << HMATRIX_##name##_OFFSET))                \ 
    4058 +        | HMATRIX_BF(name,value)) 
    4059 + 
    4060 +#endif /* __HMATRIX_H */ 
    4061 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 
    4062 --- linux-2.6.21.3/arch/avr32/mach-at32ap/hsmc.c        2007-05-24 23:22:47.000000000 +0200 
    4063 +++ avr32-git/arch/avr32/mach-at32ap/hsmc.c     2007-06-06 11:33:46.000000000 +0200 
    4064 @@ -75,12 +75,35 @@ 
    4065                 return -EINVAL; 
    4066         } 
    4067   
    4068 +       switch (config->nwait_mode) { 
    4069 +       case 0: 
    4070 +               mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_DISABLED); 
    4071 +               break; 
    4072 +       case 1: 
    4073 +               mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_RESERVED); 
    4074 +               break; 
    4075 +       case 2: 
    4076 +               mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_FROZEN); 
    4077 +               break; 
    4078 +       case 3: 
    4079 +               mode |= HSMC_BF(EXNW_MODE, HSMC_EXNW_MODE_READY); 
    4080 +               break; 
    4081 +       default: 
    4082 +               return -EINVAL; 
    4083 +       } 
    4084 + 
    4085 +       if (config->tdf_cycles) { 
    4086 +               mode |= HSMC_BF(TDF_CYCLES, config->tdf_cycles); 
    4087 +       } 
    4088 + 
    4089         if (config->nrd_controlled) 
    4090                 mode |= HSMC_BIT(READ_MODE); 
    4091         if (config->nwe_controlled) 
    4092                 mode |= HSMC_BIT(WRITE_MODE); 
    4093         if (config->byte_write) 
    4094                 mode |= HSMC_BIT(BAT); 
    4095 +       if (config->tdf_mode) 
    4096 +               mode |= HSMC_BIT(TDF_MODE); 
    4097   
    4098         pr_debug("smc cs%d: setup/%08x pulse/%08x cycle/%08x mode/%08x\n", 
    4099                  cs, setup, pulse, cycle, mode); 
    4100 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/Kconfig avr32-git/arch/avr32/mach-at32ap/Kconfig 
    4101 --- linux-2.6.21.3/arch/avr32/mach-at32ap/Kconfig       1970-01-01 01:00:00.000000000 +0100 
    4102 +++ avr32-git/arch/avr32/mach-at32ap/Kconfig    2007-06-06 11:33:46.000000000 +0200 
    4103 @@ -0,0 +1,31 @@ 
    4104 +if PLATFORM_AT32AP 
    4105 + 
    4106 +menu "Atmel AVR32 AP options" 
    4107 + 
    4108 +choice 
    4109 +       prompt "AT32AP7000 static memory bus width" 
    4110 +       depends on CPU_AT32AP7000 
    4111 +       default AP7000_16_BIT_SMC 
    4112 +       help 
    4113 +         Define the width of the AP7000 external static memory interface. 
    4114 +         This is used to determine how to mangle the address and/or data 
    4115 +         when doing little-endian port access. 
    4116 + 
    4117 +         The current code can only support a single external memory bus 
    4118 +         width for all chip selects, excluding the flash (which is using 
    4119 +         raw access and is thus not affected by any of this.) 
    4120 + 
    4121 +config AP7000_32_BIT_SMC 
    4122 +       bool "32 bit" 
    4123 + 
    4124 +config AP7000_16_BIT_SMC 
    4125 +       bool "16 bit" 
    4126 + 
    4127 +config AP7000_8_BIT_SMC 
    4128 +       bool "8 bit" 
    4129 + 
    4130 +endchoice 
    4131 + 
    4132 +endmenu 
    4133 + 
    4134 +endif # PLATFORM_AT32AP 
    4135 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/mach-at32ap/Makefile avr32-git/arch/avr32/mach-at32ap/Makefile 
    4136 --- linux-2.6.21.3/arch/avr32/mach-at32ap/Makefile      2007-05-24 23:22:47.000000000 +0200 
    4137 +++ avr32-git/arch/avr32/mach-at32ap/Makefile   2007-06-06 11:33:46.000000000 +0200 
    4138 @@ -1,2 +1,3 @@ 
    4139  obj-y                          += at32ap.o clock.o intc.o extint.o pio.o hsmc.o 
    4140  obj-$(CONFIG_CPU_AT32AP7000)   += at32ap7000.o 
    4141 +obj-$(CONFIG_CPU_AT32AP7000)   += time-tc.o 
    4142 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 
    4143 --- linux-2.6.21.3/arch/avr32/mach-at32ap/time-tc.c     1970-01-01 01:00:00.000000000 +0100 
    4144 +++ avr32-git/arch/avr32/mach-at32ap/time-tc.c  2007-06-06 11:33:46.000000000 +0200 
    4145 @@ -0,0 +1,218 @@ 
     2169-       at32_sm_init(); 
     2170        at32_clock_init(); 
     2171        at32_portmux_init(); 
     2172 } 
     2173diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/cpufreq.c linux-avr32.git/arch/avr32/mach-at32ap/cpufreq.c 
     2174--- linux-2.6.22.1/arch/avr32/mach-at32ap/cpufreq.c     1970-01-01 01:00:00.000000000 +0100 
     2175+++ linux-avr32.git/arch/avr32/mach-at32ap/cpufreq.c    2007-07-12 13:59:49.000000000 +0200 
     2176@@ -0,0 +1,112 @@ 
    41462177+/* 
    41472178+ * Copyright (C) 2004-2007 Atmel Corporation 
     
    41552186+ */ 
    41562187+ 
     2188+/*#define DEBUG*/ 
     2189+ 
     2190+#include <linux/kernel.h> 
     2191+#include <linux/types.h> 
     2192+#include <linux/init.h> 
     2193+#include <linux/cpufreq.h> 
     2194+#include <linux/io.h> 
    41572195+#include <linux/clk.h> 
    4158 +#include <linux/clocksource.h> 
    4159 +#include <linux/time.h> 
    4160 +#include <linux/module.h> 
     2196+#include <linux/err.h> 
     2197+#include <asm/system.h> 
     2198+ 
     2199+static struct clk *cpuclk; 
     2200+ 
     2201+static int at32_verify_speed(struct cpufreq_policy *policy) 
     2202+{ 
     2203+       if (policy->cpu != 0) 
     2204+               return -EINVAL; 
     2205+ 
     2206+       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, 
     2207+                       policy->cpuinfo.max_freq); 
     2208+       return 0; 
     2209+} 
     2210+ 
     2211+static unsigned int at32_get_speed(unsigned int cpu) 
     2212+{ 
     2213+       /* No SMP support */ 
     2214+       if (cpu) 
     2215+               return 0; 
     2216+       return (unsigned int)((clk_get_rate(cpuclk) + 500) / 1000); 
     2217+} 
     2218+ 
     2219+static int at32_set_target(struct cpufreq_policy *policy, 
     2220+                         unsigned int target_freq, 
     2221+                         unsigned int relation) 
     2222+{ 
     2223+       struct cpufreq_freqs freqs; 
     2224+       long freq; 
     2225+ 
     2226+       /* Convert target_freq from kHz to Hz */ 
     2227+       freq = clk_round_rate(cpuclk, target_freq * 1000); 
     2228+ 
     2229+       /* Check if policy->min <= new_freq <= policy->max */ 
     2230+       if(freq < (policy->min * 1000) || freq > (policy->max * 1000)) 
     2231+               return -EINVAL; 
     2232+ 
     2233+       pr_debug("cpufreq: requested frequency %u Hz\n", target_freq * 1000); 
     2234+ 
     2235+       freqs.old = at32_get_speed(0); 
     2236+       freqs.new = (freq + 500) / 1000; 
     2237+       freqs.cpu = 0; 
     2238+       freqs.flags = 0; 
     2239+ 
     2240+       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); 
     2241+       clk_set_rate(cpuclk, freq); 
     2242+       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); 
     2243+ 
     2244+       pr_debug("cpufreq: set frequency %lu Hz\n", freq); 
     2245+ 
     2246+       return 0; 
     2247+} 
     2248+ 
     2249+static int __init at32_cpufreq_driver_init(struct cpufreq_policy *policy) 
     2250+{ 
     2251+       if (policy->cpu != 0) 
     2252+               return -EINVAL; 
     2253+ 
     2254+       cpuclk = clk_get(NULL, "cpu"); 
     2255+       if (IS_ERR(cpuclk)) { 
     2256+               pr_debug("cpufreq: could not get CPU clk\n"); 
     2257+               return PTR_ERR(cpuclk); 
     2258+       } 
     2259+ 
     2260+       policy->cpuinfo.min_freq = (clk_round_rate(cpuclk, 1) + 500) / 1000; 
     2261+       policy->cpuinfo.max_freq = (clk_round_rate(cpuclk, ~0UL) + 500) / 1000; 
     2262+       policy->cpuinfo.transition_latency = 0; 
     2263+       policy->cur = at32_get_speed(0); 
     2264+       policy->min = policy->cpuinfo.min_freq; 
     2265+       policy->max = policy->cpuinfo.max_freq; 
     2266+       policy->governor = CPUFREQ_DEFAULT_GOVERNOR; 
     2267+ 
     2268+       printk("cpufreq: AT32AP CPU frequency driver\n"); 
     2269+ 
     2270+       return 0; 
     2271+} 
     2272+ 
     2273+static struct cpufreq_driver at32_driver = { 
     2274+       .name           = "at32ap", 
     2275+       .owner          = THIS_MODULE, 
     2276+       .init           = at32_cpufreq_driver_init, 
     2277+       .verify         = at32_verify_speed, 
     2278+       .target         = at32_set_target, 
     2279+       .get            = at32_get_speed, 
     2280+       .flags          = CPUFREQ_STICKY, 
     2281+}; 
     2282+ 
     2283+static int __init at32_cpufreq_init(void) 
     2284+{ 
     2285+       return cpufreq_register_driver(&at32_driver); 
     2286+} 
     2287+ 
     2288+arch_initcall(at32_cpufreq_init); 
     2289diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/extint.c linux-avr32.git/arch/avr32/mach-at32ap/extint.c 
     2290--- linux-2.6.22.1/arch/avr32/mach-at32ap/extint.c      2007-07-10 20:56:30.000000000 +0200 
     2291+++ linux-avr32.git/arch/avr32/mach-at32ap/extint.c     2007-07-12 13:59:49.000000000 +0200 
     2292@@ -17,42 +17,83 @@ 
     2293  
     2294 #include <asm/io.h> 
     2295  
     2296-#include <asm/arch/sm.h> 
     2297- 
     2298-#include "sm.h" 
     2299+/* EIC register offsets */ 
     2300+#define EIC_IER                                        0x0000 
     2301+#define EIC_IDR                                        0x0004 
     2302+#define EIC_IMR                                        0x0008 
     2303+#define EIC_ISR                                        0x000c 
     2304+#define EIC_ICR                                        0x0010 
     2305+#define EIC_MODE                               0x0014 
     2306+#define EIC_EDGE                               0x0018 
     2307+#define EIC_LEVEL                              0x001c 
     2308+#define EIC_TEST                               0x0020 
     2309+#define EIC_NMIC                               0x0024 
     2310+ 
     2311+/* Bitfields in TEST */ 
     2312+#define EIC_TESTEN_OFFSET                      31 
     2313+#define EIC_TESTEN_SIZE                                1 
     2314+ 
     2315+/* Bitfields in NMIC */ 
     2316+#define EIC_EN_OFFSET                          0 
     2317+#define EIC_EN_SIZE                            1 
     2318+ 
     2319+/* Bit manipulation macros */ 
     2320+#define EIC_BIT(name)                                  \ 
     2321+       (1 << EIC_##name##_OFFSET) 
     2322+#define EIC_BF(name,value)                             \ 
     2323+       (((value) & ((1 << EIC_##name##_SIZE) - 1))     \ 
     2324+        << EIC_##name##_OFFSET) 
     2325+#define EIC_BFEXT(name,value)                          \ 
     2326+       (((value) >> EIC_##name##_OFFSET)               \ 
     2327+        & ((1 << EIC_##name##_SIZE) - 1)) 
     2328+#define EIC_BFINS(name,value,old)                      \ 
     2329+       (((old) & ~(((1 << EIC_##name##_SIZE) - 1)      \ 
     2330+                   << EIC_##name##_OFFSET))            \ 
     2331+        | EIC_BF(name,value)) 
     2332+ 
     2333+/* Register access macros */ 
     2334+#define eic_readl(port,reg)                            \ 
     2335+       __raw_readl((port)->regs + EIC_##reg) 
     2336+#define eic_writel(port,reg,value)                     \ 
     2337+       __raw_writel((value), (port)->regs + EIC_##reg) 
     2338+ 
     2339+struct eic { 
     2340+       void __iomem *regs; 
     2341+       struct irq_chip *chip; 
     2342+       unsigned int first_irq; 
     2343+}; 
     2344  
     2345-static void eim_ack_irq(unsigned int irq) 
     2346+static void eic_ack_irq(unsigned int irq) 
     2347 { 
     2348-       struct at32_sm *sm = get_irq_chip_data(irq); 
     2349-       sm_writel(sm, EIM_ICR, 1 << (irq - sm->eim_first_irq)); 
     2350+       struct eic *eic = get_irq_chip_data(irq); 
     2351+       eic_writel(eic, ICR, 1 << (irq - eic->first_irq)); 
     2352 } 
     2353  
     2354-static void eim_mask_irq(unsigned int irq) 
     2355+static void eic_mask_irq(unsigned int irq) 
     2356 { 
     2357-       struct at32_sm *sm = get_irq_chip_data(irq); 
     2358-       sm_writel(sm, EIM_IDR, 1 << (irq - sm->eim_first_irq)); 
     2359+       struct eic *eic = get_irq_chip_data(irq); 
     2360+       eic_writel(eic, IDR, 1 << (irq - eic->first_irq)); 
     2361 } 
     2362  
     2363-static void eim_mask_ack_irq(unsigned int irq) 
     2364+static void eic_mask_ack_irq(unsigned int irq) 
     2365 { 
     2366-       struct at32_sm *sm = get_irq_chip_data(irq); 
     2367-       sm_writel(sm, EIM_ICR, 1 << (irq - sm->eim_first_irq)); 
     2368-       sm_writel(sm, EIM_IDR, 1 << (irq - sm->eim_first_irq)); 
     2369+       struct eic *eic = get_irq_chip_data(irq); 
     2370+       eic_writel(eic, ICR, 1 << (irq - eic->first_irq)); 
     2371+       eic_writel(eic, IDR, 1 << (irq - eic->first_irq)); 
     2372 } 
     2373  
     2374-static void eim_unmask_irq(unsigned int irq) 
     2375+static void eic_unmask_irq(unsigned int irq) 
     2376 { 
     2377-       struct at32_sm *sm = get_irq_chip_data(irq); 
     2378-       sm_writel(sm, EIM_IER, 1 << (irq - sm->eim_first_irq)); 
     2379+       struct eic *eic = get_irq_chip_data(irq); 
     2380+       eic_writel(eic, IER, 1 << (irq - eic->first_irq)); 
     2381 } 
     2382  
     2383-static int eim_set_irq_type(unsigned int irq, unsigned int flow_type) 
     2384+static int eic_set_irq_type(unsigned int irq, unsigned int flow_type) 
     2385 { 
     2386-       struct at32_sm *sm = get_irq_chip_data(irq); 
     2387+       struct eic *eic = get_irq_chip_data(irq); 
     2388        struct irq_desc *desc; 
     2389-       unsigned int i = irq - sm->eim_first_irq; 
     2390+       unsigned int i = irq - eic->first_irq; 
     2391        u32 mode, edge, level; 
     2392-       unsigned long flags; 
     2393        int ret = 0; 
     2394  
     2395        flow_type &= IRQ_TYPE_SENSE_MASK; 
     2396@@ -60,11 +101,10 @@ 
     2397                flow_type = IRQ_TYPE_LEVEL_LOW; 
     2398  
     2399        desc = &irq_desc[irq]; 
     2400-       spin_lock_irqsave(&sm->lock, flags); 
     2401  
     2402-       mode = sm_readl(sm, EIM_MODE); 
     2403-       edge = sm_readl(sm, EIM_EDGE); 
     2404-       level = sm_readl(sm, EIM_LEVEL); 
     2405+       mode = eic_readl(eic, MODE); 
     2406+       edge = eic_readl(eic, EDGE); 
     2407+       level = eic_readl(eic, LEVEL); 
     2408  
     2409        switch (flow_type) { 
     2410        case IRQ_TYPE_LEVEL_LOW: 
     2411@@ -89,9 +129,9 @@ 
     2412        } 
     2413  
     2414        if (ret == 0) { 
     2415-               sm_writel(sm, EIM_MODE, mode); 
     2416-               sm_writel(sm, EIM_EDGE, edge); 
     2417-               sm_writel(sm, EIM_LEVEL, level); 
     2418+               eic_writel(eic, MODE, mode); 
     2419+               eic_writel(eic, EDGE, edge); 
     2420+               eic_writel(eic, LEVEL, level); 
     2421  
     2422                if (flow_type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH)) 
     2423                        flow_type |= IRQ_LEVEL; 
     2424@@ -99,35 +139,33 @@ 
     2425                desc->status |= flow_type; 
     2426        } 
     2427  
     2428-       spin_unlock_irqrestore(&sm->lock, flags); 
     2429- 
     2430        return ret; 
     2431 } 
     2432  
     2433-struct irq_chip eim_chip = { 
     2434-       .name           = "eim", 
     2435-       .ack            = eim_ack_irq, 
     2436-       .mask           = eim_mask_irq, 
     2437-       .mask_ack       = eim_mask_ack_irq, 
     2438-       .unmask         = eim_unmask_irq, 
     2439-       .set_type       = eim_set_irq_type, 
     2440+struct irq_chip eic_chip = { 
     2441+       .name           = "eic", 
     2442+       .ack            = eic_ack_irq, 
     2443+       .mask           = eic_mask_irq, 
     2444+       .mask_ack       = eic_mask_ack_irq, 
     2445+       .unmask         = eic_unmask_irq, 
     2446+       .set_type       = eic_set_irq_type, 
     2447 }; 
     2448  
     2449-static void demux_eim_irq(unsigned int irq, struct irq_desc *desc) 
     2450+static void demux_eic_irq(unsigned int irq, struct irq_desc *desc) 
     2451 { 
     2452-       struct at32_sm *sm = desc->handler_data; 
     2453+       struct eic *eic = desc->handler_data; 
     2454        struct irq_desc *ext_desc; 
     2455        unsigned long status, pending; 
     2456        unsigned int i, ext_irq; 
     2457  
     2458-       status = sm_readl(sm, EIM_ISR); 
     2459-       pending = status & sm_readl(sm, EIM_IMR); 
     2460+       status = eic_readl(eic, ISR); 
     2461+       pending = status & eic_readl(eic, IMR); 
     2462  
     2463        while (pending) { 
     2464                i = fls(pending) - 1; 
     2465                pending &= ~(1 << i); 
     2466  
     2467-               ext_irq = i + sm->eim_first_irq; 
     2468+               ext_irq = i + eic->first_irq; 
     2469                ext_desc = irq_desc + ext_irq; 
     2470                if (ext_desc->status & IRQ_LEVEL) 
     2471                        handle_level_irq(ext_irq, ext_desc); 
     2472@@ -136,51 +174,85 @@ 
     2473        } 
     2474 } 
     2475  
     2476-static int __init eim_init(void) 
     2477+static int __init eic_probe(struct platform_device *pdev) 
     2478 { 
     2479-       struct at32_sm *sm = &system_manager; 
     2480+       struct eic *eic; 
     2481+       struct resource *regs; 
     2482        unsigned int i; 
     2483        unsigned int nr_irqs; 
     2484        unsigned int int_irq; 
     2485+       int ret; 
     2486        u32 pattern; 
     2487  
     2488-       /* 
     2489-        * The EIM is really the same module as SM, so register 
     2490-        * mapping, etc. has been taken care of already. 
     2491-        */ 
     2492+       regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     2493+       int_irq = platform_get_irq(pdev, 0); 
     2494+       if (!regs || !int_irq) { 
     2495+               dev_dbg(&pdev->dev, "missing regs and/or irq resource\n"); 
     2496+               return -ENXIO; 
     2497+       } 
     2498+ 
     2499+       ret = -ENOMEM; 
     2500+       eic = kzalloc(sizeof(struct eic), GFP_KERNEL); 
     2501+       if (!eic) { 
     2502+               dev_dbg(&pdev->dev, "no memory for eic structure\n"); 
     2503+               goto err_kzalloc; 
     2504+       } 
     2505+ 
     2506+       eic->first_irq = EIM_IRQ_BASE + 32 * pdev->id; 
     2507+       eic->regs = ioremap(regs->start, regs->end - regs->start + 1); 
     2508+       if (!eic->regs) { 
     2509+               dev_dbg(&pdev->dev, "failed to map regs\n"); 
     2510+               goto err_ioremap; 
     2511+       } 
     2512  
     2513        /* 
     2514         * Find out how many interrupt lines that are actually 
     2515         * implemented in hardware. 
     2516         */ 
     2517-       sm_writel(sm, EIM_IDR, ~0UL); 
     2518-       sm_writel(sm, EIM_MODE, ~0UL); 
     2519-       pattern = sm_readl(sm, EIM_MODE); 
     2520+       eic_writel(eic, IDR, ~0UL); 
     2521+       eic_writel(eic, MODE, ~0UL); 
     2522+       pattern = eic_readl(eic, MODE); 
     2523        nr_irqs = fls(pattern); 
     2524  
     2525        /* Trigger on falling edge unless overridden by driver */ 
     2526-       sm_writel(sm, EIM_MODE, 0UL); 
     2527-       sm_writel(sm, EIM_EDGE, 0UL); 
     2528+       eic_writel(eic, MODE, 0UL); 
     2529+       eic_writel(eic, EDGE, 0UL); 
     2530  
     2531-       sm->eim_chip = &eim_chip; 
     2532+       eic->chip = &eic_chip; 
     2533  
     2534        for (i = 0; i < nr_irqs; i++) { 
     2535                /* NOTE the handler we set here is ignored by the demux */ 
     2536-               set_irq_chip_and_handler(sm->eim_first_irq + i, &eim_chip, 
     2537+               set_irq_chip_and_handler(eic->first_irq + i, &eic_chip, 
     2538                                         handle_level_irq); 
     2539-               set_irq_chip_data(sm->eim_first_irq + i, sm); 
     2540+               set_irq_chip_data(eic->first_irq + i, eic); 
     2541        } 
     2542  
     2543-       int_irq = platform_get_irq_byname(sm->pdev, "eim"); 
     2544- 
     2545-       set_irq_chained_handler(int_irq, demux_eim_irq); 
     2546-       set_irq_data(int_irq, sm); 
     2547+       set_irq_chained_handler(int_irq, demux_eic_irq); 
     2548+       set_irq_data(int_irq, eic); 
     2549  
     2550-       printk("EIM: External Interrupt Module at 0x%p, IRQ %u\n", 
     2551-              sm->regs, int_irq); 
     2552-       printk("EIM: Handling %u external IRQs, starting with IRQ %u\n", 
     2553-              nr_irqs, sm->eim_first_irq); 
     2554+       dev_info(&pdev->dev, 
     2555+                "External Interrupt Controller at 0x%p, IRQ %u\n", 
     2556+                eic->regs, int_irq); 
     2557+       dev_info(&pdev->dev, 
     2558+                "Handling %u external IRQs, starting with IRQ %u\n", 
     2559+                nr_irqs, eic->first_irq); 
     2560  
     2561        return 0; 
     2562+ 
     2563+err_ioremap: 
     2564+       kfree(eic); 
     2565+err_kzalloc: 
     2566+       return ret; 
     2567+} 
     2568+ 
     2569+static struct platform_driver eic_driver = { 
     2570+       .driver = { 
     2571+               .name = "at32_eic", 
     2572+       }, 
     2573+}; 
     2574+ 
     2575+static int __init eic_init(void) 
     2576+{ 
     2577+       return platform_driver_probe(&eic_driver, eic_probe); 
     2578 } 
     2579-arch_initcall(eim_init); 
     2580+arch_initcall(eic_init); 
     2581diff -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 
     2582--- linux-2.6.22.1/arch/avr32/mach-at32ap/gpio-dev.c    1970-01-01 01:00:00.000000000 +0100 
     2583+++ linux-avr32.git/arch/avr32/mach-at32ap/gpio-dev.c   2007-07-12 13:59:49.000000000 +0200 
     2584@@ -0,0 +1,570 @@ 
     2585+/* 
     2586+ * GPIO /dev and configfs interface 
     2587+ * 
     2588+ * Copyright (C) 2006-2007 Atmel Corporation 
     2589+ * 
     2590+ * This program is free software; you can redistribute it and/or modify 
     2591+ * it under the terms of the GNU General Public License version 2 as 
     2592+ * published by the Free Software Foundation. 
     2593+ */ 
     2594+#include <linux/configfs.h> 
     2595+#include <linux/cdev.h> 
     2596+#include <linux/fs.h> 
    41612597+#include <linux/interrupt.h> 
    4162 +#include <linux/irq.h> 
    4163 +#include <linux/kernel_stat.h> 
    4164 +#include <linux/errno.h> 
    4165 +#include <linux/init.h> 
    4166 +#include <linux/profile.h> 
    4167 +#include <linux/sysdev.h> 
    4168 +#include <linux/err.h> 
    4169 + 
    4170 +#include <asm/div64.h> 
    4171 +#include <asm/sysreg.h> 
    4172 +#include <asm/io.h> 
    4173 +#include <asm/sections.h> 
    4174 + 
    4175 +#include <asm/arch/time.h> 
    4176 + 
    4177 +/* how many counter cycles in a jiffy? */ 
    4178 +static u32 cycles_per_jiffy; 
    4179 + 
    4180 +/* the count value for the next timer interrupt */ 
    4181 +static u32 expirelo; 
    4182 + 
    4183 +/* the I/O registers of the TC module */ 
    4184 +static void __iomem *ioregs; 
    4185 + 
    4186 +cycle_t read_cycle_count(void) 
    4187 +{ 
    4188 +       return (cycle_t)timer_read(ioregs, 0, CV); 
    4189 +} 
    4190 + 
    4191 +struct clocksource clocksource_avr32 = { 
    4192 +       .name           = "avr32", 
    4193 +       .rating         = 342, 
    4194 +       .read           = read_cycle_count, 
    4195 +       .mask           = CLOCKSOURCE_MASK(16), 
    4196 +       .shift          = 16, 
    4197 +       .flags          = CLOCK_SOURCE_IS_CONTINUOUS, 
     2598+#include <linux/poll.h> 
     2599+#include <linux/uaccess.h> 
     2600+#include <linux/wait.h> 
     2601+ 
     2602+#include <asm/gpio.h> 
     2603+#include <asm/arch/portmux.h> 
     2604+ 
     2605+#define GPIO_DEV_MAX                   8 
     2606+ 
     2607+static struct class *gpio_dev_class; 
     2608+static dev_t gpio_devt; 
     2609+ 
     2610+struct gpio_item { 
     2611+       spinlock_t lock; 
     2612+ 
     2613+       int enabled; 
     2614+       int initialized; 
     2615+       int port; 
     2616+       u32 pin_mask; 
     2617+       u32 oe_mask; 
     2618+ 
     2619+       /* Pin state last time we read it (for blocking reads) */ 
     2620+       u32 pin_state; 
     2621+       int changed; 
     2622+ 
     2623+       wait_queue_head_t change_wq; 
     2624+       struct fasync_struct *async_queue; 
     2625+ 
     2626+       int id; 
     2627+       struct class_device *gpio_dev; 
     2628+       struct cdev char_dev; 
     2629+       struct config_item item; 
    41982630+}; 
    41992631+ 
    4200 +static void avr32_timer_ack(void) 
    4201 +{ 
    4202 +       u16 count = expirelo; 
    4203 + 
    4204 +       /* Ack this timer interrupt and set the next one, use a u16 
    4205 +        * variable so it will wrap around correctly */ 
    4206 +       count += cycles_per_jiffy; 
    4207 +       expirelo = count; 
    4208 +       timer_write(ioregs, 0, RC, expirelo); 
    4209 + 
    4210 +       /* Check to see if we have missed any timer interrupts */ 
    4211 +       count = timer_read(ioregs, 0, CV); 
    4212 +       if ((count - expirelo) < 0x7fff) { 
    4213 +               expirelo = count + cycles_per_jiffy; 
    4214 +               timer_write(ioregs, 0, RC, expirelo); 
    4215 +       } 
    4216 +} 
    4217 + 
    4218 +u32 avr32_hpt_read(void) 
    4219 +{ 
    4220 +       return timer_read(ioregs, 0, CV); 
    4221 +} 
    4222 + 
    4223 +static int avr32_timer_calc_div_and_set_jiffies(struct clk *pclk) 
    4224 +{ 
    4225 +       unsigned int cycles_max = (clocksource_avr32.mask + 1) / 2; 
    4226 +       unsigned int divs[] = { 4, 8, 16, 32 }; 
    4227 +       int divs_size = sizeof(divs) / sizeof(*divs); 
    4228 +       int i = 0; 
    4229 +       unsigned long count_hz; 
    4230 +       unsigned long shift; 
    4231 +       unsigned long mult; 
    4232 +       int clock_div = -1; 
    4233 +       u64 tmp; 
    4234 + 
    4235 +       shift = clocksource_avr32.shift; 
    4236 + 
     2632+struct gpio_attribute { 
     2633+       struct configfs_attribute attr; 
     2634+       ssize_t (*show)(struct gpio_item *, char *); 
     2635+       ssize_t (*store)(struct gpio_item *, const char *, size_t); 
     2636+}; 
     2637+ 
     2638+static irqreturn_t gpio_dev_interrupt(int irq, void *dev_id) 
     2639+{ 
     2640+       struct gpio_item *gpio = dev_id; 
     2641+       u32 old_state, new_state; 
     2642+ 
     2643+       old_state = gpio->pin_state; 
     2644+       new_state = at32_gpio_get_value_multiple(gpio->port, gpio->pin_mask); 
     2645+       gpio->pin_state = new_state; 
     2646+ 
     2647+       if (new_state != old_state) { 
     2648+               gpio->changed = 1; 
     2649+               wake_up_interruptible(&gpio->change_wq); 
     2650+ 
     2651+               if (gpio->async_queue) 
     2652+                       kill_fasync(&gpio->async_queue, SIGIO, POLL_IN); 
     2653+       } 
     2654+ 
     2655+       return IRQ_HANDLED; 
     2656+} 
     2657+ 
     2658+static int gpio_dev_open(struct inode *inode, struct file *file) 
     2659+{ 
     2660+       struct gpio_item *gpio = container_of(inode->i_cdev, 
     2661+                                             struct gpio_item, 
     2662+                                             char_dev); 
     2663+       unsigned int irq; 
     2664+       unsigned int i; 
     2665+       int ret; 
     2666+ 
     2667+       nonseekable_open(inode, file); 
     2668+       config_item_get(&gpio->item); 
     2669+       file->private_data = gpio; 
     2670+ 
     2671+       gpio->pin_state = at32_gpio_get_value_multiple(gpio->port, 
     2672+                                                      gpio->pin_mask); 
     2673+       gpio->changed = 1; 
     2674+ 
     2675+       for (i = 0; i < 32; i++) { 
     2676+               if (gpio->pin_mask & (1 << i)) { 
     2677+                       irq = gpio_to_irq(32 * gpio->port + i); 
     2678+                       ret = request_irq(irq, gpio_dev_interrupt, 0, 
     2679+                                         "gpio-dev", gpio); 
     2680+                       if (ret) 
     2681+                               goto err_irq; 
     2682+               } 
     2683+       } 
     2684+ 
     2685+       return 0; 
     2686+ 
     2687+err_irq: 
     2688+       while (i--) { 
     2689+               if (gpio->pin_mask & (1 << i)) { 
     2690+                       irq = gpio_to_irq(32 * gpio->port + i); 
     2691+                       free_irq(irq, gpio); 
     2692+               } 
     2693+       } 
     2694+ 
     2695+       config_item_put(&gpio->item); 
     2696+ 
     2697+       return ret; 
     2698+} 
     2699+ 
     2700+static int gpio_dev_fasync(int fd, struct file *file, int mode) 
     2701+{ 
     2702+       struct gpio_item *gpio = file->private_data; 
     2703+ 
     2704+       return fasync_helper(fd, file, mode, &gpio->async_queue); 
     2705+} 
     2706+ 
     2707+static int gpio_dev_release(struct inode *inode, struct file *file) 
     2708+{ 
     2709+       struct gpio_item *gpio = file->private_data; 
     2710+       unsigned int irq; 
     2711+       unsigned int i; 
     2712+ 
     2713+       gpio_dev_fasync(-1, file, 0); 
     2714+ 
     2715+       for (i = 0; i < 32; i++) { 
     2716+               if (gpio->pin_mask & (1 << i)) { 
     2717+                       irq = gpio_to_irq(32 * gpio->port + i); 
     2718+                       free_irq(irq, gpio); 
     2719+               } 
     2720+       } 
     2721+ 
     2722+       config_item_put(&gpio->item); 
     2723+ 
     2724+       return 0; 
     2725+} 
     2726+ 
     2727+static unsigned int gpio_dev_poll(struct file *file, poll_table *wait) 
     2728+{ 
     2729+       struct gpio_item *gpio = file->private_data; 
     2730+       unsigned int mask = 0; 
     2731+ 
     2732+       poll_wait(file, &gpio->change_wq, wait); 
     2733+       if (gpio->changed) 
     2734+               mask |= POLLIN | POLLRDNORM; 
     2735+ 
     2736+       return mask; 
     2737+} 
     2738+ 
     2739+static ssize_t gpio_dev_read(struct file *file, char __user *buf, 
     2740+                            size_t count, loff_t *offset) 
     2741+{ 
     2742+       struct gpio_item *gpio = file->private_data; 
     2743+       u32 value; 
     2744+ 
     2745+       spin_lock_irq(&gpio->lock); 
     2746+       while (!gpio->changed) { 
     2747+               spin_unlock_irq(&gpio->lock); 
     2748+ 
     2749+               if (file->f_flags & O_NONBLOCK) 
     2750+                       return -EAGAIN; 
     2751+ 
     2752+               if (wait_event_interruptible(gpio->change_wq, gpio->changed)) 
     2753+                       return -ERESTARTSYS; 
     2754+ 
     2755+               spin_lock_irq(&gpio->lock); 
     2756+       } 
     2757+ 
     2758+       gpio->changed = 0; 
     2759+       value = at32_gpio_get_value_multiple(gpio->port, gpio->pin_mask); 
     2760+ 
     2761+       spin_unlock_irq(&gpio->lock); 
     2762+ 
     2763+       count = min(count, (size_t)4); 
     2764+       if (copy_to_user(buf, &value, count)) 
     2765+               return -EFAULT; 
     2766+ 
     2767+       return count; 
     2768+} 
     2769+ 
     2770+static ssize_t gpio_dev_write(struct file *file, const char __user *buf, 
     2771+                             size_t count, loff_t *offset) 
     2772+{ 
     2773+       struct gpio_item *gpio = file->private_data; 
     2774+       u32 value = 0; 
     2775+       u32 mask = ~0UL; 
     2776+ 
     2777+       count = min(count, (size_t)4); 
     2778+       if (copy_from_user(&value, buf, count)) 
     2779+               return -EFAULT; 
     2780+ 
     2781+       /* Assuming big endian */ 
     2782+       mask <<= (4 - count) * 8; 
     2783+       mask &= gpio->pin_mask; 
     2784+ 
     2785+       at32_gpio_set_value_multiple(gpio->port, value, mask); 
     2786+ 
     2787+       return count; 
     2788+} 
     2789+ 
     2790+static struct file_operations gpio_dev_fops = { 
     2791+       .owner          = THIS_MODULE, 
     2792+       .llseek         = no_llseek, 
     2793+       .open           = gpio_dev_open, 
     2794+       .release        = gpio_dev_release, 
     2795+       .fasync         = gpio_dev_fasync, 
     2796+       .poll           = gpio_dev_poll, 
     2797+       .read           = gpio_dev_read, 
     2798+       .write          = gpio_dev_write, 
     2799+}; 
     2800+ 
     2801+static struct gpio_item *to_gpio_item(struct config_item *item) 
     2802+{ 
     2803+       return item ? container_of(item, struct gpio_item, item) : NULL; 
     2804+} 
     2805+ 
     2806+static ssize_t gpio_show_gpio_id(struct gpio_item *gpio, char *page) 
     2807+{ 
     2808+       return sprintf(page, "%d\n", gpio->port); 
     2809+} 
     2810+ 
     2811+static ssize_t gpio_store_gpio_id(struct gpio_item *gpio, 
     2812+                                 const char *page, size_t count) 
     2813+{ 
     2814+       unsigned long id; 
     2815+       char *p = (char *)page; 
     2816+       ssize_t ret = -EINVAL; 
     2817+ 
     2818+       id = simple_strtoul(p, &p, 0); 
     2819+       if (!p || (*p && (*p != '\n'))) 
     2820+               return -EINVAL; 
     2821+ 
     2822+       /* Switching PIO is not allowed when live... */ 
     2823+       spin_lock(&gpio->lock); 
     2824+       if (!gpio->enabled) { 
     2825+               ret = -ENXIO; 
     2826+               if (at32_gpio_port_is_valid(id)) { 
     2827+                       gpio->port = id; 
     2828+                       ret = count; 
     2829+               } 
     2830+       } 
     2831+       spin_unlock(&gpio->lock); 
     2832+ 
     2833+       return ret; 
     2834+} 
     2835+ 
     2836+static ssize_t gpio_show_pin_mask(struct gpio_item *gpio, char *page) 
     2837+{ 
     2838+       return sprintf(page, "0x%08x\n", gpio->pin_mask); 
     2839+} 
     2840+ 
     2841+static ssize_t gpio_store_pin_mask(struct gpio_item *gpio, 
     2842+                                  const char *page, size_t count) 
     2843+{ 
     2844+       u32 new_mask; 
     2845+       char *p = (char *)page; 
     2846+       ssize_t ret = -EINVAL; 
     2847+ 
     2848+       new_mask = simple_strtoul(p, &p, 0); 
     2849+       if (!p || (*p && (*p != '\n'))) 
     2850+               return -EINVAL; 
     2851+ 
     2852+       /* Can't update the pin mask while live. */ 
     2853+       spin_lock(&gpio->lock); 
     2854+       if (!gpio->enabled) { 
     2855+               gpio->oe_mask &= new_mask; 
     2856+               gpio->pin_mask = new_mask; 
     2857+               ret = count; 
     2858+       } 
     2859+       spin_unlock(&gpio->lock); 
     2860+ 
     2861+       return ret; 
     2862+} 
     2863+ 
     2864+static ssize_t gpio_show_oe_mask(struct gpio_item *gpio, char *page) 
     2865+{ 
     2866+       return sprintf(page, "0x%08x\n", gpio->oe_mask); 
     2867+} 
     2868+ 
     2869+static ssize_t gpio_store_oe_mask(struct gpio_item *gpio, 
     2870+                                 const char *page, size_t count) 
     2871+{ 
     2872+       u32 mask; 
     2873+       char *p = (char *)page; 
     2874+       ssize_t ret = -EINVAL; 
     2875+ 
     2876+       mask = simple_strtoul(p, &p, 0); 
     2877+       if (!p || (*p && (*p != '\n'))) 
     2878+               return -EINVAL; 
     2879+ 
     2880+       spin_lock(&gpio->lock); 
     2881+       if (!gpio->enabled) { 
     2882+               gpio->oe_mask = mask & gpio->pin_mask; 
     2883+               ret = count; 
     2884+       } 
     2885+       spin_unlock(&gpio->lock); 
     2886+ 
     2887+       return ret; 
     2888+} 
     2889+ 
     2890+static ssize_t gpio_show_enabled(struct gpio_item *gpio, char *page) 
     2891+{ 
     2892+       return sprintf(page, "%d\n", gpio->enabled); 
     2893+} 
     2894+ 
     2895+static ssize_t gpio_store_enabled(struct gpio_item *gpio, 
     2896+                                 const char *page, size_t count) 
     2897+{ 
     2898+       char *p = (char *)page; 
     2899+       int enabled; 
     2900+       int ret; 
     2901+ 
     2902+       enabled = simple_strtoul(p, &p, 0); 
     2903+       if (!p || (*p && (*p != '\n'))) 
     2904+               return -EINVAL; 
     2905+ 
     2906+       /* make it a boolean value */ 
     2907+       enabled = !!enabled; 
     2908+ 
     2909+       if (gpio->enabled == enabled) 
     2910+               /* No change; do nothing. */ 
     2911+               return count; 
     2912+ 
     2913+       BUG_ON(gpio->id >= GPIO_DEV_MAX); 
     2914+ 
     2915+       if (!enabled) { 
     2916+               class_device_unregister(gpio->gpio_dev); 
     2917+               cdev_del(&gpio->char_dev); 
     2918+               at32_deselect_pins(gpio->port, gpio->pin_mask); 
     2919+               gpio->initialized = 0; 
     2920+       } else { 
     2921+               if (gpio->port < 0 || !gpio->pin_mask) 
     2922+                       return -ENODEV; 
     2923+       } 
     2924+ 
     2925+       /* Disallow any updates to gpio_id or pin_mask */ 
     2926+       spin_lock(&gpio->lock); 
     2927+       gpio->enabled = enabled; 
     2928+       spin_unlock(&gpio->lock); 
     2929+ 
     2930+       if (!enabled) 
     2931+               return count; 
     2932+ 
     2933+       /* Now, try to allocate the pins */ 
     2934+       ret = at32_select_gpio_pins(gpio->port, gpio->pin_mask, gpio->oe_mask); 
     2935+       if (ret) 
     2936+               goto err_alloc_pins; 
     2937+ 
     2938+       gpio->initialized = 1; 
     2939+ 
     2940+       cdev_init(&gpio->char_dev, &gpio_dev_fops); 
     2941+       gpio->char_dev.owner = THIS_MODULE; 
     2942+       ret = cdev_add(&gpio->char_dev, MKDEV(MAJOR(gpio_devt), gpio->id), 1); 
     2943+       if (ret < 0) 
     2944+               goto err_cdev_add; 
     2945+       gpio->gpio_dev = class_device_create(gpio_dev_class, NULL, 
     2946+                                            MKDEV(MAJOR(gpio_devt), gpio->id), 
     2947+                                            NULL, 
     2948+                                            "gpio%d", gpio->id); 
     2949+       if (IS_ERR(gpio->gpio_dev)) { 
     2950+               printk(KERN_ERR "failed to create gpio%d\n", gpio->id); 
     2951+               ret = PTR_ERR(gpio->gpio_dev); 
     2952+               goto err_class_dev; 
     2953+       } 
     2954+ 
     2955+       printk(KERN_INFO "created gpio%d (port%d/0x%08x) as (%d:%d)\n", 
     2956+              gpio->id, gpio->port, gpio->pin_mask, 
     2957+              MAJOR(gpio->gpio_dev->devt), MINOR(gpio->gpio_dev->devt)); 
     2958+ 
     2959+       return 0; 
     2960+ 
     2961+err_class_dev: 
     2962+       cdev_del(&gpio->char_dev); 
     2963+err_cdev_add: 
     2964+       at32_deselect_pins(gpio->port, gpio->pin_mask); 
     2965+       gpio->initialized = 0; 
     2966+err_alloc_pins: 
     2967+       spin_lock(&gpio->lock); 
     2968+       gpio->enabled = 0; 
     2969+       spin_unlock(&gpio->lock); 
     2970+ 
     2971+       return ret; 
     2972+} 
     2973+ 
     2974+static struct gpio_attribute gpio_item_attr_gpio_id = { 
     2975+       .attr = { 
     2976+               .ca_owner = THIS_MODULE, 
     2977+               .ca_name = "gpio_id", 
     2978+               .ca_mode = S_IRUGO | S_IWUSR, 
     2979+       }, 
     2980+       .show = gpio_show_gpio_id, 
     2981+       .store = gpio_store_gpio_id, 
     2982+}; 
     2983+static struct gpio_attribute gpio_item_attr_pin_mask = { 
     2984+       .attr = { 
     2985+               .ca_owner = THIS_MODULE, 
     2986+               .ca_name = "pin_mask", 
     2987+               .ca_mode = S_IRUGO | S_IWUSR, 
     2988+       }, 
     2989+       .show = gpio_show_pin_mask, 
     2990+       .store = gpio_store_pin_mask, 
     2991+}; 
     2992+static struct gpio_attribute gpio_item_attr_oe_mask = { 
     2993+       .attr = { 
     2994+               .ca_owner = THIS_MODULE, 
     2995+               .ca_name = "oe_mask", 
     2996+               .ca_mode = S_IRUGO | S_IWUSR, 
     2997+       }, 
     2998+       .show = gpio_show_oe_mask, 
     2999+       .store = gpio_store_oe_mask, 
     3000+}; 
     3001+static struct gpio_attribute gpio_item_attr_enabled = { 
     3002+       .attr = { 
     3003+               .ca_owner = THIS_MODULE, 
     3004+               .ca_name = "enabled", 
     3005+               .ca_mode = S_IRUGO | S_IWUSR, 
     3006+       }, 
     3007+       .show = gpio_show_enabled, 
     3008+       .store = gpio_store_enabled, 
     3009+}; 
     3010+ 
     3011+static struct configfs_attribute *gpio_item_attrs[] = { 
     3012+       &gpio_item_attr_gpio_id.attr, 
     3013+       &gpio_item_attr_pin_mask.attr, 
     3014+       &gpio_item_attr_oe_mask.attr, 
     3015+       &gpio_item_attr_enabled.attr, 
     3016+       NULL, 
     3017+}; 
     3018+ 
     3019+static ssize_t gpio_show_attr(struct config_item *item, 
     3020+                             struct configfs_attribute *attr, 
     3021+                             char *page) 
     3022+{ 
     3023+       struct gpio_item *gpio_item = to_gpio_item(item); 
     3024+       struct gpio_attribute *gpio_attr 
     3025+               = container_of(attr, struct gpio_attribute, attr); 
     3026+       ssize_t ret = 0; 
     3027+ 
     3028+       if (gpio_attr->show) 
     3029+               ret = gpio_attr->show(gpio_item, page); 
     3030+       return ret; 
     3031+} 
     3032+ 
     3033+static ssize_t gpio_store_attr(struct config_item *item, 
     3034+                              struct configfs_attribute *attr, 
     3035+                              const char *page, size_t count) 
     3036+{ 
     3037+       struct gpio_item *gpio_item = to_gpio_item(item); 
     3038+       struct gpio_attribute *gpio_attr 
     3039+               = container_of(attr, struct gpio_attribute, attr); 
     3040+       ssize_t ret = -EINVAL; 
     3041+ 
     3042+       if (gpio_attr->store) 
     3043+               ret = gpio_attr->store(gpio_item, page, count); 
     3044+       return ret; 
     3045+} 
     3046+ 
     3047+static void gpio_release(struct config_item *item) 
     3048+{ 
     3049+       kfree(to_gpio_item(item)); 
     3050+} 
     3051+ 
     3052+static struct configfs_item_operations gpio_item_ops = { 
     3053+       .release                = gpio_release, 
     3054+       .show_attribute         = gpio_show_attr, 
     3055+       .store_attribute        = gpio_store_attr, 
     3056+}; 
     3057+ 
     3058+static struct config_item_type gpio_item_type = { 
     3059+       .ct_item_ops    = &gpio_item_ops, 
     3060+       .ct_attrs       = gpio_item_attrs, 
     3061+       .ct_owner       = THIS_MODULE, 
     3062+}; 
     3063+ 
     3064+static struct config_item *gpio_make_item(struct config_group *group, 
     3065+                                         const char *name) 
     3066+{ 
     3067+       static int next_id; 
     3068+       struct gpio_item *gpio; 
     3069+ 
     3070+       if (next_id >= GPIO_DEV_MAX) 
     3071+               return NULL; 
     3072+ 
     3073+       gpio = kzalloc(sizeof(struct gpio_item), GFP_KERNEL); 
     3074+       if (!gpio) 
     3075+               return NULL; 
     3076+ 
     3077+       gpio->id = next_id++; 
     3078+       config_item_init_type_name(&gpio->item, name, &gpio_item_type); 
     3079+       spin_lock_init(&gpio->lock); 
     3080+       init_waitqueue_head(&gpio->change_wq); 
     3081+ 
     3082+       return &gpio->item; 
     3083+} 
     3084+ 
     3085+static void gpio_drop_item(struct config_group *group, 
     3086+                          struct config_item *item) 
     3087+{ 
     3088+       struct gpio_item *gpio = to_gpio_item(item); 
     3089+ 
     3090+       spin_lock(&gpio->lock); 
     3091+       if (gpio->enabled) { 
     3092+               class_device_unregister(gpio->gpio_dev); 
     3093+               cdev_del(&gpio->char_dev); 
     3094+       } 
     3095+ 
     3096+       if (gpio->initialized) { 
     3097+               at32_deselect_pins(gpio->port, gpio->pin_mask); 
     3098+               gpio->initialized = 0; 
     3099+               gpio->enabled = 0; 
     3100+       } 
     3101+       spin_unlock(&gpio->lock); 
     3102+} 
     3103+ 
     3104+static struct configfs_group_operations gpio_group_ops = { 
     3105+       .make_item      = gpio_make_item, 
     3106+       .drop_item      = gpio_drop_item, 
     3107+}; 
     3108+ 
     3109+static struct config_item_type gpio_group_type = { 
     3110+       .ct_group_ops   = &gpio_group_ops, 
     3111+       .ct_owner       = THIS_MODULE, 
     3112+}; 
     3113+ 
     3114+static struct configfs_subsystem gpio_subsys = { 
     3115+       .su_group = { 
     3116+               .cg_item = { 
     3117+                        .ci_namebuf = "gpio", 
     3118+                        .ci_type = &gpio_group_type, 
     3119+                }, 
     3120+       }, 
     3121+}; 
     3122+ 
     3123+static int __init gpio_dev_init(void) 
     3124+{ 
     3125+       int err; 
     3126+ 
     3127+       gpio_dev_class = class_create(THIS_MODULE, "gpio-dev"); 
     3128+       if (IS_ERR(gpio_dev_class)) { 
     3129+               err = PTR_ERR(gpio_dev_class); 
     3130+               goto err_class_create; 
     3131+       } 
     3132+ 
     3133+       err = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpio"); 
     3134+       if (err < 0) 
     3135+               goto err_alloc_chrdev; 
     3136+ 
     3137+       /* Configfs initialization */ 
     3138+       config_group_init(&gpio_subsys.su_group); 
     3139+       init_MUTEX(&gpio_subsys.su_sem); 
     3140+       err = configfs_register_subsystem(&gpio_subsys); 
     3141+       if (err) 
     3142+               goto err_register_subsys; 
     3143+ 
     3144+       return 0; 
     3145+ 
     3146+err_register_subsys: 
     3147+       unregister_chrdev_region(gpio_devt, GPIO_DEV_MAX); 
     3148+err_alloc_chrdev: 
     3149+       class_destroy(gpio_dev_class); 
     3150+err_class_create: 
     3151+       printk(KERN_WARNING "Failed to initialize gpio /dev interface\n"); 
     3152+       return err; 
     3153+} 
     3154+late_initcall(gpio_dev_init); 
     3155diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/Kconfig linux-avr32.git/arch/avr32/mach-at32ap/Kconfig 
     3156--- linux-2.6.22.1/arch/avr32/mach-at32ap/Kconfig       2007-07-10 20:56:30.000000000 +0200 
     3157+++ linux-avr32.git/arch/avr32/mach-at32ap/Kconfig      2007-07-12 13:59:49.000000000 +0200 
     3158@@ -26,6 +26,13 @@ 
     3159  
     3160 endchoice 
     3161  
     3162+config GPIO_DEV 
     3163+       bool "GPIO /dev interface" 
     3164+       select CONFIGFS_FS 
     3165+       default n 
     3166+       help 
     3167+         Say `Y' to enable a /dev interface to the GPIO pins. 
     3168+ 
     3169 endmenu 
     3170  
     3171 endif # PLATFORM_AT32AP 
     3172diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/Makefile linux-avr32.git/arch/avr32/mach-at32ap/Makefile 
     3173--- linux-2.6.22.1/arch/avr32/mach-at32ap/Makefile      2007-07-10 20:56:30.000000000 +0200 
     3174+++ linux-avr32.git/arch/avr32/mach-at32ap/Makefile     2007-07-12 13:59:49.000000000 +0200 
     3175@@ -1,3 +1,5 @@ 
     3176 obj-y                          += at32ap.o clock.o intc.o extint.o pio.o hsmc.o 
     3177 obj-$(CONFIG_CPU_AT32AP7000)   += at32ap7000.o 
     3178 obj-$(CONFIG_CPU_AT32AP7000)   += time-tc.o 
     3179+obj-$(CONFIG_CPU_FREQ_AT32AP)  += cpufreq.o 
     3180+obj-$(CONFIG_GPIO_DEV)         += gpio-dev.o 
     3181diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/pio.c linux-avr32.git/arch/avr32/mach-at32ap/pio.c 
     3182--- linux-2.6.22.1/arch/avr32/mach-at32ap/pio.c 2007-07-10 20:56:30.000000000 +0200 
     3183+++ linux-avr32.git/arch/avr32/mach-at32ap/pio.c        2007-07-12 13:59:49.000000000 +0200 
     3184@@ -158,6 +158,82 @@ 
     3185        dump_stack(); 
     3186 } 
     3187  
     3188+#ifdef CONFIG_GPIO_DEV 
     3189+ 
     3190+/* Gang allocators and accessors; used by the GPIO /dev driver */ 
     3191+int at32_gpio_port_is_valid(unsigned int port) 
     3192+{ 
     3193+       return port < MAX_NR_PIO_DEVICES && pio_dev[port].regs != NULL; 
     3194+} 
     3195+ 
     3196+int at32_select_gpio_pins(unsigned int port, u32 pins, u32 oe_mask) 
     3197+{ 
     3198+       struct pio_device *pio; 
     3199+       u32 old, new; 
     3200+ 
     3201+       pio = &pio_dev[port]; 
     3202+       BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs || (oe_mask & ~pins)); 
     3203+ 
     3204+       /* Try to allocate the pins */ 
    42373205+       do { 
    4238 +               count_hz = clk_get_rate(pclk) / divs[i]; 
    4239 +               mult = clocksource_hz2mult(count_hz, shift); 
    4240 +               clocksource_avr32.mult = mult; 
    4241 + 
    4242 +               tmp = TICK_NSEC; 
    4243 +               tmp <<= shift; 
    4244 +               tmp += mult / 2; 
    4245 +               do_div(tmp, mult); 
    4246 + 
    4247 +               cycles_per_jiffy = tmp; 
    4248 +       } while (cycles_per_jiffy > cycles_max && ++i < divs_size); 
    4249 + 
    4250 +       clock_div = i + 1; 
    4251 + 
    4252 +       if (clock_div > divs_size) { 
    4253 +               pr_debug("timer: could not calculate clock divider\n"); 
    4254 +               return -EFAULT; 
    4255 +       } 
    4256 + 
    4257 +       /* Set the clock divider */ 
    4258 +       timer_write(ioregs, 0, CMR, TIMER_BF(CMR_TCCLKS, clock_div)); 
     3206+               old = pio->pinmux_mask; 
     3207+               if (old & pins) 
     3208+                       return -EBUSY; 
     3209+ 
     3210+               new = old | pins; 
     3211+       } while (cmpxchg(&pio->pinmux_mask, old, new) != old); 
     3212+ 
     3213+       /* That went well, now configure the port */ 
     3214+       pio_writel(pio, OER, oe_mask); 
     3215+       pio_writel(pio, PER, pins); 
    42593216+ 
    42603217+       return 0; 
    42613218+} 
    42623219+ 
    4263 +int avr32_hpt_init(unsigned int count) 
    4264 +{ 
    4265 +       struct resource *regs; 
    4266 +       struct clk *pclk; 
    4267 +       int irq = -1; 
    4268 +       int ret = 0; 
    4269 + 
    4270 +       ret = -ENXIO; 
    4271 + 
    4272 +       irq = platform_get_irq(&at32_systc0_device, 0); 
    4273 +       if (irq < 0) { 
    4274 +               pr_debug("timer: could not get irq\n"); 
    4275 +               goto out_error; 
    4276 +       } 
    4277 + 
    4278 +       pclk = clk_get(&at32_systc0_device.dev, "pclk"); 
    4279 +       if (IS_ERR(pclk)) { 
    4280 +               pr_debug("timer: could not get clk: %ld\n", PTR_ERR(pclk)); 
    4281 +               goto out_error; 
    4282 +       } 
    4283 +       clk_enable(pclk); 
    4284 + 
    4285 +       regs = platform_get_resource(&at32_systc0_device, IORESOURCE_MEM, 0); 
    4286 +       if (!regs) { 
    4287 +               pr_debug("timer: could not get resource\n"); 
    4288 +               goto out_error_clk; 
    4289 +       } 
    4290 + 
    4291 +       ioregs = ioremap(regs->start, regs->end - regs->start + 1); 
    4292 +       if (!ioregs) { 
    4293 +               pr_debug("timer: could not get ioregs\n"); 
    4294 +               goto out_error_clk; 
    4295 +       } 
    4296 + 
    4297 +       ret = avr32_timer_calc_div_and_set_jiffies(pclk); 
    4298 +       if (ret) 
    4299 +               goto out_error_io; 
    4300 + 
    4301 +       ret = setup_irq(irq, &timer_irqaction); 
    4302 +       if (ret) { 
    4303 +               pr_debug("timer: could not request irq %d: %d\n", 
    4304 +                               irq, ret); 
    4305 +               goto out_error_io; 
    4306 +       } 
    4307 + 
    4308 +       expirelo = (timer_read(ioregs, 0, CV) / cycles_per_jiffy + 1) 
    4309 +               * cycles_per_jiffy; 
    4310 + 
    4311 +       /* Enable clock and interrupts on RC compare */ 
    4312 +       timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_CLKEN)); 
    4313 +       timer_write(ioregs, 0, IER, TIMER_BIT(IER_CPCS)); 
    4314 +       /* Set cycles to first interrupt */ 
    4315 +       timer_write(ioregs, 0,  RC, expirelo); 
    4316 + 
    4317 +       printk(KERN_INFO "timer: AT32AP system timer/counter at 0x%p irq %d\n", 
    4318 +                       ioregs, irq); 
    4319 + 
    4320 +       return 0; 
    4321 + 
    4322 +out_error_io: 
    4323 +       iounmap(ioregs); 
    4324 +out_error_clk: 
    4325 +       clk_put(pclk); 
    4326 +out_error: 
    4327 +       return ret; 
    4328 +} 
    4329 + 
    4330 +int avr32_hpt_start(void) 
    4331 +{ 
    4332 +       timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_SWTRG)); 
    4333 +       return 0; 
    4334 +} 
    4335 + 
    4336 +irqreturn_t timer_interrupt(int irq, void *dev_id) 
    4337 +{ 
    4338 +       unsigned int sr = timer_read(ioregs, 0, SR); 
    4339 + 
    4340 +       if (sr & TIMER_BIT(SR_CPCS)) { 
    4341 +               /* ack timer interrupt and try to set next interrupt */ 
    4342 +               avr32_timer_ack(); 
    4343 + 
    4344 +               /* 
    4345 +                * Call the generic timer interrupt handler 
    4346 +                */ 
    4347 +               write_seqlock(&xtime_lock); 
    4348 +               do_timer(1); 
    4349 +               write_sequnlock(&xtime_lock); 
    4350 + 
    4351 +               /* 
    4352 +                * In UP mode, we call local_timer_interrupt() to do profiling 
    4353 +                * and process accounting. 
    4354 +                * 
    4355 +                * SMP is not supported yet. 
    4356 +                */ 
    4357 +               local_timer_interrupt(irq, dev_id); 
    4358 + 
    4359 +               return IRQ_HANDLED; 
    4360 +       } 
    4361 + 
    4362 +       return IRQ_NONE; 
    4363 +} 
    4364 diff -Nur -x .gitignore -x .git linux-2.6.21.3/arch/avr32/Makefile avr32-git/arch/avr32/Makefile 
    4365 --- linux-2.6.21.3/arch/avr32/Makefile  2007-05-24 23:22:47.000000000 +0200 
    4366 +++ avr32-git/arch/avr32/Makefile       2007-06-06 11:33:46.000000000 +0200 
    4367 @@ -16,7 +16,7 @@ 
    4368  CFLAGS_MODULE  += -mno-relax 
    4369  LDFLAGS_vmlinux        += --relax 
    4370   
    4371 -cpuflags-$(CONFIG_CPU_AP7000)  += -mcpu=ap7000 
    4372 +cpuflags-$(CONFIG_CPU_AT32AP7000)      += -mcpu=ap7000 
    4373   
    4374  CFLAGS         += $(cpuflags-y) 
    4375  AFLAGS         += $(cpuflags-y) 
    4376 @@ -27,9 +27,11 @@ 
    4377  head-y                                 += arch/avr32/kernel/head.o 
    4378  core-$(CONFIG_PLATFORM_AT32AP)         += arch/avr32/mach-at32ap/ 
    4379  core-$(CONFIG_BOARD_ATSTK1000)         += arch/avr32/boards/atstk1000/ 
    4380 +core-$(CONFIG_BOARD_ATNGW100)          += arch/avr32/boards/atngw100/ 
     3220+void at32_deselect_pins(unsigned int port, u32 pins) 
     3221+{ 
     3222+       struct pio_device *pio; 
     3223+       u32 old, new; 
     3224+ 
     3225+       pio = &pio_dev[port]; 
     3226+       BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs); 
     3227+ 
     3228+       /* Return to a "safe" mux configuration */ 
     3229+       pio_writel(pio, PUER, pins); 
     3230+       pio_writel(pio, ODR, pins); 
     3231+ 
     3232+       /* Deallocate the pins */ 
     3233+       do { 
     3234+               old = pio->pinmux_mask; 
     3235+               new = old & ~pins; 
     3236+       } while (cmpxchg(&pio->pinmux_mask, old, new) != old); 
     3237+} 
     3238+ 
     3239+u32 at32_gpio_get_value_multiple(unsigned int port, u32 pins) 
     3240+{ 
     3241+       struct pio_device *pio; 
     3242+ 
     3243+       pio = &pio_dev[port]; 
     3244+       BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs); 
     3245+ 
     3246+       return pio_readl(pio, PDSR) & pins; 
     3247+} 
     3248+ 
     3249+void at32_gpio_set_value_multiple(unsigned int port, u32 value, u32 mask) 
     3250+{ 
     3251+       struct pio_device *pio; 
     3252+ 
     3253+       pio = &pio_dev[port]; 
     3254+       BUG_ON(port > ARRAY_SIZE(pio_dev) || !pio->regs); 
     3255+ 
     3256+       /* No atomic updates for now... */ 
     3257+       pio_writel(pio, CODR, ~value & mask); 
     3258+       pio_writel(pio, SODR, value & mask); 
     3259+} 
     3260+ 
     3261+#endif /* CONFIG_GPIO_DEV */ 
     3262+ 
     3263+ 
     3264 /*--------------------------------------------------------------------------*/ 
     3265  
     3266 /* GPIO API */ 
     3267diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/pm.h linux-avr32.git/arch/avr32/mach-at32ap/pm.h 
     3268--- linux-2.6.22.1/arch/avr32/mach-at32ap/pm.h  1970-01-01 01:00:00.000000000 +0100 
     3269+++ linux-avr32.git/arch/avr32/mach-at32ap/pm.h 2007-07-12 13:59:49.000000000 +0200 
     3270@@ -0,0 +1,112 @@ 
     3271+/* 
     3272+ * Register definitions for the Power Manager (PM) 
     3273+ */ 
     3274+#ifndef __ARCH_AVR32_MACH_AT32AP_PM_H__ 
     3275+#define __ARCH_AVR32_MACH_AT32AP_PM_H__ 
     3276+ 
     3277+/* PM register offsets */ 
     3278+#define PM_MCCTRL                              0x0000 
     3279+#define PM_CKSEL                               0x0004 
     3280+#define PM_CPU_MASK                            0x0008 
     3281+#define PM_HSB_MASK                            0x000c 
     3282+#define PM_PBA_MASK                            0x0010 
     3283+#define PM_PBB_MASK                            0x0014 
     3284+#define PM_PLL0                                        0x0020 
     3285+#define PM_PLL1                                        0x0024 
     3286+#define PM_IER                                 0x0040 
     3287+#define PM_IDR                                 0x0044 
     3288+#define PM_IMR                                 0x0048 
     3289+#define PM_ISR                                 0x004c 
     3290+#define PM_ICR                                 0x0050 
     3291+#define PM_GCCTRL(x)                           (0x0060 + 4 * (x)) 
     3292+#define PM_RCAUSE                              0x00c0 
     3293+ 
     3294+/* Bitfields in CKSEL */ 
     3295+#define PM_CPUSEL_OFFSET                       0 
     3296+#define PM_CPUSEL_SIZE                         3 
     3297+#define PM_CPUDIV_OFFSET                       7 
     3298+#define PM_CPUDIV_SIZE                         1 
     3299+#define PM_HSBSEL_OFFSET                       8 
     3300+#define PM_HSBSEL_SIZE                         3 
     3301+#define PM_HSBDIV_OFFSET                       15 
     3302+#define PM_HSBDIV_SIZE                         1 
     3303+#define PM_PBASEL_OFFSET                       16 
     3304+#define PM_PBASEL_SIZE                         3 
     3305+#define PM_PBADIV_OFFSET                       23 
     3306+#define PM_PBADIV_SIZE                         1 
     3307+#define PM_PBBSEL_OFFSET                       24 
     3308+#define PM_PBBSEL_SIZE                         3 
     3309+#define PM_PBBDIV_OFFSET                       31 
     3310+#define PM_PBBDIV_SIZE                         1 
     3311+ 
     3312+/* Bitfields in PLL0 */ 
     3313+#define PM_PLLEN_OFFSET                                0 
     3314+#define PM_PLLEN_SIZE                          1 
     3315+#define PM_PLLOSC_OFFSET                       1 
     3316+#define PM_PLLOSC_SIZE                         1 
     3317+#define PM_PLLOPT_OFFSET                       2 
     3318+#define PM_PLLOPT_SIZE                         3 
     3319+#define PM_PLLDIV_OFFSET                       8 
     3320+#define PM_PLLDIV_SIZE                         8 
     3321+#define PM_PLLMUL_OFFSET                       16 
     3322+#define PM_PLLMUL_SIZE                         8 
     3323+#define PM_PLLCOUNT_OFFSET                     24 
     3324+#define PM_PLLCOUNT_SIZE                       6 
     3325+#define PM_PLLTEST_OFFSET                      31 
     3326+#define PM_PLLTEST_SIZE                                1 
     3327+ 
     3328+/* Bitfields in ICR */ 
     3329+#define PM_LOCK0_OFFSET                                0 
     3330+#define PM_LOCK0_SIZE                          1 
     3331+#define PM_LOCK1_OFFSET                                1 
     3332+#define PM_LOCK1_SIZE                          1 
     3333+#define PM_WAKE_OFFSET                         2 
     3334+#define PM_WAKE_SIZE                           1 
     3335+#define PM_CKRDY_OFFSET                                5 
     3336+#define PM_CKRDY_SIZE                          1 
     3337+#define PM_MSKRDY_OFFSET                       6 
     3338+#define PM_MSKRDY_SIZE                         1 
     3339+ 
     3340+/* Bitfields in GCCTRL0 */ 
     3341+#define PM_OSCSEL_OFFSET                       0 
     3342+#define PM_OSCSEL_SIZE                         1 
     3343+#define PM_PLLSEL_OFFSET                       1 
     3344+#define PM_PLLSEL_SIZE                         1 
     3345+#define PM_CEN_OFFSET                          2 
     3346+#define PM_CEN_SIZE                            1 
     3347+#define PM_DIVEN_OFFSET                                4 
     3348+#define PM_DIVEN_SIZE                          1 
     3349+#define PM_DIV_OFFSET                          8 
     3350+#define PM_DIV_SIZE                            8 
     3351+ 
     3352+/* Bitfields in RCAUSE */ 
     3353+#define PM_POR_OFFSET                          0 
     3354+#define PM_POR_SIZE                            1 
     3355+#define PM_EXT_OFFSET                          2 
     3356+#define PM_EXT_SIZE                            1 
     3357+#define PM_WDT_OFFSET                          3 
     3358+#define PM_WDT_SIZE                            1 
     3359+#define PM_NTAE_OFFSET                         4 
     3360+#define PM_NTAE_SIZE                           1 
     3361+ 
     3362+/* Bit manipulation macros */ 
     3363+#define PM_BIT(name)                                   \ 
     3364+       (1 << PM_##name##_OFFSET) 
     3365+#define PM_BF(name,value)                              \ 
     3366+       (((value) & ((1 << PM_##name##_SIZE) - 1))      \ 
     3367+        << PM_##name##_OFFSET) 
     3368+#define PM_BFEXT(name,value)                           \ 
     3369+       (((value) >> PM_##name##_OFFSET)                \ 
     3370+        & ((1 << PM_##name##_SIZE) - 1)) 
     3371+#define PM_BFINS(name,value,old)\ 
     3372+       (((old) & ~(((1 << PM_##name##_SIZE) - 1)       \ 
     3373+                   << PM_##name##_OFFSET))             \ 
     3374+        | PM_BF(name,value)) 
     3375+ 
     3376+/* Register access macros */ 
     3377+#define pm_readl(reg)                                                  \ 
     3378+       __raw_readl((void __iomem *)AT32_PM_BASE + PM_##reg) 
     3379+#define pm_writel(reg,value)                                           \ 
     3380+       __raw_writel((value), (void __iomem *)AT32_PM_BASE + PM_##reg) 
     3381+ 
     3382+#endif /* __ARCH_AVR32_MACH_AT32AP_PM_H__ */ 
     3383diff -x .git -Nur linux-2.6.22.1/arch/avr32/mach-at32ap/sm.h linux-avr32.git/arch/avr32/mach-at32ap/sm.h 
     3384--- linux-2.6.22.1/arch/avr32/mach-at32ap/sm.h  2007-07-10 20:56:30.000000000 +0200 
     3385+++ linux-avr32.git/arch/avr32/mach-at32ap/sm.h 1970-01-01 01:00:00.000000000 +0100 
     3386@@ -1,242 +0,0 @@ 
     3387-/* 
     3388- * Register definitions for SM 
     3389- * 
     3390- * System Manager 
     3391- */ 
     3392-#ifndef __ASM_AVR32_SM_H__ 
     3393-#define __ASM_AVR32_SM_H__ 
     3394- 
     3395-/* SM register offsets */ 
     3396-#define SM_PM_MCCTRL                            0x0000 
     3397-#define SM_PM_CKSEL                             0x0004 
     3398-#define SM_PM_CPU_MASK                          0x0008 
     3399-#define SM_PM_HSB_MASK                          0x000c 
     3400-#define SM_PM_PBA_MASK                         0x0010 
     3401-#define SM_PM_PBB_MASK                         0x0014 
     3402-#define SM_PM_PLL0                              0x0020 
     3403-#define SM_PM_PLL1                              0x0024 
     3404-#define SM_PM_VCTRL                             0x0030 
     3405-#define SM_PM_VMREF                             0x0034 
     3406-#define SM_PM_VMV                               0x0038 
     3407-#define SM_PM_IER                               0x0040 
     3408-#define SM_PM_IDR                               0x0044 
     3409-#define SM_PM_IMR                               0x0048 
     3410-#define SM_PM_ISR                               0x004c 
     3411-#define SM_PM_ICR                               0x0050 
     3412-#define SM_PM_GCCTRL                            0x0060 
     3413-#define SM_RTC_CTRL                             0x0080 
     3414-#define SM_RTC_VAL                              0x0084 
     3415-#define SM_RTC_TOP                              0x0088 
     3416-#define SM_RTC_IER                              0x0090 
     3417-#define SM_RTC_IDR                              0x0094 
     3418-#define SM_RTC_IMR                              0x0098 
     3419-#define SM_RTC_ISR                              0x009c 
     3420-#define SM_RTC_ICR                              0x00a0 
     3421-#define SM_WDT_CTRL                             0x00b0 
     3422-#define SM_WDT_CLR                              0x00b4 
     3423-#define SM_WDT_EXT                              0x00b8 
     3424-#define SM_RC_RCAUSE                            0x00c0 
     3425-#define SM_EIM_IER                              0x0100 
     3426-#define SM_EIM_IDR                              0x0104 
     3427-#define SM_EIM_IMR                              0x0108 
     3428-#define SM_EIM_ISR                              0x010c 
     3429-#define SM_EIM_ICR                              0x0110 
     3430-#define SM_EIM_MODE                             0x0114 
     3431-#define SM_EIM_EDGE                             0x0118 
     3432-#define SM_EIM_LEVEL                            0x011c 
     3433-#define SM_EIM_TEST                             0x0120 
     3434-#define SM_EIM_NMIC                             0x0124 
     3435- 
     3436-/* Bitfields in PM_MCCTRL */ 
     3437- 
     3438-/* Bitfields in PM_CKSEL */ 
     3439-#define SM_CPUSEL_OFFSET                        0 
     3440-#define SM_CPUSEL_SIZE                          3 
     3441-#define SM_CPUDIV_OFFSET                        7 
     3442-#define SM_CPUDIV_SIZE                          1 
     3443-#define SM_HSBSEL_OFFSET                        8 
     3444-#define SM_HSBSEL_SIZE                          3 
     3445-#define SM_HSBDIV_OFFSET                        15 
     3446-#define SM_HSBDIV_SIZE                          1 
     3447-#define SM_PBASEL_OFFSET                       16 
     3448-#define SM_PBASEL_SIZE                         3 
     3449-#define SM_PBADIV_OFFSET                       23 
     3450-#define SM_PBADIV_SIZE                         1 
     3451-#define SM_PBBSEL_OFFSET                       24 
     3452-#define SM_PBBSEL_SIZE                         3 
     3453-#define SM_PBBDIV_OFFSET                       31 
     3454-#define SM_PBBDIV_SIZE                         1 
     3455- 
     3456-/* Bitfields in PM_CPU_MASK */ 
     3457- 
     3458-/* Bitfields in PM_HSB_MASK */ 
     3459- 
     3460-/* Bitfields in PM_PBA_MASK */ 
     3461- 
     3462-/* Bitfields in PM_PBB_MASK */ 
     3463- 
     3464-/* Bitfields in PM_PLL0 */ 
     3465-#define SM_PLLEN_OFFSET                         0 
     3466-#define SM_PLLEN_SIZE                           1 
     3467-#define SM_PLLOSC_OFFSET                        1 
     3468-#define SM_PLLOSC_SIZE                          1 
     3469-#define SM_PLLOPT_OFFSET                        2 
     3470-#define SM_PLLOPT_SIZE                          3 
     3471-#define SM_PLLDIV_OFFSET                        8 
     3472-#define SM_PLLDIV_SIZE                          8 
     3473-#define SM_PLLMUL_OFFSET                        16 
     3474-#define SM_PLLMUL_SIZE                          8 
     3475-#define SM_PLLCOUNT_OFFSET                      24 
     3476-#define SM_PLLCOUNT_SIZE                        6 
     3477-#define SM_PLLTEST_OFFSET                       31 
     3478-#define SM_PLLTEST_SIZE                         1 
     3479- 
     3480-/* Bitfields in PM_PLL1 */ 
     3481- 
     3482-/* Bitfields in PM_VCTRL */ 
     3483-#define SM_VAUTO_OFFSET                         0 
     3484-#define SM_VAUTO_SIZE                           1 
     3485-#define SM_PM_VCTRL_VAL_OFFSET                  8 
     3486-#define SM_PM_VCTRL_VAL_SIZE                    7 
     3487- 
     3488-/* Bitfields in PM_VMREF */ 
     3489-#define SM_REFSEL_OFFSET                        0 
     3490-#define SM_REFSEL_SIZE                          4 
     3491- 
     3492-/* Bitfields in PM_VMV */ 
     3493-#define SM_PM_VMV_VAL_OFFSET                    0 
     3494-#define SM_PM_VMV_VAL_SIZE                      8 
     3495- 
     3496-/* Bitfields in PM_IER */ 
     3497- 
     3498-/* Bitfields in PM_IDR */ 
     3499- 
     3500-/* Bitfields in PM_IMR */ 
     3501- 
     3502-/* Bitfields in PM_ISR */ 
     3503- 
     3504-/* Bitfields in PM_ICR */ 
     3505-#define SM_LOCK0_OFFSET                         0 
     3506-#define SM_LOCK0_SIZE                           1 
     3507-#define SM_LOCK1_OFFSET                         1 
     3508-#define SM_LOCK1_SIZE                           1 
     3509-#define SM_WAKE_OFFSET                          2 
     3510-#define SM_WAKE_SIZE                            1 
     3511-#define SM_VOK_OFFSET                           3 
     3512-#define SM_VOK_SIZE                             1 
     3513-#define SM_VMRDY_OFFSET                         4 
     3514-#define SM_VMRDY_SIZE                           1 
     3515-#define SM_CKRDY_OFFSET                         5 
     3516-#define SM_CKRDY_SIZE                           1 
     3517- 
     3518-/* Bitfields in PM_GCCTRL */ 
     3519-#define SM_OSCSEL_OFFSET                        0 
     3520-#define SM_OSCSEL_SIZE                          1 
     3521-#define SM_PLLSEL_OFFSET                        1 
     3522-#define SM_PLLSEL_SIZE                          1 
     3523-#define SM_CEN_OFFSET                           2 
     3524-#define SM_CEN_SIZE                             1 
     3525-#define SM_CPC_OFFSET                           3 
     3526-#define SM_CPC_SIZE                             1 
     3527-#define SM_DIVEN_OFFSET                         4 
     3528-#define SM_DIVEN_SIZE                           1 
     3529-#define SM_DIV_OFFSET                           8 
     3530-#define SM_DIV_SIZE                             8 
     3531- 
     3532-/* Bitfields in RTC_CTRL */ 
     3533-#define SM_PCLR_OFFSET                          1 
     3534-#define SM_PCLR_SIZE                            1 
     3535-#define SM_TOPEN_OFFSET                         2 
     3536-#define SM_TOPEN_SIZE                           1 
     3537-#define SM_CLKEN_OFFSET                         3 
     3538-#define SM_CLKEN_SIZE                           1 
     3539-#define SM_PSEL_OFFSET                          8 
     3540-#define SM_PSEL_SIZE                            16 
     3541- 
     3542-/* Bitfields in RTC_VAL */ 
     3543-#define SM_RTC_VAL_VAL_OFFSET                   0 
     3544-#define SM_RTC_VAL_VAL_SIZE                     31 
     3545- 
     3546-/* Bitfields in RTC_TOP */ 
     3547-#define SM_RTC_TOP_VAL_OFFSET                   0 
     3548-#define SM_RTC_TOP_VAL_SIZE                     32 
     3549- 
     3550-/* Bitfields in RTC_IER */ 
     3551- 
     3552-/* Bitfields in RTC_IDR */ 
     3553- 
     3554-/* Bitfields in RTC_IMR */ 
     3555- 
     3556-/* Bitfields in RTC_ISR */ 
     3557- 
     3558-/* Bitfields in RTC_ICR */ 
     3559-#define SM_TOPI_OFFSET                          0 
     3560-#define SM_TOPI_SIZE                            1 
     3561- 
     3562-/* Bitfields in WDT_CTRL */ 
     3563-#define SM_KEY_OFFSET                           24 
     3564-#define SM_KEY_SIZE                             8 
     3565- 
     3566-/* Bitfields in WDT_CLR */ 
     3567- 
     3568-/* Bitfields in WDT_EXT */ 
     3569- 
     3570-/* Bitfields in RC_RCAUSE */ 
     3571-#define SM_POR_OFFSET                           0 
     3572-#define SM_POR_SIZE                             1 
     3573-#define SM_BOD_OFFSET                           1 
     3574-#define SM_BOD_SIZE                             1 
     3575-#define SM_EXT_OFFSET                           2 
     3576-#define SM_EXT_SIZE                             1 
     3577-#define SM_WDT_OFFSET                           3 
     3578-#define SM_WDT_SIZE                             1 
     3579-#define SM_NTAE_OFFSET                          4 
     3580-#define SM_NTAE_SIZE                            1 
     3581-#define SM_SERP_OFFSET                          5 
     3582-#define SM_SERP_SIZE                            1 
     3583- 
     3584-/* Bitfields in EIM_IER */ 
     3585- 
     3586-/* Bitfields in EIM_IDR */ 
     3587- 
     3588-/* Bitfields in EIM_IMR */ 
     3589- 
     3590-/* Bitfields in EIM_ISR */ 
     3591- 
     3592-/* Bitfields in EIM_ICR */ 
     3593- 
     3594-/* Bitfields in EIM_MODE */ 
     3595- 
     3596-/* Bitfields in EIM_EDGE */ 
     3597-#define SM_INT0_OFFSET                          0 
     3598-#define SM_INT0_SIZE                            1 
     3599-#define SM_INT1_OFFSET                          1 
     3600-#define SM_INT1_SIZE                            1 
     3601-#define SM_INT2_OFFSET                          2 
     3602-#define SM_INT2_SIZE                            1 
     3603-#define SM_INT3_OFFSET                          3 
     3604-#define SM_INT3_SIZE                            1 
     3605- 
     3606-/* Bitfields in EIM_LEVEL */ 
     3607- 
     3608-/* Bitfields in EIM_TEST */ 
     3609-#define SM_TESTEN_OFFSET                        31 
     3610-#define SM_TESTEN_SIZE                          1 
     3611- 
     3612-/* Bitfields in EIM_NMIC */ 
     3613-#define SM_EN_OFFSET                            0 
     3614-#define SM_EN_SIZE                              1 
     3615- 
     3616-/* Bit manipulation macros */ 
     3617-#define SM_BIT(name)                            (1 << SM_##name##_OFFSET) 
     3618-#define SM_BF(name,value)                       (((value) & ((1 << SM_##name##_SIZE) - 1)) << SM_##name##_OFFSET) 
     3619-#define SM_BFEXT(name,value)                    (((value) >> SM_##name##_OFFSET) & ((1 << SM_##name##_SIZE) - 1)) 
     3620-#define SM_BFINS(name,value,old)                (((old) & ~(((1 << SM_##name##_SIZE) - 1) << SM_##name##_OFFSET)) | SM_BF(name,value)) 
     3621- 
     3622-/* Register access macros */ 
     3623-#define sm_readl(port,reg)                                     \ 
     3624-       __raw_readl((port)->regs + SM_##reg) 
     3625-#define sm_writel(port,reg,value)                              \ 
     3626-       __raw_writel((value), (port)->regs + SM_##reg) 
     3627- 
     3628-#endif /* __ASM_AVR32_SM_H__ */ 
     3629diff -x .git -Nur linux-2.6.22.1/arch/avr32/Makefile linux-avr32.git/arch/avr32/Makefile 
     3630--- linux-2.6.22.1/arch/avr32/Makefile  2007-07-10 20:56:30.000000000 +0200 
     3631+++ linux-avr32.git/arch/avr32/Makefile 2007-06-06 11:33:46.000000000 +0200 
     3632@@ -31,6 +31,7 @@ 
    43813633 core-$(CONFIG_LOADER_U_BOOT)           += arch/avr32/boot/u-boot/ 
    43823634 core-y                                 += arch/avr32/kernel/ 
     
    43863638  
    43873639 archincdir-$(CONFIG_PLATFORM_AT32AP)   := arch-at32ap 
    4388 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 
    4389 --- linux-2.6.21.3/arch/avr32/mm/dma-coherent.c 2007-05-24 23:22:47.000000000 +0200 
    4390 +++ avr32-git/arch/avr32/mm/dma-coherent.c      2007-06-06 11:33:46.000000000 +0200 
    4391 @@ -112,16 +112,21 @@ 
    4392  } 
    4393  EXPORT_SYMBOL(dma_free_coherent); 
    4394   
    4395 -#if 0 
    4396  void *dma_alloc_writecombine(struct device *dev, size_t size, 
    4397                              dma_addr_t *handle, gfp_t gfp) 
    4398  { 
    4399         struct page *page; 
    4400 +       dma_addr_t phys; 
    4401