Nothing exciting here, just trivial fixes..
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
 
 static int sh_dmac_request_dma(struct dma_channel *chan)
 {
-       char name[32];
-
        if (unlikely(!chan->flags & DMA_TEI_CAPABLE))
                return 0;
 
-       snprintf(name, sizeof(name), "DMAC Transfer End (Channel %d)",
+       chan->name = kzalloc(32, GFP_KERNEL);
+       if (unlikely(chan->name == NULL))
+               return -ENOMEM;
+       snprintf(chan->name, 32, "DMAC Transfer End (Channel %d)",
                 chan->chan);
 
        return request_irq(get_dmte_irq(chan->chan), dma_tei,
-                          IRQF_DISABLED, name, chan);
+                          IRQF_DISABLED, chan->name, chan);
 }
 
 static void sh_dmac_free_dma(struct dma_channel *chan)
 {
        free_irq(get_dmte_irq(chan->chan), chan);
+       kfree(chan->name);
 }
 
 static void
 
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/init.h>
+#include <linux/pci.h>
 #include <asm/io.h>
 #include <asm/titan.h>
 #include "pci-sh4.h"
 
         * unified cache on the SH-2 and SH-3, as well as the harvard
         * style cache on the SH-4.
         */
-       if (test_bit(SH_CACHE_COMBINED, &(boot_cpu_data.icache.flags))) {
+       if (boot_cpu_data.icache.flags & SH_CACHE_COMBINED) {
                seq_printf(m, "unified\n");
                show_cacheinfo(m, "cache", boot_cpu_data.icache);
        } else {
 
 
 /* platform dependent support */
 EXPORT_SYMBOL(dump_fpu);
-EXPORT_SYMBOL(enable_irq);
-EXPORT_SYMBOL(disable_irq);
-EXPORT_SYMBOL(probe_irq_mask);
 EXPORT_SYMBOL(kernel_thread);
-EXPORT_SYMBOL(disable_irq_nosync);
 EXPORT_SYMBOL(irq_desc);
 EXPORT_SYMBOL(no_irq_type);
 
-EXPORT_SYMBOL(strstr);
 EXPORT_SYMBOL(strlen);
-EXPORT_SYMBOL(strnlen);
-EXPORT_SYMBOL(strchr);
-EXPORT_SYMBOL(strcat);
-EXPORT_SYMBOL(strncat);
 
 /* PCI exports */
 #ifdef CONFIG_PCI
 /* mem exports */
 EXPORT_SYMBOL(memchr);
 EXPORT_SYMBOL(memcpy);
-EXPORT_SYMBOL(memcpy_fromio);
-EXPORT_SYMBOL(memcpy_toio);
 EXPORT_SYMBOL(memset);
-EXPORT_SYMBOL(memset_io);
 EXPORT_SYMBOL(memmove);
-EXPORT_SYMBOL(memcmp);
-EXPORT_SYMBOL(memscan);
 EXPORT_SYMBOL(__copy_user);
 EXPORT_SYMBOL(boot_cpu_data);
 
 #ifdef CONFIG_IPV6
 EXPORT_SYMBOL(csum_ipv6_magic);
 #endif
-EXPORT_SYMBOL(consistent_sync);
 EXPORT_SYMBOL(clear_page);
 
  * for more details.
  *
  */
-
 #include <linux/init.h>
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <asm/mmu_context.h>
 #include <asm/cacheflush.h>
 
-/* The 32KB cache on the SH7705 suffers from the same synonym problem
- * as SH4 CPUs */
-
-#define __pte_offset(address) \
-               ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
-#define pte_offset(dir, address) ((pte_t *) pmd_page_vaddr(*(dir)) + \
-               __pte_offset(address))
-
+/*
+ * The 32KB cache on the SH7705 suffers from the same synonym problem
+ * as SH4 CPUs
+ */
 static inline void cache_wback_all(void)
 {
        unsigned long ways, waysize, addrstart;
        __flush_wback_region((void *)start, end - start);
 }
 
-
 /*
  * Writeback&Invalidate the D-cache of the page
  */
        local_irq_restore(flags);
 }
 
-
 /*
  * Write back & invalidate the D-cache of the page.
  * (To avoid "alias" issues)
  *
  * ADDRESS: Virtual Address (U0 address)
  */
