26 files changed, 998 insertions, 788 deletions

diff --git a/arch/blackfin/Kconfig b/arch/blackfin/Kconfig
index ba21e33b8b1f..368bc7fe167e 100644
--- a/arch/blackfin/Kconfig
+++ b/arch/blackfin/Kconfig
@@ -544,7 +544,7 @@ config EXCPT_IRQ_SYSC_L1
         default y
         help
           If enabled, the entire ASM lowlevel exception and interrupt entry code
-          (STORE/RESTORE CONTEXT) is linked into L1 instruction memory. 
+          (STORE/RESTORE CONTEXT) is linked into L1 instruction memory.
           (less latency)
 
 config DO_IRQ_L1
@@ -904,29 +904,38 @@ config ARCH_SUSPEND_POSSIBLE
         depends on !SMP
 
 choice
-        prompt "Select PM Wakeup Event Source"
-        default PM_WAKEUP_GPIO_BY_SIC_IWR
+        prompt "Default Power Saving Mode"
         depends on PM
-        help
-          If you have a GPIO already configured as input with the corresponding PORTx_MASK
-          bit set - "Specify Wakeup Event by SIC_IWR value"
+        default PM_BFIN_SLEEP_DEEPER
+config  PM_BFIN_SLEEP_DEEPER
+        bool "Sleep Deeper"
+        help
+          Sleep "Deeper" Mode (High Power Savings) - This mode reduces dynamic
+          power dissipation by disabling the clock to the processor core (CCLK).
+          Furthermore, Standby sets the internal power supply voltage (VDDINT)
+          to 0.85 V to provide the greatest power savings, while preserving the
+          processor state.
+          The PLL and system clock (SCLK) continue to operate at a very low
+          frequency of about 3.3 MHz. To preserve data integrity in the SDRAM,
+          the SDRAM is put into Self Refresh Mode. Typically an external event
+          such as GPIO interrupt or RTC activity wakes up the processor.
+          Various Peripherals such as UART, SPORT, PPI may not function as
+          normal during Sleep Deeper, due to the reduced SCLK frequency.
+          When in the sleep mode, system DMA access to L1 memory is not supported.
+
+config  PM_BFIN_SLEEP
+        bool "Sleep"
+        help
+          Sleep Mode (High Power Savings) - The sleep mode reduces power
+          dissipation by disabling the clock to the processor core (CCLK).
+          The PLL and system clock (SCLK), however, continue to operate in
+          this mode. Typically an external event or RTC activity will wake
+          up the processor. When in the sleep mode,
+          system DMA access to L1 memory is not supported.
+endchoice
 
-config PM_WAKEUP_GPIO_BY_SIC_IWR
-        bool "Specify Wakeup Event by SIC_IWR value"
 config PM_WAKEUP_BY_GPIO
         bool "Cause Wakeup Event by GPIO"
-config PM_WAKEUP_GPIO_API
-        bool "Configure Wakeup Event by PM GPIO API"
-
-endchoice
-
-config PM_WAKEUP_SIC_IWR
-        hex "Wakeup Events (SIC_IWR)"
-        depends on PM_WAKEUP_GPIO_BY_SIC_IWR
-        default 0x8 if (BF537 || BF536 || BF534)
-        default 0x80 if (BF533 || BF532 || BF531)
-        default 0x80 if (BF54x)
-        default 0x80 if (BF52x)
 
 config PM_WAKEUP_GPIO_NUMBER
         int "Wakeup GPIO number"
diff --git a/arch/blackfin/Kconfig.debug b/arch/blackfin/Kconfig.debug
index 59b87a483c68..c61bdebb9974 100644
--- a/arch/blackfin/Kconfig.debug
+++ b/arch/blackfin/Kconfig.debug
@@ -164,7 +164,7 @@ config DUAL_CORE_TEST_MODULE
 config CPLB_INFO
         bool "Display the CPLB information"
         help
-          Display the CPLB information.
+          Display the CPLB information via /proc/cplbinfo.
 
 config ACCESS_CHECK
         bool "Check the user pointer address"
diff --git a/arch/blackfin/Makefile b/arch/blackfin/Makefile
index 0edc402fef54..fe254f886a6e 100644
--- a/arch/blackfin/Makefile
+++ b/arch/blackfin/Makefile
@@ -119,6 +119,7 @@ archclean:
         $(Q)$(MAKE) $(clean)=$(boot)
 
 
+INSTALL_PATH ?= /tftpboot
 boot := arch/$(ARCH)/boot
 BOOT_TARGETS = vmImage
 PHONY += $(BOOT_TARGETS) install
diff --git a/arch/blackfin/configs/BF533-STAMP_defconfig b/arch/blackfin/configs/BF533-STAMP_defconfig
index 9b7123cf27a3..198f4123af4b 100644
--- a/arch/blackfin/configs/BF533-STAMP_defconfig
+++ b/arch/blackfin/configs/BF533-STAMP_defconfig
@@ -216,8 +216,6 @@ CONFIG_MEM_SIZE=128
 CONFIG_MEM_ADD_WIDTH=11
 CONFIG_ENET_FLASH_PIN=0
 CONFIG_BOOT_LOAD=0x1000
-
-
 CONFIG_BFIN_SCRATCH_REG_RETN=y
 # CONFIG_BFIN_SCRATCH_REG_RETE is not set
 # CONFIG_BFIN_SCRATCH_REG_CYCLES is not set
@@ -483,7 +481,7 @@ CONFIG_MTD=y
 # CONFIG_MTD_CONCAT is not set
 CONFIG_MTD_PARTITIONS=y
 # CONFIG_MTD_REDBOOT_PARTS is not set
-# CONFIG_MTD_CMDLINE_PARTS is not set
+CONFIG_MTD_CMDLINE_PARTS=y
 
 #
 # User Modules And Translation Layers
@@ -500,8 +498,8 @@ CONFIG_MTD_BLOCK=y
 #
 # RAM/ROM/Flash chip drivers
 #
-# CONFIG_MTD_CFI is not set
-CONFIG_MTD_JEDECPROBE=m
+CONFIG_MTD_CFI=m
+# CONFIG_MTD_JEDECPROBE is not set
 CONFIG_MTD_GEN_PROBE=m
 # CONFIG_MTD_CFI_ADV_OPTIONS is not set
 CONFIG_MTD_MAP_BANK_WIDTH_1=y
@@ -515,8 +513,9 @@ CONFIG_MTD_CFI_I2=y
 # CONFIG_MTD_CFI_I4 is not set
 # CONFIG_MTD_CFI_I8 is not set
 # CONFIG_MTD_CFI_INTELEXT is not set
-# CONFIG_MTD_CFI_AMDSTD is not set
+CONFIG_MTD_CFI_AMDSTD=m
 # CONFIG_MTD_CFI_STAA is not set
+CONFIG_MTD_CFI_UTIL=m
 CONFIG_MTD_RAM=y
 CONFIG_MTD_ROM=m
 # CONFIG_MTD_ABSENT is not set
@@ -526,6 +525,11 @@ CONFIG_MTD_ROM=m
 #
 CONFIG_MTD_COMPLEX_MAPPINGS=y
 # CONFIG_MTD_PHYSMAP is not set
+CONFIG_MTD_BF5xx=m
+CONFIG_BFIN_FLASH_BANK_0=0x7BB0
+CONFIG_BFIN_FLASH_BANK_1=0x7BB0
+CONFIG_BFIN_FLASH_BANK_2=0x7BB0
+CONFIG_BFIN_FLASH_BANK_3=0x7BB0
 # CONFIG_MTD_UCLINUX is not set
 # CONFIG_MTD_PLATRAM is not set
 
diff --git a/arch/blackfin/kernel/bfin_dma_5xx.c b/arch/blackfin/kernel/bfin_dma_5xx.c
index fa9debe8d5f4..5453bc3664fc 100644
--- a/arch/blackfin/kernel/bfin_dma_5xx.c
+++ b/arch/blackfin/kernel/bfin_dma_5xx.c
@@ -104,6 +104,16 @@ int request_dma(unsigned int channel, char *device_id)
 
         mutex_unlock(&(dma_ch[channel].dmalock));
 
+#ifdef CONFIG_BF54x
+        if (channel >= CH_UART2_RX && channel <= CH_UART3_TX &&
+                strncmp(device_id, "BFIN_UART", 9) == 0)
+                dma_ch[channel].regs->peripheral_map |=
+                        (channel - CH_UART2_RX + 0xC);
+        else
+                dma_ch[channel].regs->peripheral_map |=
+                        (channel - CH_UART2_RX + 0x6);
+#endif
+
         dma_ch[channel].device_id = device_id;
         dma_ch[channel].irq_callback = NULL;
 
diff --git a/arch/blackfin/kernel/bfin_gpio.c b/arch/blackfin/kernel/bfin_gpio.c
index 6bbe0a2fccb8..08788f7bbfba 100644
--- a/arch/blackfin/kernel/bfin_gpio.c
+++ b/arch/blackfin/kernel/bfin_gpio.c
@@ -186,7 +186,7 @@ static struct str_ident {
         char name[RESOURCE_LABEL_SIZE];
 } str_ident[MAX_RESOURCES];
 
-#ifdef CONFIG_PM
+#if defined(CONFIG_PM) && !defined(CONFIG_BF54x)
 static unsigned short wakeup_map[gpio_bank(MAX_BLACKFIN_GPIOS)];
 static unsigned char wakeup_flags_map[MAX_BLACKFIN_GPIOS];
 static struct gpio_port_s gpio_bank_saved[gpio_bank(MAX_BLACKFIN_GPIOS)];
@@ -696,9 +696,8 @@ static int bfin_gpio_wakeup_type(unsigned gpio, unsigned char type)
         return 0;
 }
 
-u32 gpio_pm_setup(void)
+u32 bfin_pm_setup(void)
 {
-        u32 sic_iwr = 0;
         u16 bank, mask, i, gpio;
 
         for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
@@ -723,7 +722,8 @@ u32 gpio_pm_setup(void)
                         gpio = i;
 
                         while (mask) {
-                                if (mask & 1) {
+                                if ((mask & 1) && (wakeup_flags_map[gpio] !=
+                                        PM_WAKE_IGNORE)) {
                                         reserved_gpio_map[gpio_bank(gpio)] |=
                                                         gpio_bit(gpio);
                                         bfin_gpio_wakeup_type(gpio,
@@ -734,21 +734,17 @@ u32 gpio_pm_setup(void)
                                 mask >>= 1;
                         }
 
-                        sic_iwr |= 1 <<
-                                (sic_iwr_irqs[bank] - (IRQ_CORETMR + 1));
+                        bfin_internal_set_wake(sic_iwr_irqs[bank], 1);
                         gpio_bankb[bank]->maskb_set = wakeup_map[gpio_bank(i)];
                 }
         }
 
         AWA_DUMMY_READ(maskb_set);
 
-        if (sic_iwr)
-                return sic_iwr;
-        else
-                return IWR_ENABLE_ALL;
+        return 0;
 }
 
-void gpio_pm_restore(void)
+void bfin_pm_restore(void)
 {
         u16 bank, mask, i;
 
@@ -768,7 +764,7 @@ void gpio_pm_restore(void)
 
                         reserved_gpio_map[bank] =
                                         gpio_bank_saved[bank].reserved;
-
+                        bfin_internal_set_wake(sic_iwr_irqs[bank], 0);
                 }
 
                 gpio_bankb[bank]->maskb = gpio_bank_saved[bank].maskb;
diff --git a/arch/blackfin/kernel/cplb-mpu/cplbinit.c b/arch/blackfin/kernel/cplb-mpu/cplbinit.c
index e2e2b5079f5b..dc6e8a7a8bda 100644
--- a/arch/blackfin/kernel/cplb-mpu/cplbinit.c
+++ b/arch/blackfin/kernel/cplb-mpu/cplbinit.c
@@ -26,6 +26,10 @@
 #include <asm/cplb.h>
 #include <asm/cplbinit.h>
 
+#if ANOMALY_05000263
+# error the MPU will not function safely while Anomaly 05000263 applies
+#endif
+
 struct cplb_entry icplb_tbl[MAX_CPLBS];
 struct cplb_entry dcplb_tbl[MAX_CPLBS];
 
diff --git a/arch/blackfin/kernel/init_task.c b/arch/blackfin/kernel/init_task.c
index 673c860ffc23..c640154030e2 100644
--- a/arch/blackfin/kernel/init_task.c
+++ b/arch/blackfin/kernel/init_task.c
@@ -57,5 +57,5 @@ EXPORT_SYMBOL(init_task);
  * "init_task" linker map entry.
  */
 union thread_union init_thread_union
-    __attribute__ ((__section__(".data.init_task"))) = {
+    __attribute__ ((__section__(".init_task.data"))) = {
 INIT_THREAD_INFO(init_task)};
diff --git a/arch/blackfin/kernel/process.c b/arch/blackfin/kernel/process.c
index 023dc80af187..6b8459c66163 100644
--- a/arch/blackfin/kernel/process.c
+++ b/arch/blackfin/kernel/process.c
@@ -31,7 +31,6 @@
 #include <linux/smp_lock.h>
 #include <linux/unistd.h>
 #include <linux/user.h>
-#include <linux/a.out.h>
 #include <linux/uaccess.h>
 #include <linux/fs.h>
 #include <linux/err.h>
diff --git a/arch/blackfin/kernel/setup.c b/arch/blackfin/kernel/setup.c
index 6e106b3d7729..8229b1090eb9 100644
--- a/arch/blackfin/kernel/setup.c
+++ b/arch/blackfin/kernel/setup.c
@@ -1,30 +1,11 @@
 /*
- * File:         arch/blackfin/kernel/setup.c
- * Based on:
- * Author:
+ * arch/blackfin/kernel/setup.c
  *
- * Created:
- * Description:
+ * Copyright 2004-2006 Analog Devices Inc.
  *
- * Modified:
- *               Copyright 2004-2006 Analog Devices Inc.
+ * Enter bugs at http://blackfin.uclinux.org/
  *
- * Bugs:         Enter bugs at http://blackfin.uclinux.org/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see the file COPYING, or write
- * to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * Licensed under the GPL-2 or later.
  */
 
 #include <linux/delay.h>
@@ -34,6 +15,7 @@
 #include <linux/cpu.h>
 #include <linux/module.h>
 #include <linux/tty.h>
+#include <linux/pfn.h>
 
 #include <linux/ext2_fs.h>
 #include <linux/cramfs_fs.h>
@@ -47,6 +29,8 @@
 #include <asm/fixed_code.h>
 #include <asm/early_printk.h>
 
+static DEFINE_PER_CPU(struct cpu, cpu_devices);
+
 u16 _bfin_swrst;
 
 unsigned long memory_start, memory_end, physical_mem_end;
@@ -67,6 +51,29 @@ EXPORT_SYMBOL(mtd_size);
 
 char __initdata command_line[COMMAND_LINE_SIZE];
 
+/* boot memmap, for parsing "memmap=" */
+#define BFIN_MEMMAP_MAX         128 /* number of entries in bfin_memmap */
+#define BFIN_MEMMAP_RAM         1
+#define BFIN_MEMMAP_RESERVED    2
+struct bfin_memmap {
+        int nr_map;
+        struct bfin_memmap_entry {
+                unsigned long long addr; /* start of memory segment */
+                unsigned long long size;
+                unsigned long type;
+        } map[BFIN_MEMMAP_MAX];
+} bfin_memmap __initdata;
+
+/* for memmap sanitization */
+struct change_member {
+        struct bfin_memmap_entry *pentry; /* pointer to original entry */
+        unsigned long long addr; /* address for this change point */
+};
+static struct change_member change_point_list[2*BFIN_MEMMAP_MAX] __initdata;
+static struct change_member *change_point[2*BFIN_MEMMAP_MAX] __initdata;
+static struct bfin_memmap_entry *overlap_list[BFIN_MEMMAP_MAX] __initdata;
+static struct bfin_memmap_entry new_map[BFIN_MEMMAP_MAX] __initdata;
+
 void __init bf53x_cache_init(void)
 {
 #if defined(CONFIG_BFIN_DCACHE) || defined(CONFIG_BFIN_ICACHE)
@@ -123,12 +130,224 @@ void __init bf53x_relocate_l1_mem(void)
 
 }
 
+/* add_memory_region to memmap */
+static void __init add_memory_region(unsigned long long start,
+                              unsigned long long size, int type)
+{
+        int i;
+
+        i = bfin_memmap.nr_map;
+
+        if (i == BFIN_MEMMAP_MAX) {
+                printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
+                return;
+        }
+
+        bfin_memmap.map[i].addr = start;
+        bfin_memmap.map[i].size = size;
+        bfin_memmap.map[i].type = type;
+        bfin_memmap.nr_map++;
+}
+
+/*
+ * Sanitize the boot memmap, removing overlaps.
+ */
+static int __init sanitize_memmap(struct bfin_memmap_entry *map, int *pnr_map)
+{
+        struct change_member *change_tmp;
+        unsigned long current_type, last_type;
+        unsigned long long last_addr;
+        int chgidx, still_changing;
+        int overlap_entries;
+        int new_entry;
+        int old_nr, new_nr, chg_nr;
+        int i;
+
+        /*
+                Visually we're performing the following (1,2,3,4 = memory types)
+
+                Sample memory map (w/overlaps):
+                   ____22__________________
+                   ______________________4_
+                   ____1111________________
+                   _44_____________________
+                   11111111________________
+                   ____________________33__
+                   ___________44___________
+                   __________33333_________
+                   ______________22________
+                   ___________________2222_
+                   _________111111111______
+                   _____________________11_
+                   _________________4______
+
+                Sanitized equivalent (no overlap):
+                   1_______________________
+                   _44_____________________
+                   ___1____________________
+                   ____22__________________
+                   ______11________________
+                   _________1______________
+                   __________3_____________
+                   ___________44___________
+                   _____________33_________
+                   _______________2________
+                   ________________1_______
+                   _________________4______
+                   ___________________2____
+                   ____________________33__
+                   ______________________4_
+        */
+        /* if there's only one memory region, don't bother */
+        if (*pnr_map < 2)
+                return -1;
+
+        old_nr = *pnr_map;
+
+        /* bail out if we find any unreasonable addresses in memmap */
+        for (i = 0; i < old_nr; i++)
+                if (map[i].addr + map[i].size < map[i].addr)
+                        return -1;
+
+        /* create pointers for initial change-point information (for sorting) */
+        for (i = 0; i < 2*old_nr; i++)
+                change_point[i] = &change_point_list[i];
+
+        /* record all known change-points (starting and ending addresses),
+           omitting those that are for empty memory regions */
+        chgidx = 0;
+        for (i = 0; i < old_nr; i++)    {
+                if (map[i].size != 0) {
+                        change_point[chgidx]->addr = map[i].addr;
+                        change_point[chgidx++]->pentry = &map[i];
+                        change_point[chgidx]->addr = map[i].addr + map[i].size;
+                        change_point[chgidx++]->pentry = &map[i];
+                }
+        }
+        chg_nr = chgidx;        /* true number of change-points */
+
+        /* sort change-point list by memory addresses (low -> high) */
+        still_changing = 1;
+        while (still_changing)  {
+                still_changing = 0;
+                for (i = 1; i < chg_nr; i++)  {
+                        /* if <current_addr> > <last_addr>, swap */
+                        /* or, if current=<start_addr> & last=<end_addr>, swap */
+                        if ((change_point[i]->addr < change_point[i-1]->addr) ||
+                                ((change_point[i]->addr == change_point[i-1]->addr) &&
+                                 (change_point[i]->addr == change_point[i]->pentry->addr) &&
+                                 (change_point[i-1]->addr != change_point[i-1]->pentry->addr))
+                           ) {
+                                change_tmp = change_point[i];
+                                change_point[i] = change_point[i-1];
+                                change_point[i-1] = change_tmp;
+                                still_changing = 1;
+                        }
+                }
+        }
+
+        /* create a new memmap, removing overlaps */
+        overlap_entries = 0;     /* number of entries in the overlap table */
+        new_entry = 0;   /* index for creating new memmap entries */
+        last_type = 0;           /* start with undefined memory type */
+        last_addr = 0;           /* start with 0 as last starting address */
+        /* loop through change-points, determining affect on the new memmap */
+        for (chgidx = 0; chgidx < chg_nr; chgidx++) {
+                /* keep track of all overlapping memmap entries */
+                if (change_point[chgidx]->addr == change_point[chgidx]->pentry->addr) {
+                        /* add map entry to overlap list (> 1 entry implies an overlap) */
+                        overlap_list[overlap_entries++] = change_point[chgidx]->pentry;
+                } else {
+                        /* remove entry from list (order independent, so swap with last) */
+                        for (i = 0; i < overlap_entries; i++) {
+                                if (overlap_list[i] == change_point[chgidx]->pentry)
+                                        overlap_list[i] = overlap_list[overlap_entries-1];
+                        }
+                        overlap_entries--;
+                }
+                /* if there are overlapping entries, decide which "type" to use */
+                /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
+                current_type = 0;
+                for (i = 0; i < overlap_entries; i++)
+                        if (overlap_list[i]->type > current_type)
+                                current_type = overlap_list[i]->type;
+                /* continue building up new memmap based on this information */
+                if (current_type != last_type)  {
+                        if (last_type != 0) {
+                                new_map[new_entry].size =
+                                        change_point[chgidx]->addr - last_addr;
+                                /* move forward only if the new size was non-zero */
+                                if (new_map[new_entry].size != 0)
+                                        if (++new_entry >= BFIN_MEMMAP_MAX)
+                                                break;  /* no more space left for new entries */
+                        }
+                        if (current_type != 0) {
+                                new_map[new_entry].addr = change_point[chgidx]->addr;
+                                new_map[new_entry].type = current_type;
+                                last_addr = change_point[chgidx]->addr;
+                        }
+                        last_type = current_type;
+                }
+        }
+        new_nr = new_entry;   /* retain count for new entries */
+
+        /* copy new  mapping into original location */
+        memcpy(map, new_map, new_nr*sizeof(struct bfin_memmap_entry));
+        *pnr_map = new_nr;
+
+        return 0;
+}
+
+static void __init print_memory_map(char *who)
+{
+        int i;
+
+        for (i = 0; i < bfin_memmap.nr_map; i++) {
+                printk(KERN_DEBUG " %s: %016Lx - %016Lx ", who,
+                        bfin_memmap.map[i].addr,
+                        bfin_memmap.map[i].addr + bfin_memmap.map[i].size);
+                switch (bfin_memmap.map[i].type) {
+                case BFIN_MEMMAP_RAM:
+                                printk("(usable)\n");
+                                break;
+                case BFIN_MEMMAP_RESERVED:
+                                printk("(reserved)\n");
+                                break;
+                default:        printk("type %lu\n", bfin_memmap.map[i].type);
+                                break;
+                }
+        }
+}
+
+static __init int parse_memmap(char *arg)
+{
+        unsigned long long start_at, mem_size;
+
+        if (!arg)
+                return -EINVAL;
+
+        mem_size = memparse(arg, &arg);
+        if (*arg == '@') {
+                start_at = memparse(arg+1, &arg);
+                add_memory_region(start_at, mem_size, BFIN_MEMMAP_RAM);
+        } else if (*arg == '$') {
+                start_at = memparse(arg+1, &arg);
+                add_memory_region(start_at, mem_size, BFIN_MEMMAP_RESERVED);
+        }
+
+        return 0;
+}
+
 /*
  * Initial parsing of the command line.  Currently, we support:
  *  - Controlling the linux memory size: mem=xxx[KMG]
  *  - Controlling the physical memory size: max_mem=xxx[KMG][$][#]
  *       $ -> reserved memory is dcacheable
  *       # -> reserved memory is icacheable
+ *  - "memmap=XXX[KkmM][@][$]XXX[KkmM]" defines a memory region
+ *       @ from <start> to <start>+<mem>, type RAM
+ *       $ from <start> to <start>+<mem>, type RESERVED
+ *
  */
 static __init void parse_cmdline_early(char *cmdline_p)
 {
@@ -136,7 +355,6 @@ static __init void parse_cmdline_early(char *cmdline_p)
         unsigned int memsize;
         for (;;) {
                 if (c == ' ') {
-
                         if (!memcmp(to, "mem=", 4)) {
                                 to += 4;
                                 memsize = memparse(to, &to);
@@ -162,6 +380,9 @@ static __init void parse_cmdline_early(char *cmdline_p)
                         } else if (!memcmp(to, "earlyprintk=", 12)) {
                                 to += 12;
                                 setup_early_printk(to);
+                        } else if (!memcmp(to, "memmap=", 7)) {
+                                to += 7;
+                                parse_memmap(to);
                         }
                 }
                 c = *(to++);
@@ -170,75 +391,36 @@ static __init void parse_cmdline_early(char *cmdline_p)
         }
 }
 
-void __init setup_arch(char **cmdline_p)
+/*
+ * Setup memory defaults from user config.
+ * The physical memory layout looks like:
+ *
+ *  [_rambase, _ramstart]:              kernel image
+ *  [memory_start, memory_end]:         dynamic memory managed by kernel
+ *  [memory_end, _ramend]:              reserved memory
+ *      [meory_mtd_start(memory_end),
+ *              memory_mtd_start + mtd_size]:   rootfs (if any)
+ *      [_ramend - DMA_UNCACHED_REGION,
+ *              _ramend]:                       uncached DMA region
+ *  [_ramend, physical_mem_end]:        memory not managed by kernel
+ *
+ */
+static __init void  memory_setup(void)
 {
-        int bootmap_size;
-        unsigned long l1_length, sclk, cclk;
 #ifdef CONFIG_MTD_UCLINUX
         unsigned long mtd_phys = 0;
 #endif
 
-#ifdef CONFIG_DUMMY_CONSOLE
-        conswitchp = &dummy_con;
-#endif
-
-#if defined(CONFIG_CMDLINE_BOOL)
-        strncpy(&command_line[0], CONFIG_CMDLINE, sizeof(command_line));
-        command_line[sizeof(command_line) - 1] = 0;
-#endif
-
-        /* Keep a copy of command line */
-        *cmdline_p = &command_line[0];
-        memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
-        boot_command_line[COMMAND_LINE_SIZE - 1] = '\0';
-
-        /* setup memory defaults from the user config */
-        physical_mem_end = 0;
-        _ramend = CONFIG_MEM_SIZE * 1024 * 1024;
-
-        parse_cmdline_early(&command_line[0]);
-
-        cclk = get_cclk();
-        sclk = get_sclk();
-
-#if !defined(CONFIG_BFIN_KERNEL_CLOCK)
-        if (ANOMALY_05000273 && cclk == sclk)
-                panic("ANOMALY 05000273, SCLK can not be same as CCLK");
-#endif
+        _rambase = (unsigned long)_stext;
+        _ramstart = (unsigned long)_end;
 
-#ifdef BF561_FAMILY
-        if (ANOMALY_05000266) {
-                bfin_read_IMDMA_D0_IRQ_STATUS();
-                bfin_read_IMDMA_D1_IRQ_STATUS();
+        if (DMA_UNCACHED_REGION > (_ramend - _ramstart)) {
+                console_init();
+                panic("DMA region exceeds memory limit: %lu.\n",
+                        _ramend - _ramstart);
         }
-#endif
-
-        printk(KERN_INFO "Hardware Trace ");
-        if (bfin_read_TBUFCTL() & 0x1 )
-                printk("Active ");
-        else
-                printk("Off ");
-        if (bfin_read_TBUFCTL() & 0x2)
-                printk("and Enabled\n");
-        else
-        printk("and Disabled\n");
-
-
-#if defined(CONFIG_CHR_DEV_FLASH) || defined(CONFIG_BLK_DEV_FLASH)
-        /* we need to initialize the Flashrom device here since we might
-         * do things with flash early on in the boot
-         */
-        flash_probe();
-#endif
-
-        if (physical_mem_end == 0)
-                physical_mem_end = _ramend;
-
-        /* by now the stack is part of the init task */
         memory_end = _ramend - DMA_UNCACHED_REGION;
 
-        _ramstart = (unsigned long)__bss_stop;
-        _rambase = (unsigned long)_stext;
 #ifdef CONFIG_MPU
         /* Round up to multiple of 4MB.  */
         memory_start = (_ramstart + 0x3fffff) & ~0x3fffff;
@@ -292,7 +474,7 @@ void __init setup_arch(char **cmdline_p)
         }
 
         /* Relocate MTD image to the top of memory after the uncached memory area */
-        dma_memcpy((char *)memory_end, __bss_stop, mtd_size);
+        dma_memcpy((char *)memory_end, _end, mtd_size);
 
         memory_mtd_start = memory_end;
         _ebss = memory_mtd_start;       /* define _ebss for compatible */
@@ -319,13 +501,175 @@ void __init setup_arch(char **cmdline_p)
 #endif
 
 #if !defined(CONFIG_MTD_UCLINUX)
-        memory_end -= SIZE_4K; /*In case there is no valid CPLB behind memory_end make sure we don't get to close*/
+        /*In case there is no valid CPLB behind memory_end make sure we don't get to close*/
+        memory_end -= SIZE_4K;
 #endif
+
         init_mm.start_code = (unsigned long)_stext;
         init_mm.end_code = (unsigned long)_etext;
         init_mm.end_data = (unsigned long)_edata;
         init_mm.brk = (unsigned long)0;
 
+        printk(KERN_INFO "Board Memory: %ldMB\n", physical_mem_end >> 20);
+        printk(KERN_INFO "Kernel Managed Memory: %ldMB\n", _ramend >> 20);
+
+        printk(KERN_INFO "Memory map:\n"
+                KERN_INFO "  text      = 0x%p-0x%p\n"
+                KERN_INFO "  rodata    = 0x%p-0x%p\n"
+                KERN_INFO "  bss       = 0x%p-0x%p\n"
+                KERN_INFO "  data      = 0x%p-0x%p\n"
+                KERN_INFO "    stack   = 0x%p-0x%p\n"
+                KERN_INFO "  init      = 0x%p-0x%p\n"
+                KERN_INFO "  available = 0x%p-0x%p\n"
+#ifdef CONFIG_MTD_UCLINUX
+                KERN_INFO "  rootfs    = 0x%p-0x%p\n"
+#endif
+#if DMA_UNCACHED_REGION > 0
+                KERN_INFO "  DMA Zone  = 0x%p-0x%p\n"
+#endif
+                , _stext, _etext,
+                __start_rodata, __end_rodata,
+                __bss_start, __bss_stop,
+                _sdata, _edata,
+                (void *)&init_thread_union,
+                (void *)((int)(&init_thread_union) + 0x2000),
+                __init_begin, __init_end,
+                (void *)_ramstart, (void *)memory_end
+#ifdef CONFIG_MTD_UCLINUX
+                , (void *)memory_mtd_start, (void *)(memory_mtd_start + mtd_size)
+#endif
+#if DMA_UNCACHED_REGION > 0
+                , (void *)(_ramend - DMA_UNCACHED_REGION), (void *)(_ramend)
+#endif
+                );
+}
+
+static __init void setup_bootmem_allocator(void)
+{
+        int bootmap_size;
+        int i;
+        unsigned long min_pfn, max_pfn;
+        unsigned long curr_pfn, last_pfn, size;
+
+        /* mark memory between memory_start and memory_end usable */
+        add_memory_region(memory_start,
+                memory_end - memory_start, BFIN_MEMMAP_RAM);
+        /* sanity check for overlap */
+        sanitize_memmap(bfin_memmap.map, &bfin_memmap.nr_map);
+        print_memory_map("boot memmap");
+
+        min_pfn = PAGE_OFFSET >> PAGE_SHIFT;
+        max_pfn = memory_end >> PAGE_SHIFT;
+
+        /*
+         * give all the memory to the bootmap allocator,  tell it to put the
+         * boot mem_map at the start of memory.
+         */
+        bootmap_size = init_bootmem_node(NODE_DATA(0),
+                        memory_start >> PAGE_SHIFT,     /* map goes here */
+                        min_pfn, max_pfn);
+
+        /* register the memmap regions with the bootmem allocator */
+        for (i = 0; i < bfin_memmap.nr_map; i++) {
+                /*
+                 * Reserve usable memory
+                 */
+                if (bfin_memmap.map[i].type != BFIN_MEMMAP_RAM)
+                        continue;
+                /*
+                 * We are rounding up the start address of usable memory:
+                 */
+                curr_pfn = PFN_UP(bfin_memmap.map[i].addr);
+                if (curr_pfn >= max_pfn)
+                        continue;
+                /*
+                 * ... and at the end of the usable range downwards:
+                 */
+                last_pfn = PFN_DOWN(bfin_memmap.map[i].addr +
+                                         bfin_memmap.map[i].size);
+
+                if (last_pfn > max_pfn)
+                        last_pfn = max_pfn;
+
+                /*
+                 * .. finally, did all the rounding and playing
+                 * around just make the area go away?
+                 */
+                if (last_pfn <= curr_pfn)
+                        continue;
+
+                size = last_pfn - curr_pfn;
+                free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
+        }
+
+        /* reserve memory before memory_start, including bootmap */
+        reserve_bootmem(PAGE_OFFSET,
+                memory_start + bootmap_size + PAGE_SIZE - 1 - PAGE_OFFSET,
+                BOOTMEM_DEFAULT);
+}
+
+void __init setup_arch(char **cmdline_p)
+{
+        unsigned long l1_length, sclk, cclk;
+
+#ifdef CONFIG_DUMMY_CONSOLE
+        conswitchp = &dummy_con;
+#endif
+
+#if defined(CONFIG_CMDLINE_BOOL)
+        strncpy(&command_line[0], CONFIG_CMDLINE, sizeof(command_line));
+        command_line[sizeof(command_line) - 1] = 0;
+#endif
+
+        /* Keep a copy of command line */
+        *cmdline_p = &command_line[0];
+        memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
+        boot_command_line[COMMAND_LINE_SIZE - 1] = '\0';
+
+        /* setup memory defaults from the user config */
+        physical_mem_end = 0;
+        _ramend = CONFIG_MEM_SIZE * 1024 * 1024;
+
+        memset(&bfin_memmap, 0, sizeof(bfin_memmap));
+
+        parse_cmdline_early(&command_line[0]);
+
+        if (physical_mem_end == 0)
+                physical_mem_end = _ramend;
+
+        memory_setup();
+
+        cclk = get_cclk();
+        sclk = get_sclk();
+
+#if !defined(CONFIG_BFIN_KERNEL_CLOCK)
+        if (ANOMALY_05000273 && cclk == sclk)
+                panic("ANOMALY 05000273, SCLK can not be same as CCLK");
+#endif
+
+#ifdef BF561_FAMILY
+        if (ANOMALY_05000266) {
+                bfin_read_IMDMA_D0_IRQ_STATUS();
+                bfin_read_IMDMA_D1_IRQ_STATUS();
+        }
+#endif
+        printk(KERN_INFO "Hardware Trace ");
+        if (bfin_read_TBUFCTL() & 0x1)
+                printk("Active ");
+        else
+                printk("Off ");
+        if (bfin_read_TBUFCTL() & 0x2)
+                printk("and Enabled\n");
+        else
+        printk("and Disabled\n");
+
+#if defined(CONFIG_CHR_DEV_FLASH) || defined(CONFIG_BLK_DEV_FLASH)
+        /* we need to initialize the Flashrom device here since we might
+         * do things with flash early on in the boot
+         */
+        flash_probe();
+#endif
+
         _bfin_swrst = bfin_read_SWRST();
 
         if (_bfin_swrst & RESET_DOUBLE)
@@ -335,7 +679,7 @@ void __init setup_arch(char **cmdline_p)
         else if (_bfin_swrst & RESET_SOFTWARE)
                 printk(KERN_NOTICE "Reset caused by Software reset\n");
 
-        printk(KERN_INFO "Blackfin support (C) 2004-2007 Analog Devices, Inc.\n");
+        printk(KERN_INFO "Blackfin support (C) 2004-2008 Analog Devices, Inc.\n");
         if (bfin_compiled_revid() == 0xffff)
                 printk(KERN_INFO "Compiled for ADSP-%s Rev any\n", CPU);
         else if (bfin_compiled_revid() == -1)
@@ -361,55 +705,8 @@ void __init setup_arch(char **cmdline_p)
         if (ANOMALY_05000273 && (cclk >> 1) <= sclk)
                 printk("\n\n\nANOMALY_05000273: CCLK must be >= 2*SCLK !!!\n\n\n");
 
-        printk(KERN_INFO "Board Memory: %ldMB\n", physical_mem_end >> 20);
-        printk(KERN_INFO "Kernel Managed Memory: %ldMB\n", _ramend >> 20);
-
-        printk(KERN_INFO "Memory map:\n"
-               KERN_INFO "  text      = 0x%p-0x%p\n"
-               KERN_INFO "  rodata    = 0x%p-0x%p\n"
-               KERN_INFO "  data      = 0x%p-0x%p\n"
-               KERN_INFO "    stack   = 0x%p-0x%p\n"
-               KERN_INFO "  init      = 0x%p-0x%p\n"
-               KERN_INFO "  bss       = 0x%p-0x%p\n"
-               KERN_INFO "  available = 0x%p-0x%p\n"
-#ifdef CONFIG_MTD_UCLINUX
-               KERN_INFO "  rootfs    = 0x%p-0x%p\n"
-#endif
-#if DMA_UNCACHED_REGION > 0
-               KERN_INFO "  DMA Zone  = 0x%p-0x%p\n"
-#endif
-               , _stext, _etext,
-               __start_rodata, __end_rodata,
-               _sdata, _edata,
-               (void *)&init_thread_union, (void *)((int)(&init_thread_union) + 0x2000),
-               __init_begin, __init_end,
-               __bss_start, __bss_stop,
-               (void *)_ramstart, (void *)memory_end
-#ifdef CONFIG_MTD_UCLINUX
-               , (void *)memory_mtd_start, (void *)(memory_mtd_start + mtd_size)
-#endif
-#if DMA_UNCACHED_REGION > 0
-               , (void *)(_ramend - DMA_UNCACHED_REGION), (void *)(_ramend)
-#endif
-               );
+        setup_bootmem_allocator();
 
-        /*
-         * give all the memory to the bootmap allocator,  tell it to put the
-         * boot mem_map at the start of memory
-         */
-        bootmap_size = init_bootmem_node(NODE_DATA(0), memory_start >> PAGE_SHIFT,      /* map goes here */
-                                         PAGE_OFFSET >> PAGE_SHIFT,
-                                         memory_end >> PAGE_SHIFT);
-        /*
-         * free the usable memory,  we have to make sure we do not free
-         * the bootmem bitmap so we then reserve it after freeing it :-)
-         */
-        free_bootmem(memory_start, memory_end - memory_start);
-
-        reserve_bootmem(memory_start, bootmap_size, BOOTMEM_DEFAULT);
-        /*
-         * get kmalloc into gear
-         */
         paging_init();
 
         /* check the size of the l1 area */
@@ -450,15 +747,15 @@ void __init setup_arch(char **cmdline_p)
 
 static int __init topology_init(void)
 {
-#if defined (CONFIG_BF561)
-        static struct cpu cpu[2];
-        register_cpu(&cpu[0], 0);
-        register_cpu(&cpu[1], 1);
+        int cpu;
+
+        for_each_possible_cpu(cpu) {
+                struct cpu *c = &per_cpu(cpu_devices, cpu);
+
+                register_cpu(c, cpu);
+        }
+
         return 0;
-#else
-        static struct cpu cpu[1];
-        return register_cpu(cpu, 0);
-#endif
 }
 
 subsys_initcall(topology_init);
@@ -700,7 +997,7 @@ static void c_stop(struct seq_file *m, void *v)
 {
 }
 
-struct seq_operations cpuinfo_op = {
+const struct seq_operations cpuinfo_op = {
         .start = c_start,
         .next = c_next,
         .stop = c_stop,
diff --git a/arch/blackfin/kernel/traps.c b/arch/blackfin/kernel/traps.c
index 66b5f3e3ae2a..58717cb19707 100644
--- a/arch/blackfin/kernel/traps.c
+++ b/arch/blackfin/kernel/traps.c
@@ -649,7 +649,7 @@ void dump_bfin_process(struct pt_regs *fp)
         if (context & 0x0020 && (fp->seqstat & SEQSTAT_EXCAUSE) == VEC_HWERR)
                 printk(KERN_NOTICE "HW Error context\n");
         else if (context & 0x0020)
-                printk(KERN_NOTICE "Defered Exception context\n");
+                printk(KERN_NOTICE "Deferred Exception context\n");
         else if (context & 0x3FC0)
                 printk(KERN_NOTICE "Interrupt context\n");
         else if (context & 0x4000)
diff --git a/arch/blackfin/kernel/vmlinux.lds.S b/arch/blackfin/kernel/vmlinux.lds.S
index 858722421b40..aed832540b3b 100644
--- a/arch/blackfin/kernel/vmlinux.lds.S
+++ b/arch/blackfin/kernel/vmlinux.lds.S
@@ -41,6 +41,9 @@ _jiffies = _jiffies_64;
 SECTIONS
 {
         . = CONFIG_BOOT_LOAD;
+        /* Neither the text, ro_data or bss section need to be aligned
+         * So pack them back to back
+         */
         .text :
         {
                 __text = .;
@@ -58,22 +61,25 @@ SECTIONS
                 *(__ex_table)
                 ___stop___ex_table = .;
 
-                . = ALIGN(4);
                 __etext = .;
         }
 
-        RO_DATA(PAGE_SIZE)
+        /* Just in case the first read only is a 32-bit access */
+        RO_DATA(4)
+
+        .bss :
+        {
+                . = ALIGN(4);
+                ___bss_start = .;
+                *(.bss .bss.*)
+                *(COMMON)
+                ___bss_stop = .;
+        }
 
         .data :
         {
-                /* make sure the init_task is aligned to the
-                 * kernel thread size so we can locate the kernel
-                 * stack properly and quickly.
-                 */
                 __sdata = .;
-                . = ALIGN(THREAD_SIZE);
-                *(.data.init_task)
-
+                /* This gets done first, so the glob doesn't suck it in */
                 . = ALIGN(32);
                 *(.data.cacheline_aligned)
 
@@ -81,10 +87,22 @@ SECTIONS
                 *(.data.*)
                 CONSTRUCTORS
 
+                /* make sure the init_task is aligned to the
+                 * kernel thread size so we can locate the kernel
+                 * stack properly and quickly.
+                 */
                 . = ALIGN(THREAD_SIZE);
+                *(.init_task.data)
+
                 __edata = .;
         }
 
+        /* The init section should be last, so when we free it, it goes into
+         * the general memory pool, and (hopefully) will decrease fragmentation
+         * a tiny bit. The init section has a _requirement_ that it be
+         * PAGE_SIZE aligned
+         */
+        . = ALIGN(PAGE_SIZE);
         ___init_begin = .;
 
         .init.text :
@@ -179,16 +197,7 @@ SECTIONS
         . = ALIGN(PAGE_SIZE);
         ___init_end = .;
 
-        .bss :
-        {
-                . = ALIGN(4);
-                ___bss_start = .;
-                *(.bss .bss.*)
-                *(COMMON)
-                . = ALIGN(4);
-                ___bss_stop = .;
-                __end = .;
-        }
+        __end =.;
 
         STABS_DEBUG
 
diff --git a/arch/blackfin/mach-bf527/boards/ezkit.c b/arch/blackfin/mach-bf527/boards/ezkit.c
index 1795aab79064..337515fba612 100644
--- a/arch/blackfin/mach-bf527/boards/ezkit.c
+++ b/arch/blackfin/mach-bf527/boards/ezkit.c
@@ -41,7 +41,9 @@
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/usb/sl811.h>
+#if defined(CONFIG_USB_MUSB_HDRC) || defined(CONFIG_USB_MUSB_HDRC_MODULE)
 #include <linux/usb/musb.h>
+#endif
 #include <asm/cplb.h>
 #include <asm/dma.h>
 #include <asm/bfin5xx_spi.h>
@@ -517,6 +519,14 @@ static struct bfin5xx_spi_chip spi_wm8731_chip_info = {
         .bits_per_word = 16,
 };
 #endif
+
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+static struct bfin5xx_spi_chip spidev_chip_info = {
+        .enable_dma = 0,
+        .bits_per_word = 8,
+};
+#endif
+
 static struct spi_board_info bfin_spi_board_info[] __initdata = {
 #if defined(CONFIG_MTD_M25P80) \
         || defined(CONFIG_MTD_M25P80_MODULE)
@@ -634,6 +644,15 @@ static struct spi_board_info bfin_spi_board_info[] __initdata = {
                 .mode = SPI_MODE_0,
         },
 #endif
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+        {
+                .modalias = "spidev",
+                .max_speed_hz = 3125000,     /* max spi clock (SCK) speed in HZ */
+                .bus_num = 0,
+                .chip_select = 1,
+                .controller_data = &spidev_chip_info,
+        },
+#endif
 };
 
 /* SPI controller data */
diff --git a/arch/blackfin/mach-bf533/boards/ezkit.c b/arch/blackfin/mach-bf533/boards/ezkit.c
index 4026c2f3ab4e..2b09aa39f565 100644
--- a/arch/blackfin/mach-bf533/boards/ezkit.c
+++ b/arch/blackfin/mach-bf533/boards/ezkit.c
@@ -34,7 +34,9 @@
 #include <linux/mtd/partitions.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/flash.h>
+#if defined(CONFIG_USB_ISP1362_HCD) || defined(CONFIG_USB_ISP1362_HCD_MODULE)
 #include <linux/usb/isp1362.h>
+#endif
 #include <linux/ata_platform.h>
 #include <linux/irq.h>
 #include <asm/dma.h>
@@ -134,6 +136,13 @@ static struct bfin5xx_spi_chip ad1836_spi_chip_info = {
 };
 #endif
 
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+static struct bfin5xx_spi_chip spidev_chip_info = {
+        .enable_dma = 0,
+        .bits_per_word = 8,
+};
+#endif
+
 static struct spi_board_info bfin_spi_board_info[] __initdata = {
 #if defined(CONFIG_MTD_M25P80) || defined(CONFIG_MTD_M25P80_MODULE)
         {
@@ -168,6 +177,15 @@ static struct spi_board_info bfin_spi_board_info[] __initdata = {
                 .controller_data = &ad1836_spi_chip_info,
         },
 #endif
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+        {
+                .modalias = "spidev",
+                .max_speed_hz = 3125000,     /* max spi clock (SCK) speed in HZ */
+                .bus_num = 0,
+                .chip_select = 1,
+                .controller_data = &spidev_chip_info,
+        },
+#endif
 };
 
 /* SPI (0) */
diff --git a/arch/blackfin/mach-bf533/boards/stamp.c b/arch/blackfin/mach-bf533/boards/stamp.c
index 0185350feacc..a645f6fd091b 100644
--- a/arch/blackfin/mach-bf533/boards/stamp.c
+++ b/arch/blackfin/mach-bf533/boards/stamp.c
@@ -226,6 +226,13 @@ static struct bfin5xx_spi_chip spi_mmc_chip_info = {
 };
 #endif
 
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+static struct bfin5xx_spi_chip spidev_chip_info = {
+        .enable_dma = 0,
+        .bits_per_word = 8,
+};
+#endif
+
 static struct spi_board_info bfin_spi_board_info[] __initdata = {
 #if defined(CONFIG_MTD_M25P80) || defined(CONFIG_MTD_M25P80_MODULE)
         {
@@ -312,6 +319,15 @@ static struct spi_board_info bfin_spi_board_info[] __initdata = {
                 .mode = SPI_MODE_2,
         },
 #endif
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+        {
+                .modalias = "spidev",
+                .max_speed_hz = 3125000,     /* max spi clock (SCK) speed in HZ */
+                .bus_num = 0,
+                .chip_select = 1,
+                .controller_data = &spidev_chip_info,
+        },
+#endif
 };
 
 /* SPI (0) */
@@ -423,9 +439,9 @@ static struct platform_device bfin_pata_device = {
 #include <linux/gpio_keys.h>
 
 static struct gpio_keys_button bfin_gpio_keys_table[] = {
-        {BTN_0, GPIO_PF5, 1, "gpio-keys: BTN0"},
-        {BTN_1, GPIO_PF6, 1, "gpio-keys: BTN1"},
-        {BTN_2, GPIO_PF8, 1, "gpio-keys: BTN2"},
+        {BTN_0, GPIO_PF5, 0, "gpio-keys: BTN0"},
+        {BTN_1, GPIO_PF6, 0, "gpio-keys: BTN1"},
+        {BTN_2, GPIO_PF8, 0, "gpio-keys: BTN2"},
 };
 
 static struct gpio_keys_platform_data bfin_gpio_keys_data = {
diff --git a/arch/blackfin/mach-bf537/boards/stamp.c b/arch/blackfin/mach-bf537/boards/stamp.c
index 119e6ea83384..9e2277e0d25c 100644
--- a/arch/blackfin/mach-bf537/boards/stamp.c
+++ b/arch/blackfin/mach-bf537/boards/stamp.c
@@ -487,6 +487,13 @@ static const struct ad7877_platform_data bfin_ad7877_ts_info = {
 };
 #endif
 
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+static struct bfin5xx_spi_chip spidev_chip_info = {
+        .enable_dma = 0,
+        .bits_per_word = 8,
+};
+#endif
+
 static struct spi_board_info bfin_spi_board_info[] __initdata = {
 #if defined(CONFIG_MTD_M25P80) \
         || defined(CONFIG_MTD_M25P80_MODULE)
@@ -593,6 +600,15 @@ static struct spi_board_info bfin_spi_board_info[] __initdata = {
                 .controller_data = &spi_ad7877_chip_info,
         },
 #endif
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+        {
+                .modalias = "spidev",
+                .max_speed_hz = 3125000,     /* max spi clock (SCK) speed in HZ */
+                .bus_num = 0,
+                .chip_select = 1,
+                .controller_data = &spidev_chip_info,
+        },
+#endif
 };
 
 /* SPI controller data */
diff --git a/arch/blackfin/mach-bf548/boards/ezkit.c b/arch/blackfin/mach-bf548/boards/ezkit.c
index 14860f04d1bd..916e963e83ba 100644
--- a/arch/blackfin/mach-bf548/boards/ezkit.c
+++ b/arch/blackfin/mach-bf548/boards/ezkit.c
@@ -37,7 +37,9 @@
 #include <linux/spi/flash.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
+#if defined(CONFIG_USB_MUSB_HDRC) || defined(CONFIG_USB_MUSB_HDRC_MODULE)
 #include <linux/usb/musb.h>
+#endif
 #include <asm/bfin5xx_spi.h>
 #include <asm/cplb.h>
 #include <asm/dma.h>
@@ -420,6 +422,13 @@ static const struct ad7877_platform_data bfin_ad7877_ts_info = {
 };
 #endif
 
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+static struct bfin5xx_spi_chip spidev_chip_info = {
+        .enable_dma = 0,
+        .bits_per_word = 8,
+};
+#endif
+
 static struct spi_board_info bf54x_spi_board_info[] __initdata = {
 #if defined(CONFIG_MTD_M25P80) \
         || defined(CONFIG_MTD_M25P80_MODULE)
@@ -445,6 +454,15 @@ static struct spi_board_info bf54x_spi_board_info[] __initdata = {
         .controller_data = &spi_ad7877_chip_info,
 },
 #endif
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+        {
+                .modalias = "spidev",
+                .max_speed_hz = 3125000,     /* max spi clock (SCK) speed in HZ */
+                .bus_num = 0,
+                .chip_select = 1,
+                .controller_data = &spidev_chip_info,
+        },
+#endif
 };
 
 /* SPI (0) */
@@ -631,7 +649,7 @@ static struct platform_device *ezkit_devices[] __initdata = {
         &ezkit_flash_device,
 };
 
-static int __init stamp_init(void)
+static int __init ezkit_init(void)
 {
         printk(KERN_INFO "%s(): registering device resources\n", __FUNCTION__);
         platform_add_devices(ezkit_devices, ARRAY_SIZE(ezkit_devices));
@@ -644,4 +662,4 @@ static int __init stamp_init(void)
         return 0;
 }
 
-arch_initcall(stamp_init);
+arch_initcall(ezkit_init);
diff --git a/arch/blackfin/mach-bf548/dma.c b/arch/blackfin/mach-bf548/dma.c
index 957bf1366eff..374803a8d2e8 100644
--- a/arch/blackfin/mach-bf548/dma.c
+++ b/arch/blackfin/mach-bf548/dma.c
@@ -1,5 +1,5 @@
 /*
- * File:         arch/blackfin/mach-bf561/dma.c
+ * File:         arch/blackfin/mach-bf548/dma.c
  * Based on:
  * Author:
  *
@@ -7,7 +7,7 @@
  * Description:  This file contains the simple DMA Implementation for Blackfin
  *
  * Modified:
- *               Copyright 2004-2007 Analog Devices Inc.
+ *               Copyright 2004-2008 Analog Devices Inc.
  *
  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
  *
diff --git a/arch/blackfin/mach-bf561/boards/ezkit.c b/arch/blackfin/mach-bf561/boards/ezkit.c
index ed863ce9a2d8..43c1b0982819 100644
--- a/arch/blackfin/mach-bf561/boards/ezkit.c
+++ b/arch/blackfin/mach-bf561/boards/ezkit.c
@@ -92,6 +92,68 @@ void __exit bfin_isp1761_exit(void)
 arch_initcall(bfin_isp1761_init);
 #endif
 
+#if defined(CONFIG_USB_ISP1362_HCD) || defined(CONFIG_USB_ISP1362_HCD_MODULE)
+#include <linux/usb/isp1362.h>
+
+static struct resource isp1362_hcd_resources[] = {
+        {
+                .start = 0x2c060000,
+                .end = 0x2c060000,
+                .flags = IORESOURCE_MEM,
+        }, {
+                .start = 0x2c060004,
+                .end = 0x2c060004,
+                .flags = IORESOURCE_MEM,
+        }, {
+                .start = IRQ_PF8,
+                .end = IRQ_PF8,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct isp1362_platform_data isp1362_priv = {
+        .sel15Kres = 1,
+        .clknotstop = 0,
+        .oc_enable = 0,
+        .int_act_high = 0,
+        .int_edge_triggered = 0,
+        .remote_wakeup_connected = 0,
+        .no_power_switching = 1,
+        .power_switching_mode = 0,
+};
+
+static struct platform_device isp1362_hcd_device = {
+        .name = "isp1362-hcd",
+        .id = 0,
+        .dev = {
+                .platform_data = &isp1362_priv,
+        },
+        .num_resources = ARRAY_SIZE(isp1362_hcd_resources),
+        .resource = isp1362_hcd_resources,
+};
+#endif
+
+#if defined(CONFIG_USB_NET2272) || defined(CONFIG_USB_NET2272_MODULE)
+static struct resource net2272_bfin_resources[] = {
+        {
+                .start = 0x2C000000,
+                .end = 0x2C000000 + 0x7F,
+                .flags = IORESOURCE_MEM,
+        }, {
+                .start = IRQ_PF10,
+                .end = IRQ_PF10,
+                .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
+        },
+};
+
+static struct platform_device net2272_bfin_device = {
+        .name = "net2272",
+        .id = -1,
+        .num_resources = ARRAY_SIZE(net2272_bfin_resources),
+        .resource = net2272_bfin_resources,
+};
+#endif
+
 /*
  *  USB-LAN EzExtender board
  *  Driver needs to know address, irq and flag pin.
@@ -204,6 +266,13 @@ static struct bfin5xx_spi_chip ad1836_spi_chip_info = {
         .bits_per_word = 16,
 };
 #endif
+
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+static struct bfin5xx_spi_chip spidev_chip_info = {
+        .enable_dma = 0,
+        .bits_per_word = 8,
+};
+#endif
 #endif
 
 /* SPI (0) */
@@ -248,6 +317,15 @@ static struct spi_board_info bfin_spi_board_info[] __initdata = {
                 .controller_data = &ad1836_spi_chip_info,
         },
 #endif
+#if defined(CONFIG_SPI_SPIDEV) || defined(CONFIG_SPI_SPIDEV_MODULE)
+        {
+                .modalias = "spidev",
+                .max_speed_hz = 3125000,     /* max spi clock (SCK) speed in HZ */
+                .bus_num = 0,
+                .chip_select = 1,
+                .controller_data = &spidev_chip_info,
+        },
+#endif
 };
 
 #if defined(CONFIG_PATA_PLATFORM) || defined(CONFIG_PATA_PLATFORM_MODULE)
@@ -340,6 +418,10 @@ static struct platform_device *ezkit_devices[] __initdata = {
         &ax88180_device,
 #endif
 
+#if defined(CONFIG_USB_NET2272) || defined(CONFIG_USB_NET2272_MODULE)
+        &net2272_bfin_device,
+#endif
+
 #if defined(CONFIG_SPI_BFIN) || defined(CONFIG_SPI_BFIN_MODULE)
         &bfin_spi0_device,
 #endif
@@ -359,6 +441,11 @@ static struct platform_device *ezkit_devices[] __initdata = {
 #if defined(CONFIG_I2C_GPIO) || defined(CONFIG_I2C_GPIO_MODULE)
         &i2c_gpio_device,
 #endif
+
+#if defined(CONFIG_USB_ISP1362_HCD) || defined(CONFIG_USB_ISP1362_HCD_MODULE)
+        &isp1362_hcd_device,
+#endif
+
         &ezkit_flash_device,
 };
 
diff --git a/arch/blackfin/mach-common/Makefile b/arch/blackfin/mach-common/Makefile
index 8636d4284bdb..15e33ca1ce80 100644
--- a/arch/blackfin/mach-common/Makefile
+++ b/arch/blackfin/mach-common/Makefile
@@ -4,8 +4,6 @@
 
 obj-y := \
         cache.o cacheinit.o entry.o \
-        interrupt.o lock.o irqpanic.o arch_checks.o
+        interrupt.o lock.o irqpanic.o arch_checks.o ints-priority.o
 
-obj-$(CONFIG_BFIN_SINGLE_CORE)   += ints-priority-sc.o
-obj-$(CONFIG_BFIN_DUAL_CORE)     += ints-priority-dc.o
 obj-$(CONFIG_PM)                 += pm.o dpmc.o
diff --git a/arch/blackfin/mach-common/dpmc.S b/arch/blackfin/mach-common/dpmc.S
index b82c096e1980..b80ddd8b232d 100644
--- a/arch/blackfin/mach-common/dpmc.S
+++ b/arch/blackfin/mach-common/dpmc.S
@@ -191,6 +191,9 @@ ENTRY(_sleep_mode)
         call _test_pll_locked;
 
         R0 = IWR_ENABLE(0);
+        R1 = IWR_DISABLE_ALL;
+        R2 = IWR_DISABLE_ALL;
+
         call _set_sic_iwr;
 
         P0.H = hi(PLL_CTL);
@@ -237,6 +240,10 @@ ENTRY(_deep_sleep)
 
         CLI R4;
 
+        R0 = IWR_ENABLE(0);
+        R1 = IWR_DISABLE_ALL;
+        R2 = IWR_DISABLE_ALL;
+
         call _set_sic_iwr;
 
         call _set_dram_srfs;
@@ -261,6 +268,9 @@ ENTRY(_deep_sleep)
         call _test_pll_locked;
 
         R0 = IWR_ENABLE(0);
+        R1 = IWR_DISABLE_ALL;
+        R2 = IWR_DISABLE_ALL;
+
         call _set_sic_iwr;
 
         P0.H = hi(PLL_CTL);
@@ -286,7 +296,13 @@ ENTRY(_sleep_deeper)
         CLI R4;
 
         P3 = R0;
+        P4 = R1;
+        P5 = R2;
+
         R0 = IWR_ENABLE(0);
+        R1 = IWR_DISABLE_ALL;
+        R2 = IWR_DISABLE_ALL;
+
         call _set_sic_iwr;
         call _set_dram_srfs;    /* Set SDRAM Self Refresh */
 
@@ -327,6 +343,8 @@ ENTRY(_sleep_deeper)
         call _test_pll_locked;
 
         R0 = P3;
+        R1 = P4;
+        R3 = P5;
         call _set_sic_iwr;      /* Set Awake from IDLE */
 
         P0.H = hi(PLL_CTL);
@@ -340,6 +358,9 @@ ENTRY(_sleep_deeper)
         call _test_pll_locked;
 
         R0 = IWR_ENABLE(0);
+        R1 = IWR_DISABLE_ALL;
+        R2 = IWR_DISABLE_ALL;
+
         call _set_sic_iwr;      /* Set Awake from IDLE PLL */
 
         P0.H = hi(VR_CTL);
@@ -417,14 +438,23 @@ ENTRY(_unset_dram_srfs)
         RTS;
 
 ENTRY(_set_sic_iwr)
-#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)
+#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)  || defined(CONFIG_BF561)
         P0.H = hi(SIC_IWR0);
         P0.L = lo(SIC_IWR0);
+        P1.H = hi(SIC_IWR1);
+        P1.L = lo(SIC_IWR1);
+        [P1] = R1;
+#if defined(CONFIG_BF54x)
+        P1.H = hi(SIC_IWR2);
+        P1.L = lo(SIC_IWR2);
+        [P1] = R2;
+#endif
 #else
         P0.H = hi(SIC_IWR);
         P0.L = lo(SIC_IWR);
 #endif
         [P0] = R0;
+
         SSYNC;
         RTS;
 
diff --git a/arch/blackfin/mach-common/entry.S b/arch/blackfin/mach-common/entry.S
index fdd9bf43361e..2cbb7a0bc38e 100644
--- a/arch/blackfin/mach-common/entry.S
+++ b/arch/blackfin/mach-common/entry.S
@@ -121,6 +121,7 @@ ENTRY(_ex_icplb_miss)
         (R7:6,P5:4) = [sp++];
         ASTAT = [sp++];
         SAVE_ALL_SYS
+        DEBUG_HWTRACE_SAVE(p5, r7)
 #ifdef CONFIG_MPU
         R0 = SEQSTAT;
         R1 = SP;
@@ -132,14 +133,13 @@ ENTRY(_ex_icplb_miss)
 #else
         call __cplb_hdr;
 #endif
-        DEBUG_START_HWTRACE(p5, r7)
+        DEBUG_HWTRACE_RESTORE(p5, r7)
         RESTORE_ALL_SYS
         SP = EX_SCRATCH_REG;
         rtx;
 ENDPROC(_ex_icplb_miss)
 
 ENTRY(_ex_syscall)
-        DEBUG_START_HWTRACE(p5, r7)
         (R7:6,P5:4) = [sp++];
         ASTAT = [sp++];
         raise 15;               /* invoked by TRAP #0, for sys call */
@@ -178,7 +178,6 @@ ENTRY(_ex_single_step)
 ENDPROC(_ex_single_step)
 
 ENTRY(_bfin_return_from_exception)
-        DEBUG_START_HWTRACE(p5, r7)
 #if ANOMALY_05000257
         R7=LC0;
         LC0=R7;
@@ -200,10 +199,9 @@ ENTRY(_handle_bad_cplb)
          * need to make a CPLB exception look like a normal exception
          */
 
-        DEBUG_START_HWTRACE(p5, r7)
         RESTORE_ALL_SYS
         [--sp] = ASTAT;
-        [--sp] = (R7:6, P5:4);
+        [--sp] = (R7:6,P5:4);
 
 ENTRY(_ex_replaceable)
         nop;
@@ -253,7 +251,6 @@ ENTRY(_ex_trap_c)
         R6 = SEQSTAT;
         [P5] = R6;
 
-        DEBUG_START_HWTRACE(p5, r7)
         (R7:6,P5:4) = [sp++];
         ASTAT = [sp++];
         SP = EX_SCRATCH_REG;
@@ -382,8 +379,7 @@ ENTRY(_trap) /* Exception: 4th entry into system event table(supervisor mode)*/
         sp.h = _exception_stack_top;
         /* Try to deal with syscalls quickly.  */
         [--sp] = ASTAT;
-        [--sp] = (R7:6, P5:4);
-        DEBUG_STOP_HWTRACE(p5, r7)
+        [--sp] = (R7:6,P5:4);
         r7 = SEQSTAT;           /* reason code is in bit 5:0 */
         r6.l = lo(SEQSTAT_EXCAUSE);
         r6.h = hi(SEQSTAT_EXCAUSE);
diff --git a/arch/blackfin/mach-common/ints-priority-dc.c b/arch/blackfin/mach-common/ints-priority-dc.c
deleted file mode 100644
index 8d18d6b163bb..000000000000
--- a/arch/blackfin/mach-common/ints-priority-dc.c
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- * File:         arch/blackfin/mach-common/ints-priority-dc.c
- * Based on:
- * Author:
- *
- * Created:      ?
- * Description:  Set up the interrupt priorities
- *
- * Modified:
- *               1996 Roman Zippel
- *               1999 D. Jeff Dionne <jeff@uclinux.org>
- *               2000-2001 Lineo, Inc. D. Jefff Dionne <jeff@lineo.ca>
- *               2002 Arcturus Networks Inc. MaTed <mated@sympatico.ca>
- *               2003 Metrowerks/Motorola
- *               2003 Bas Vermeulen <bas@buyways.nl>
- *               Copyright 2004-2006 Analog Devices Inc.
- *
- * Bugs:         Enter bugs at http://blackfin.uclinux.org/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see the file COPYING, or write
- * to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include <linux/module.h>
-#include <linux/kernel_stat.h>
-#include <linux/seq_file.h>
-#include <linux/irq.h>
-#ifdef CONFIG_KGDB
-#include <linux/kgdb.h>
-#endif
-#include <asm/traps.h>
-#include <asm/blackfin.h>
-#include <asm/gpio.h>
-#include <asm/irq_handler.h>
-
-/*
- * NOTES:
- * - we have separated the physical Hardware interrupt from the
- * levels that the LINUX kernel sees (see the description in irq.h)
- * -
- */
-
-/* Initialize this to an actual value to force it into the .data
- * section so that we know it is properly initialized at entry into
- * the kernel but before bss is initialized to zero (which is where
- * it would live otherwise).  The 0x1f magic represents the IRQs we
- * cannot actually mask out in hardware.
- */
-unsigned long irq_flags = 0x1f;
-
-/* The number of spurious interrupts */
-atomic_t num_spurious;
-
-struct ivgx {
-        /* irq number for request_irq, available in mach-bf561/irq.h */
-        int irqno;
-        /* corresponding bit in the SICA_ISR0 register */
-        int isrflag0;
-        /* corresponding bit in the SICA_ISR1 register */
-        int isrflag1;
-} ivg_table[NR_PERI_INTS];
-
-struct ivg_slice {
-        /* position of first irq in ivg_table for given ivg */
-        struct ivgx *ifirst;
-        struct ivgx *istop;
-} ivg7_13[IVG13 - IVG7 + 1];
-
-static void search_IAR(void);
-
-/*
- * Search SIC_IAR and fill tables with the irqvalues
- * and their positions in the SIC_ISR register.
- */
-static void __init search_IAR(void)
-{
-        unsigned ivg, irq_pos = 0;
-        for (ivg = 0; ivg <= IVG13 - IVG7; ivg++) {
-                int irqn;
-
-                ivg7_13[ivg].istop = ivg7_13[ivg].ifirst = &ivg_table[irq_pos];
-
-                for (irqn = 0; irqn < NR_PERI_INTS; irqn++) {
-                        int iar_shift = (irqn & 7) * 4;
-                        if (ivg ==
-                            (0xf &
-                             bfin_read32((unsigned long *)SICA_IAR0 +
-                                         (irqn >> 3)) >> iar_shift)) {
-                                ivg_table[irq_pos].irqno = IVG7 + irqn;
-                                ivg_table[irq_pos].isrflag0 =
-                                    (irqn < 32 ? (1 << irqn) : 0);
-                                ivg_table[irq_pos].isrflag1 =
-                                    (irqn < 32 ? 0 : (1 << (irqn - 32)));
-                                ivg7_13[ivg].istop++;
-                                irq_pos++;
-                        }
-                }
-        }
-}
-
-/*
- * This is for BF561 internal IRQs
- */
-
-static void ack_noop(unsigned int irq)
-{
-        /* Dummy function.  */
-}
-
-static void bf561_core_mask_irq(unsigned int irq)
-{
-        irq_flags &= ~(1 << irq);
-        if (!irqs_disabled())
-                local_irq_enable();
-}
-
-static void bf561_core_unmask_irq(unsigned int irq)
-{
-        irq_flags |= 1 << irq;
-        /*
-         * If interrupts are enabled, IMASK must contain the same value
-         * as irq_flags.  Make sure that invariant holds.  If interrupts
-         * are currently disabled we need not do anything; one of the
-         * callers will take care of setting IMASK to the proper value
-         * when reenabling interrupts.
-         * local_irq_enable just does "STI irq_flags", so it's exactly
-         * what we need.
-         */
-        if (!irqs_disabled())
-                local_irq_enable();
-        return;
-}
-
-static void bf561_internal_mask_irq(unsigned int irq)
-{
-        unsigned long irq_mask;
-        if ((irq - (IRQ_CORETMR + 1)) < 32) {
-                irq_mask = (1 << (irq - (IRQ_CORETMR + 1)));
-                bfin_write_SICA_IMASK0(bfin_read_SICA_IMASK0() & ~irq_mask);
-        } else {
-                irq_mask = (1 << (irq - (IRQ_CORETMR + 1) - 32));
-                bfin_write_SICA_IMASK1(bfin_read_SICA_IMASK1() & ~irq_mask);
-        }
-}
-
-static void bf561_internal_unmask_irq(unsigned int irq)
-{
-        unsigned long irq_mask;
-
-        if ((irq - (IRQ_CORETMR + 1)) < 32) {
-                irq_mask = (1 << (irq - (IRQ_CORETMR + 1)));
-                bfin_write_SICA_IMASK0(bfin_read_SICA_IMASK0() | irq_mask);
-        } else {
-                irq_mask = (1 << (irq - (IRQ_CORETMR + 1) - 32));
-                bfin_write_SICA_IMASK1(bfin_read_SICA_IMASK1() | irq_mask);
-        }
-        SSYNC();
-}
-
-static struct irq_chip bf561_core_irqchip = {
-        .ack = ack_noop,
-        .mask = bf561_core_mask_irq,
-        .unmask = bf561_core_unmask_irq,
-};
-
-static struct irq_chip bf561_internal_irqchip = {
-        .ack = ack_noop,
-        .mask = bf561_internal_mask_irq,
-        .unmask = bf561_internal_unmask_irq,
-};
-
-static unsigned short gpio_enabled[gpio_bank(MAX_BLACKFIN_GPIOS)];
-static unsigned short gpio_edge_triggered[gpio_bank(MAX_BLACKFIN_GPIOS)];
-
-static void bf561_gpio_ack_irq(unsigned int irq)
-{
-        u16 gpionr = irq - IRQ_PF0;
-
-        if (gpio_edge_triggered[gpio_bank(gpionr)] & gpio_bit(gpionr)) {
-                set_gpio_data(gpionr, 0);
-                SSYNC();
-        }
-}
-
-static void bf561_gpio_mask_ack_irq(unsigned int irq)
-{
-        u16 gpionr = irq - IRQ_PF0;
-
-        if (gpio_edge_triggered[gpio_bank(gpionr)] & gpio_bit(gpionr)) {
-                set_gpio_data(gpionr, 0);
-                SSYNC();
-        }
-
-        set_gpio_maska(gpionr, 0);
-        SSYNC();
-}
-
-static void bf561_gpio_mask_irq(unsigned int irq)
-{
-        set_gpio_maska(irq - IRQ_PF0, 0);
-        SSYNC();
-}
-
-static void bf561_gpio_unmask_irq(unsigned int irq)
-{
-        set_gpio_maska(irq - IRQ_PF0, 1);
-        SSYNC();
-}
-
-static unsigned int bf561_gpio_irq_startup(unsigned int irq)
-{
-        unsigned int ret;
-        char buf[8];
-        u16 gpionr = irq - IRQ_PF0;
-
-        if (!(gpio_enabled[gpio_bank(gpionr)] & gpio_bit(gpionr))) {
-                snprintf(buf, sizeof buf, "IRQ %d", irq);
-                ret = gpio_request(gpionr, buf);
-                if (ret)
-                        return ret;
-
-        }
-
-        gpio_enabled[gpio_bank(gpionr)] |= gpio_bit(gpionr);
-        bf561_gpio_unmask_irq(irq);
-
-  return ret;
-
-}
-
-static void bf561_gpio_irq_shutdown(unsigned int irq)
-{
-        bf561_gpio_mask_irq(irq);
-        gpio_free(irq - IRQ_PF0);
-        gpio_enabled[gpio_bank(irq - IRQ_PF0)] &= ~gpio_bit(irq - IRQ_PF0);
-}
-
-static int bf561_gpio_irq_type(unsigned int irq, unsigned int type)
-{
-
-        unsigned int ret;
-        char buf[8];
-        u16 gpionr = irq - IRQ_PF0;
-
-
-                if (type == IRQ_TYPE_PROBE) {
-                        /* only probe unenabled GPIO interrupt lines */
-                        if (gpio_enabled[gpio_bank(gpionr)] & gpio_bit(gpionr))
-                                return 0;
-                        type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
-
-                }
-
-                if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING |
-                            IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) {
-
-                if (!(gpio_enabled[gpio_bank(gpionr)] & gpio_bit(gpionr))) {
-                        snprintf(buf, sizeof buf, "IRQ %d", irq);
-                        ret = gpio_request(gpionr, buf);
-                        if (ret)
-                                return ret;
-
-                }
-
-                        gpio_enabled[gpio_bank(gpionr)] |= gpio_bit(gpionr);
-                } else {
-                        gpio_enabled[gpio_bank(gpionr)] &= ~gpio_bit(gpionr);
-                        return 0;
-                }
-
-
-                set_gpio_dir(gpionr, 0);
-                set_gpio_inen(gpionr, 1);
-
-
-                if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
-                        gpio_edge_triggered[gpio_bank(gpionr)] |= gpio_bit(gpionr);
-                        set_gpio_edge(gpionr, 1);
-                } else {
-                        set_gpio_edge(gpionr, 0);
-                        gpio_edge_triggered[gpio_bank(gpionr)] &= ~gpio_bit(gpionr);
-                }
-
-                if ((type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
-                    == (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
-                        set_gpio_both(gpionr, 1);
-                else
-                        set_gpio_both(gpionr, 0);
-
-                if ((type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_LEVEL_LOW)))
-                        set_gpio_polar(gpionr, 1);      /* low or falling edge denoted by one */
-                else
-                        set_gpio_polar(gpionr, 0);      /* high or rising edge denoted by zero */
-
-        SSYNC();
-
-        if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
-                set_irq_handler(irq, handle_edge_irq);
-        else
-                set_irq_handler(irq, handle_level_irq);
-
-        return 0;
-}
-
-static struct irq_chip bf561_gpio_irqchip = {
-        .ack = bf561_gpio_ack_irq,
-        .mask = bf561_gpio_mask_irq,
-        .mask_ack = bf561_gpio_mask_ack_irq,
-        .unmask = bf561_gpio_unmask_irq,
-        .set_type = bf561_gpio_irq_type,
-        .startup = bf561_gpio_irq_startup,
-        .shutdown = bf561_gpio_irq_shutdown
-};
-
-static void bf561_demux_gpio_irq(unsigned int inta_irq,
-                                 struct irq_desc *intb_desc)
-{
-        int irq, flag_d, mask;
-        u16 gpio;
-
-        switch (inta_irq) {
-        case IRQ_PROG0_INTA:
-                irq = IRQ_PF0;
-                break;
-        case IRQ_PROG1_INTA:
-                irq = IRQ_PF16;
-                break;
-        case IRQ_PROG2_INTA:
-                irq = IRQ_PF32;
-                break;
-        default:
-                dump_stack();
-                return;
-        }
-
-        gpio = irq - IRQ_PF0;
-
-                flag_d = get_gpiop_data(gpio);
-                mask = flag_d & (gpio_enabled[gpio_bank(gpio)] &
-                              get_gpiop_maska(gpio));
-
-                        do {
-                                if (mask & 1) {
-                                        struct irq_desc *desc = irq_desc + irq;
-                                        desc->handle_irq(irq, desc);
-                                }
-                                irq++;
-                                mask >>= 1;
-                        } while (mask);
-
-
-}
-
-void __init init_exception_vectors(void)
-{
-        SSYNC();
-
-        /* cannot program in software:
-         * evt0 - emulation (jtag)
-         * evt1 - reset
-         */
-        bfin_write_EVT2(evt_nmi);
-        bfin_write_EVT3(trap);
-        bfin_write_EVT5(evt_ivhw);
-        bfin_write_EVT6(evt_timer);
-        bfin_write_EVT7(evt_evt7);
-        bfin_write_EVT8(evt_evt8);
-        bfin_write_EVT9(evt_evt9);
-        bfin_write_EVT10(evt_evt10);
-        bfin_write_EVT11(evt_evt11);
-        bfin_write_EVT12(evt_evt12);
-        bfin_write_EVT13(evt_evt13);
-        bfin_write_EVT14(evt14_softirq);
-        bfin_write_EVT15(evt_system_call);
-        CSYNC();
-}
-
-/*
- * This function should be called during kernel startup to initialize
- * the BFin IRQ handling routines.
- */
-int __init init_arch_irq(void)
-{
-        int irq;
-        unsigned long ilat = 0;
-        /*  Disable all the peripheral intrs  - page 4-29 HW Ref manual */
-        bfin_write_SICA_IMASK0(SIC_UNMASK_ALL);
-        bfin_write_SICA_IMASK1(SIC_UNMASK_ALL);
-        SSYNC();
-
-        bfin_write_SICA_IWR0(IWR_ENABLE_ALL);
-        bfin_write_SICA_IWR1(IWR_ENABLE_ALL);
-
-        local_irq_disable();
-
-        init_exception_buff();
-
-        for (irq = 0; irq <= SYS_IRQS; irq++) {
-                if (irq <= IRQ_CORETMR)
-                        set_irq_chip(irq, &bf561_core_irqchip);
-                else
-                        set_irq_chip(irq, &bf561_internal_irqchip);
-
-                if ((irq != IRQ_PROG0_INTA) &&
-                    (irq != IRQ_PROG1_INTA) &&
-                    (irq != IRQ_PROG2_INTA))
-                        set_irq_handler(irq, handle_simple_irq);
-                else
-                        set_irq_chained_handler(irq, bf561_demux_gpio_irq);
-        }
-
-        for (irq = IRQ_PF0; irq <= IRQ_PF47; irq++) {
-                set_irq_chip(irq, &bf561_gpio_irqchip);
-                /* if configured as edge, then will be changed to do_edge_IRQ */
-                set_irq_handler(irq, handle_level_irq);
-        }
-
-        bfin_write_IMASK(0);
-        CSYNC();
-        ilat = bfin_read_ILAT();
-        CSYNC();
-        bfin_write_ILAT(ilat);
-        CSYNC();
-
-        printk(KERN_INFO "Configuring Blackfin Priority Driven Interrupts\n");
-        /* IMASK=xxx is equivalent to STI xx or irq_flags=xx,
-         * local_irq_enable()
-         */
-        program_IAR();
-        /* Therefore it's better to setup IARs before interrupts enabled */
-        search_IAR();
-
-        /* Enable interrupts IVG7-15 */
-        irq_flags = irq_flags | IMASK_IVG15 |
-            IMASK_IVG14 | IMASK_IVG13 | IMASK_IVG12 | IMASK_IVG11 |
-            IMASK_IVG10 | IMASK_IVG9 | IMASK_IVG8 | IMASK_IVG7 | IMASK_IVGHW;
-
-        return 0;
-}
-
-#ifdef CONFIG_DO_IRQ_L1
-__attribute__((l1_text))
-#endif
-void do_irq(int vec, struct pt_regs *fp)
-{
-        if (vec == EVT_IVTMR_P) {
-                vec = IRQ_CORETMR;
-        } else {
-                struct ivgx *ivg = ivg7_13[vec - IVG7].ifirst;
-                struct ivgx *ivg_stop = ivg7_13[vec - IVG7].istop;
-                unsigned long sic_status0, sic_status1;
-
-                SSYNC();
-                sic_status0 = bfin_read_SICA_IMASK0() & bfin_read_SICA_ISR0();
-                sic_status1 = bfin_read_SICA_IMASK1() & bfin_read_SICA_ISR1();
-
-                for (;; ivg++) {
-                        if (ivg >= ivg_stop) {
-                                atomic_inc(&num_spurious);
-                                return;
-                        } else if ((sic_status0 & ivg->isrflag0) ||
-                                   (sic_status1 & ivg->isrflag1))
-                                break;
-                }
-                vec = ivg->irqno;
-        }
-        asm_do_IRQ(vec, fp);
-
-#ifdef CONFIG_KGDB
-        kgdb_process_breakpoint();
-#endif
-}
diff --git a/arch/blackfin/mach-common/ints-priority-sc.c b/arch/blackfin/mach-common/ints-priority.c
index dec42acb5de0..880595afe98d 100644
--- a/arch/blackfin/mach-common/ints-priority-sc.c
+++ b/arch/blackfin/mach-common/ints-priority.c
@@ -1,5 +1,5 @@
 /*
- * File:         arch/blackfin/mach-common/ints-priority-sc.c
+ * File:         arch/blackfin/mach-common/ints-priority.c
  * Based on:
  * Author:
  *
@@ -13,7 +13,7 @@
  *               2002 Arcturus Networks Inc. MaTed <mated@sympatico.ca>
  *               2003 Metrowerks/Motorola
  *               2003 Bas Vermeulen <bas@buyways.nl>
- *               Copyright 2004-2007 Analog Devices Inc.
+ *               Copyright 2004-2008 Analog Devices Inc.
  *
  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
  *
@@ -69,6 +69,10 @@ unsigned long irq_flags = 0x1f;
 /* The number of spurious interrupts */
 atomic_t num_spurious;
 
+#ifdef CONFIG_PM
+unsigned long bfin_sic_iwr[3];  /* Up to 3 SIC_IWRx registers */
+#endif
+
 struct ivgx {
         /* irq number for request_irq, available in mach-bf533/irq.h */
         unsigned int irqno;
@@ -98,8 +102,7 @@ static void __init search_IAR(void)
 
                 for (irqn = 0; irqn < NR_PERI_INTS; irqn++) {
                         int iar_shift = (irqn & 7) * 4;
-                                if (ivg ==
-                            (0xf &
+                                if (ivg == (0xf &
 #ifndef CONFIG_BF52x
                              bfin_read32((unsigned long *)SIC_IAR0 +
                                          (irqn >> 3)) >> iar_shift)) {
@@ -179,6 +182,27 @@ static void bfin_internal_unmask_irq(unsigned int irq)
         SSYNC();
 }
 
+#ifdef CONFIG_PM
+int bfin_internal_set_wake(unsigned int irq, unsigned int state)
+{
+        unsigned bank, bit;
+        unsigned long flags;
+        bank = (irq - (IRQ_CORETMR + 1)) / 32;
+        bit = (irq - (IRQ_CORETMR + 1)) % 32;
+
+        local_irq_save(flags);
+
+        if (state)
+                bfin_sic_iwr[bank] |= (1 << bit);
+        else
+                bfin_sic_iwr[bank] &= ~(1 << bit);
+
+        local_irq_restore(flags);
+
+        return 0;
+}
+#endif
+
 static struct irq_chip bfin_core_irqchip = {
         .ack = ack_noop,
         .mask = bfin_core_mask_irq,
@@ -189,6 +213,9 @@ static struct irq_chip bfin_internal_irqchip = {
         .ack = ack_noop,
         .mask = bfin_internal_mask_irq,
         .unmask = bfin_internal_unmask_irq,
+#ifdef CONFIG_PM
+        .set_wake = bfin_internal_set_wake,
+#endif
 };
 
 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
@@ -206,8 +233,7 @@ static void bfin_generic_error_mask_irq(unsigned int irq)
         if (!error_int_mask) {
                 local_irq_disable();
                 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() &
-                                     ~(1 <<
-                                       (IRQ_GENERIC_ERROR -
+                                     ~(1 << (IRQ_GENERIC_ERROR -
                                         (IRQ_CORETMR + 1))));
                 SSYNC();
                 local_irq_enable();
@@ -232,7 +258,7 @@ static struct irq_chip bfin_generic_error_irqchip = {
 };
 
 static void bfin_demux_error_irq(unsigned int int_err_irq,
-                                 struct irq_desc *intb_desc)
+                                 struct irq_desc *inta_desc)
 {
         int irq = 0;
 
@@ -404,16 +430,8 @@ static int bfin_gpio_irq_type(unsigned int irq, unsigned int type)
                 return 0;
         }
 
+        set_gpio_inen(gpionr, 0);
         set_gpio_dir(gpionr, 0);
-        set_gpio_inen(gpionr, 1);
-
-        if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
-                gpio_edge_triggered[gpio_bank(gpionr)] |= gpio_bit(gpionr);
-                set_gpio_edge(gpionr, 1);
-        } else {
-                set_gpio_edge(gpionr, 0);
-                gpio_edge_triggered[gpio_bank(gpionr)] &= ~gpio_bit(gpionr);
-        }
 
         if ((type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
             == (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
@@ -426,6 +444,18 @@ static int bfin_gpio_irq_type(unsigned int irq, unsigned int type)
         else
                 set_gpio_polar(gpionr, 0);      /* high or rising edge denoted by zero */
 
+        if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
+                set_gpio_edge(gpionr, 1);
+                set_gpio_inen(gpionr, 1);
+                gpio_edge_triggered[gpio_bank(gpionr)] |= gpio_bit(gpionr);
+                set_gpio_data(gpionr, 0);
+
+        } else {
+                set_gpio_edge(gpionr, 0);
+                gpio_edge_triggered[gpio_bank(gpionr)] &= ~gpio_bit(gpionr);
+                set_gpio_inen(gpionr, 1);
+        }
+
         SSYNC();
 
         if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
@@ -436,6 +466,20 @@ static int bfin_gpio_irq_type(unsigned int irq, unsigned int type)
         return 0;
 }
 
+#ifdef CONFIG_PM
+int bfin_gpio_set_wake(unsigned int irq, unsigned int state)
+{
+        unsigned gpio = irq_to_gpio(irq);
+
+        if (state)
+                gpio_pm_wakeup_request(gpio, PM_WAKE_IGNORE);
+        else
+                gpio_pm_wakeup_free(gpio);
+
+        return 0;
+}
+#endif
+
 static struct irq_chip bfin_gpio_irqchip = {
         .ack = bfin_gpio_ack_irq,
         .mask = bfin_gpio_mask_irq,
@@ -443,30 +487,87 @@ static struct irq_chip bfin_gpio_irqchip = {
         .unmask = bfin_gpio_unmask_irq,
         .set_type = bfin_gpio_irq_type,
         .startup = bfin_gpio_irq_startup,
-        .shutdown = bfin_gpio_irq_shutdown
+        .shutdown = bfin_gpio_irq_shutdown,
+#ifdef CONFIG_PM
+        .set_wake = bfin_gpio_set_wake,
+#endif
 };
 
-static void bfin_demux_gpio_irq(unsigned int intb_irq,
-                                struct irq_desc *intb_desc)
+static void bfin_demux_gpio_irq(unsigned int inta_irq,
+                                struct irq_desc *desc)
 {
-        u16 i;
-        struct irq_desc *desc;
+        unsigned int i, gpio, mask, irq, search = 0;
 
-        for (i = 0; i < MAX_BLACKFIN_GPIOS; i += 16) {
-                int irq = IRQ_PF0 + i;
-                int flag_d = get_gpiop_data(i);
-                int mask =
-                    flag_d & (gpio_enabled[gpio_bank(i)] & get_gpiop_maska(i));
+        switch (inta_irq) {
+#if defined(CONFIG_BF53x)
+        case IRQ_PROG_INTA:
+                irq = IRQ_PF0;
+                search = 1;
+                break;
+# if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
+        case IRQ_MAC_RX:
+                irq = IRQ_PH0;
+                break;
+# endif
+#elif defined(CONFIG_BF52x)
+        case IRQ_PORTF_INTA:
+                irq = IRQ_PF0;
+                break;
+        case IRQ_PORTG_INTA:
+                irq = IRQ_PG0;
+                break;
+        case IRQ_PORTH_INTA:
+                irq = IRQ_PH0;
+                break;
+#elif defined(CONFIG_BF561)
+        case IRQ_PROG0_INTA:
+                irq = IRQ_PF0;
+                break;
+        case IRQ_PROG1_INTA:
+                irq = IRQ_PF16;
+                break;
+        case IRQ_PROG2_INTA:
+                irq = IRQ_PF32;
+                break;
+#endif
+        default:
+                BUG();
+                return;
+        }
 
-                while (mask) {
-                        if (mask & 1) {
-                                desc = irq_desc + irq;
-                                desc->handle_irq(irq, desc);
+        if (search) {
+                for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
+                        irq += i;
+
+                        mask = get_gpiop_data(i) &
+                                (gpio_enabled[gpio_bank(i)] &
+                                get_gpiop_maska(i));
+
+                        while (mask) {
+                                if (mask & 1) {
+                                        desc = irq_desc + irq;
+                                        desc->handle_irq(irq, desc);
+                                }
+                                irq++;
+                                mask >>= 1;
                         }
-                        irq++;
-                        mask >>= 1;
                 }
+        } else {
+                        gpio = irq_to_gpio(irq);
+                        mask = get_gpiop_data(gpio) &
+                                (gpio_enabled[gpio_bank(gpio)] &
+                                get_gpiop_maska(gpio));
+
+                        do {
+                                if (mask & 1) {
+                                        desc = irq_desc + irq;
+                                        desc->handle_irq(irq, desc);
+                                }
+                                irq++;
+                                mask >>= 1;
+                        } while (mask);
         }
+
 }
 
 #else                           /* CONFIG_BF54x */
@@ -711,6 +812,74 @@ static int bfin_gpio_irq_type(unsigned int irq, unsigned int type)
         return 0;
 }
 
+#ifdef CONFIG_PM
+u32 pint_saved_masks[NR_PINT_SYS_IRQS];
+u32 pint_wakeup_masks[NR_PINT_SYS_IRQS];
+
+int bfin_gpio_set_wake(unsigned int irq, unsigned int state)
+{
+        u32 pint_irq;
+        u8 pint_val = irq2pint_lut[irq - SYS_IRQS];
+        u32 bank = PINT_2_BANK(pint_val);
+        u32 pintbit = PINT_BIT(pint_val);
+
+        switch (bank) {
+        case 0:
+                pint_irq = IRQ_PINT0;
+                break;
+        case 2:
+                pint_irq = IRQ_PINT2;
+                break;
+        case 3:
+                pint_irq = IRQ_PINT3;
+                break;
+        case 1:
+                pint_irq = IRQ_PINT1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        bfin_internal_set_wake(pint_irq, state);
+
+        if (state)
+                pint_wakeup_masks[bank] |= pintbit;
+        else
+                pint_wakeup_masks[bank] &= ~pintbit;
+
+        return 0;
+}
+
+u32 bfin_pm_setup(void)
+{
+        u32 val, i;
+
+        for (i = 0; i < NR_PINT_SYS_IRQS; i++) {
+                val = pint[i]->mask_clear;
+                pint_saved_masks[i] = val;
+                if (val ^ pint_wakeup_masks[i]) {
+                        pint[i]->mask_clear = val;
+                        pint[i]->mask_set = pint_wakeup_masks[i];
+                }
+        }
+
+        return 0;
+}
+
+void bfin_pm_restore(void)
+{
+        u32 i, val;
+
+        for (i = 0; i < NR_PINT_SYS_IRQS; i++) {
+                val = pint_saved_masks[i];
+                if (val ^ pint_wakeup_masks[i]) {
+                        pint[i]->mask_clear = pint[i]->mask_clear;
+                        pint[i]->mask_set = val;
+                }
+        }
+}
+#endif
+
 static struct irq_chip bfin_gpio_irqchip = {
         .ack = bfin_gpio_ack_irq,
         .mask = bfin_gpio_mask_irq,
@@ -718,17 +887,19 @@ static struct irq_chip bfin_gpio_irqchip = {
         .unmask = bfin_gpio_unmask_irq,
         .set_type = bfin_gpio_irq_type,
         .startup = bfin_gpio_irq_startup,
-        .shutdown = bfin_gpio_irq_shutdown
+        .shutdown = bfin_gpio_irq_shutdown,
+#ifdef CONFIG_PM
+        .set_wake = bfin_gpio_set_wake,
+#endif
 };
 
-static void bfin_demux_gpio_irq(unsigned int intb_irq,
-                                struct irq_desc *intb_desc)
+static void bfin_demux_gpio_irq(unsigned int inta_irq,
+                                struct irq_desc *desc)
 {
         u8 bank, pint_val;
         u32 request, irq;
-        struct irq_desc *desc;
 
-        switch (intb_irq) {
+        switch (inta_irq) {
         case IRQ_PINT0:
                 bank = 0;
                 break;
@@ -795,7 +966,7 @@ int __init init_arch_irq(void)
         int irq;
         unsigned long ilat = 0;
         /*  Disable all the peripheral intrs  - page 4-29 HW Ref manual */
-#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)
+#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561)
         bfin_write_SIC_IMASK0(SIC_UNMASK_ALL);
         bfin_write_SIC_IMASK1(SIC_UNMASK_ALL);
         bfin_write_SIC_IWR0(IWR_ENABLE_ALL);
@@ -812,6 +983,8 @@ int __init init_arch_irq(void)
 
         local_irq_disable();
 
+        init_exception_buff();
+
 #ifdef CONFIG_BF54x
 # ifdef CONFIG_PINTx_REASSIGN
         pint[0]->assign = CONFIG_PINT0_ASSIGN;
@@ -874,6 +1047,19 @@ int __init init_arch_irq(void)
                                 set_irq_chained_handler(irq,
                                                         bfin_demux_gpio_irq);
                                 break;
+#elif defined(CONFIG_BF561)
+                        case IRQ_PROG0_INTA:
+                                set_irq_chained_handler(irq,
+                                                        bfin_demux_gpio_irq);
+                                break;
+                        case IRQ_PROG1_INTA:
+                                set_irq_chained_handler(irq,
+                                                        bfin_demux_gpio_irq);
+                                break;
+                        case IRQ_PROG2_INTA:
+                                set_irq_chained_handler(irq,
+                                                        bfin_demux_gpio_irq);
+                                break;
 #endif
                         default:
                                 set_irq_handler(irq, handle_simple_irq);
@@ -893,11 +1079,8 @@ int __init init_arch_irq(void)
         }
 #endif
 
-#ifndef CONFIG_BF54x
-        for (irq = IRQ_PF0; irq < NR_IRQS; irq++) {
-#else
-        for (irq = IRQ_PA0; irq < NR_IRQS; irq++) {
-#endif
+        for (irq = GPIO_IRQ_BASE; irq < NR_IRQS; irq++) {
+
                 set_irq_chip(irq, &bfin_gpio_irqchip);
                 /* if configured as edge, then will be changed to do_edge_IRQ */
                 set_irq_handler(irq, handle_level_irq);
@@ -936,7 +1119,7 @@ void do_irq(int vec, struct pt_regs *fp)
         } else {
                 struct ivgx *ivg = ivg7_13[vec - IVG7].ifirst;
                 struct ivgx *ivg_stop = ivg7_13[vec - IVG7].istop;
-#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)
+#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561)
                 unsigned long sic_status[3];
 
                 SSYNC();
diff --git a/arch/blackfin/mach-common/pm.c b/arch/blackfin/mach-common/pm.c
index 81930f7d06f1..0be805ca423f 100644
--- a/arch/blackfin/mach-common/pm.c
+++ b/arch/blackfin/mach-common/pm.c
@@ -4,7 +4,7 @@
  * Author:       Cliff Brake <cbrake@accelent.com> Copyright (c) 2001
  *
  * Created:      2001
- * Description:  Power management for the bfin
+ * Description:  Blackfin power management
  *
  * Modified:     Nicolas Pitre - PXA250 support
  *                Copyright (c) 2002 Monta Vista Software, Inc.
@@ -12,7 +12,7 @@
  *                Copyright (c) 2002 Monta Vista Software, Inc.
  *               Dirk Behme <dirk.behme@de.bosch.com> - OMAP1510/1610
  *                Copyright 2004
- *               Copyright 2004-2006 Analog Devices Inc.
+ *               Copyright 2004-2008 Analog Devices Inc.
  *
  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
  *
@@ -67,42 +67,30 @@ void bfin_pm_suspend_standby_enter(void)
         gpio_pm_wakeup_request(CONFIG_PM_WAKEUP_GPIO_NUMBER, WAKEUP_TYPE);
 #endif
 
-#if defined(CONFIG_PM_WAKEUP_BY_GPIO) || defined(CONFIG_PM_WAKEUP_GPIO_API)
-        {
-                u32 flags;
+        u32 flags;
 
-                local_irq_save(flags);
+        local_irq_save(flags);
+        bfin_pm_setup();
 
-                sleep_deeper(gpio_pm_setup()); /*Goto Sleep*/
-
-                gpio_pm_restore();
-
-#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)
-                bfin_write_SIC_IWR0(IWR_ENABLE_ALL);
-                bfin_write_SIC_IWR1(IWR_ENABLE_ALL);
-# ifdef CONFIG_BF54x
-                bfin_write_SIC_IWR2(IWR_ENABLE_ALL);
-# endif
+#ifdef CONFIG_PM_BFIN_SLEEP_DEEPER
+        sleep_deeper(bfin_sic_iwr[0], bfin_sic_iwr[1], bfin_sic_iwr[2]);
 #else
-                bfin_write_SIC_IWR(IWR_ENABLE_ALL);
+        sleep_mode(bfin_sic_iwr[0], bfin_sic_iwr[1], bfin_sic_iwr[2]);
 #endif
 
-                local_irq_restore(flags);
-        }
-#endif
+        bfin_pm_restore();
 
-#if defined(CONFIG_PM_WAKEUP_GPIO_BY_SIC_IWR)
-        sleep_deeper(CONFIG_PM_WAKEUP_SIC_IWR);
-# if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)
+#if defined(CONFIG_BF54x) || defined(CONFIG_BF52x)  || defined(CONFIG_BF561)
         bfin_write_SIC_IWR0(IWR_ENABLE_ALL);
         bfin_write_SIC_IWR1(IWR_ENABLE_ALL);
-#  ifdef CONFIG_BF54x
+# ifdef CONFIG_BF54x
         bfin_write_SIC_IWR2(IWR_ENABLE_ALL);
-#  endif
-# else
-        bfin_write_SIC_IWR(IWR_ENABLE_ALL);
 # endif
-#endif                          /* CONFIG_PM_WAKEUP_GPIO_BY_SIC_IWR */
+#else
+        bfin_write_SIC_IWR(IWR_ENABLE_ALL);
+#endif
+
+        local_irq_restore(flags);
 }
 
 /*
diff --git a/arch/blackfin/mm/init.c b/arch/blackfin/mm/init.c
index eb1a12ac9e33..1f516c55bde6 100644
--- a/arch/blackfin/mm/init.c
+++ b/arch/blackfin/mm/init.c
@@ -138,8 +138,7 @@ void __init mem_init(void)
 
         start_mem = PAGE_ALIGN(start_mem);
         max_mapnr = num_physpages = MAP_NR(high_memory);
-        printk(KERN_INFO "Kernel managed physical pages: %lu\n",
-                num_physpages);
+        printk(KERN_DEBUG "Kernel managed physical pages: %lu\n", num_physpages);
 
         /* This will put all memory onto the freelists. */
         totalram_pages = free_all_bootmem();
@@ -153,8 +152,7 @@ void __init mem_init(void)
         /* do not count in kernel image between _rambase and _ramstart */
         reservedpages -= (_ramstart - _rambase) >> PAGE_SHIFT;
 #if (defined(CONFIG_BFIN_ICACHE) && ANOMALY_05000263)
-        reservedpages += (_ramend - memory_end - DMA_UNCACHED_REGION) >>
-                                PAGE_SHIFT;
+        reservedpages += (_ramend - memory_end - DMA_UNCACHED_REGION) >> PAGE_SHIFT;
 #endif
 
         codek = (_etext - _stext) >> 10;
@@ -163,11 +161,9 @@ void __init mem_init(void)
 
         printk(KERN_INFO
              "Memory available: %luk/%luk RAM, "
-                "(%uk init code, %uk kernel code, "
-                "%uk data, %uk dma, %uk reserved)\n",
+                "(%uk init code, %uk kernel code, %uk data, %uk dma, %uk reserved)\n",
                 (unsigned long) freepages << (PAGE_SHIFT-10), _ramend >> 10,
-                initk, codek, datak, DMA_UNCACHED_REGION >> 10,
-                (reservedpages << (PAGE_SHIFT-10)));
+                initk, codek, datak, DMA_UNCACHED_REGION >> 10, (reservedpages << (PAGE_SHIFT-10)));
 
         /* Initialize the blackfin L1 Memory. */
         l1sram_init();