-void flush_cache_page(struct vm_area_struct *vma, unsigned long address, unsigned long pfn)
+void flush_cache_page(struct vm_area_struct *vma, unsigned long address,
+                     unsigned long pfn)
 {
        __flush_dcache_page(pfn << PAGE_SHIFT);
 }
 {
        __flush_purge_region(page_address(page), PAGE_SIZE);
 }
-
 
  */
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/hardirq.h>
+#include <linux/kprobes.h>
 #include <asm/system.h>
 #include <asm/mmu_context.h>
 #include <asm/kgdb.h>
 /*
  * Called with interrupts disabled.
  */
-asmlinkage int __do_page_fault(struct pt_regs *regs, unsigned long writeaccess,
-                              unsigned long address)
+asmlinkage int __kprobes __do_page_fault(struct pt_regs *regs,
+                                        unsigned long writeaccess,
+                                        unsigned long address)
 {
        pgd_t *pgd;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
        pte_t entry;
-       struct mm_struct *mm;
+       struct mm_struct *mm = current->mm;
        spinlock_t *ptl;
        int ret = 1;
 
                pgd = pgd_offset_k(address);
                mm = NULL;
        } else {
-               if (unlikely(address >= TASK_SIZE || !(mm = current->mm)))
+               if (unlikely(address >= TASK_SIZE || !mm))
                        return 1;
 
-               pgd = pgd_offset(current->mm, address);
+               pgd = pgd_offset(mm, address);
        }
 
        pud = pud_offset(pgd, address);
 
 
        return 0;
 }
-
 arch_initcall(pmb_init);
 
-#ifdef CONFIG_DEBUG_FS
 static int pmb_seq_show(struct seq_file *file, void *iter)
 {
        int i;
 
        return 0;
 }
-
 postcore_initcall(pmb_debugfs_init);
-#endif
 
        wait_queue_head_t wait_queue;
 
        struct sys_device dev;
+       char *name;
 };
 
 struct dma_info {
 
 extern void make_maskreg_irq(unsigned int irq);
 extern unsigned short *irq_mask_register;
 
+/*
+ * PINT IRQs
+ */
+void init_IRQ_pint(void);
+
 /*
  * Function for "on chip support modules".
  */
 
 /* The native architecture */
 #define KEXEC_ARCH KEXEC_ARCH_SH
 
+#define MAX_NOTE_BYTES 1024
+
 #ifndef __ASSEMBLY__
 
 extern void machine_shutdown(void);
 
 }
 #endif
 
-static __inline__ unsigned long tas(volatile int *m)
+static inline unsigned long tas(volatile int *m)
 {
        unsigned long retval;
 
 }
 #endif
 
-static __inline__ void local_irq_disable(void)
+static inline void local_irq_disable(void)
 {
        unsigned long __dummy;
        __asm__ __volatile__("stc       sr, %0\n\t"
                             : "memory");
 }
 
-static __inline__ void set_bl_bit(void)
+static inline void set_bl_bit(void)
 {
        unsigned long __dummy0, __dummy1;
 
                             : "memory");
 }
 
-static __inline__ void clear_bl_bit(void)
+static inline void clear_bl_bit(void)
 {
        unsigned long __dummy0, __dummy1;
 
        (flags != 0);                   \
 })
 
-static __inline__ unsigned long local_irq_save(void)
+static inline unsigned long local_irq_save(void)
 {
        unsigned long flags, __dummy;
 
        return flags;
 }
 
-#ifdef DEBUG_CLI_STI
-static __inline__ void  local_irq_restore(unsigned long x)
-{
-       if ((x & 0x000000f0) != 0x000000f0)
-               local_irq_enable();
-       else {
-               unsigned long flags;
-               local_save_flags(flags);
-
-               if (flags == 0) {
-                       extern void dump_stack(void);
-                       printk(KERN_ERR "BUG!\n");
-                       dump_stack();
-                       local_irq_disable();
-               }
-       }
-}
-#else
 #define local_irq_restore(x) do {                      \
        if ((x & 0x000000f0) != 0x000000f0)             \
                local_irq_enable();                     \
 } while (0)
-#endif
-
-#define really_restore_flags(x) do {                   \
-       if ((x & 0x000000f0) != 0x000000f0)             \
-               local_irq_enable();                     \
-       else                                            \
-               local_irq_disable();                    \
-} while (0)
 
 /*
  * Jump to P2 area.