Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux...
Linus Torvalds [Tue, 8 Dec 2009 16:13:35 +0000 (08:13 -0800)]
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k:
  m68k: parport_mfc3 - Not makes it a bool before the comparison.
  m68k: don't export static inline functions
  fbdev: atafb - add palette register check
  m68k: Remove the BKL from sys_execve
  m68k: Cleanup linker scripts using new linker script macros.
  m68k: Make thread_info.h usable from assembly.
  m68knommu: define arch_has_single_step() and friends
  m68k: ptrace fixes
  m68k: use generic code for ptrace requests
  rtc: Add an RTC driver for the Ricoh RP5C01
  rtc: Add an RTC driver for the Oki MSM6242

16 files changed:
arch/m68k/include/asm/ptrace.h
arch/m68k/include/asm/thread_info_mm.h
arch/m68k/kernel/entry.S
arch/m68k/kernel/process.c
arch/m68k/kernel/ptrace.c
arch/m68k/kernel/vmlinux-std.lds
arch/m68k/kernel/vmlinux-sun3.lds
arch/m68knommu/kernel/ptrace.c
drivers/dio/dio-driver.c
drivers/parport/parport_mfc3.c
drivers/rtc/Kconfig
drivers/rtc/Makefile
drivers/rtc/rtc-msm6242.c [new file with mode: 0644]
drivers/rtc/rtc-rp5c01.c [new file with mode: 0644]
drivers/video/atafb.c
drivers/zorro/zorro-driver.c

index 8c9194b..a6ab663 100644 (file)
@@ -71,6 +71,8 @@ struct switch_stack {
 #define PTRACE_GETFPREGS          14
 #define PTRACE_SETFPREGS          15
 
+#define PTRACE_SINGLEBLOCK     33      /* resume execution until next branch */
+
 #ifdef __KERNEL__
 
 #ifndef PS_S
@@ -82,6 +84,21 @@ struct switch_stack {
 #define instruction_pointer(regs) ((regs)->pc)
 #define profile_pc(regs) instruction_pointer(regs)
 extern void show_regs(struct pt_regs *);
+
+/*
+ * These are defined as per linux/ptrace.h, which see.
+ */
+struct task_struct;
+
+#define arch_has_single_step() (1)
+extern void user_enable_single_step(struct task_struct *);
+extern void user_disable_single_step(struct task_struct *);
+
+#ifdef CONFIG_MMU
+#define arch_has_block_step()  (1)
+extern void user_enable_block_step(struct task_struct *);
+#endif
+
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
 #endif /* _M68K_PTRACE_H */
index b6da388..167e518 100644 (file)
@@ -4,10 +4,12 @@
 #ifndef ASM_OFFSETS_C
 #include <asm/asm-offsets.h>
 #endif
-#include <asm/current.h>
 #include <asm/types.h>
 #include <asm/page.h>
 
+#ifndef __ASSEMBLY__
+#include <asm/current.h>
+
 struct thread_info {
        struct task_struct      *task;          /* main task structure */
        unsigned long           flags;
@@ -16,6 +18,7 @@ struct thread_info {
        __u32 cpu; /* should always be 0 on m68k */
        struct restart_block    restart_block;
 };
+#endif /* __ASSEMBLY__ */
 
 #define PREEMPT_ACTIVE         0x4000000
 
index c5b3363..77fc7c1 100644 (file)
@@ -179,7 +179,11 @@ do_signal_return:
        addql   #8,%sp
        RESTORE_SWITCH_STACK
        addql   #4,%sp
-       jbra    resume_userspace
+       tstl    %d0
+       jeq     resume_userspace
+       | when single stepping into handler stop at the first insn
+       btst    #6,%curptr@(TASK_INFO+TINFO_FLAGS+2)
+       jeq     resume_userspace
 
 do_delayed_trace:
        bclr    #7,%sp@(PT_OFF_SR)      | clear trace bit in SR
index 41230c5..0529659 100644 (file)
@@ -317,15 +317,12 @@ asmlinkage int sys_execve(char __user *name, char __user * __user *argv, char __
        char * filename;
        struct pt_regs *regs = (struct pt_regs *) &name;
 
-       lock_kernel();
        filename = getname(name);
        error = PTR_ERR(filename);
        if (IS_ERR(filename))
-               goto out;
+               return error;
        error = do_execve(filename, argv, envp, regs);
        putname(filename);
-out:
-       unlock_kernel();
        return error;
 }
 
index 2075543..1fc217e 100644 (file)
@@ -35,7 +35,9 @@
 #define SR_MASK 0x001f
 
 /* sets the trace bits. */
-#define TRACE_BITS 0x8000
+#define TRACE_BITS 0xC000
+#define T1_BIT 0x8000
+#define T0_BIT 0x4000
 
 /* Find the stack offset for a register, relative to thread.esp0. */
 #define PT_REG(reg)    ((long)&((struct pt_regs *)0)->reg)
@@ -44,7 +46,7 @@
 /* Mapping from PT_xxx to the stack offset at which the register is
    saved.  Notice that usp has no stack-slot and needs to be treated
    specially (see get_reg/put_reg below). */
-static int regoff[] = {
+static const int regoff[] = {
        [0]     = PT_REG(d1),
        [1]     = PT_REG(d2),
        [2]     = PT_REG(d3),
@@ -79,6 +81,14 @@ static inline long get_reg(struct task_struct *task, int regno)
                addr = (unsigned long *)(task->thread.esp0 + regoff[regno]);
        else
                return 0;
+       /* Need to take stkadj into account. */
+       if (regno == PT_SR || regno == PT_PC) {
+               long stkadj = *(long *)(task->thread.esp0 + PT_REG(stkadj));
+               addr = (unsigned long *) ((unsigned long)addr + stkadj);
+               /* The sr is actually a 16 bit register.  */
+               if (regno == PT_SR)
+                       return *(unsigned short *)addr;
+       }
        return *addr;
 }
 
@@ -96,6 +106,16 @@ static inline int put_reg(struct task_struct *task, int regno,
                addr = (unsigned long *)(task->thread.esp0 + regoff[regno]);
        else
                return -1;
+       /* Need to take stkadj into account. */
+       if (regno == PT_SR || regno == PT_PC) {
+               long stkadj = *(long *)(task->thread.esp0 + PT_REG(stkadj));
+               addr = (unsigned long *) ((unsigned long)addr + stkadj);
+               /* The sr is actually a 16 bit register.  */
+               if (regno == PT_SR) {
+                       *(unsigned short *)addr = data;
+                       return 0;
+               }
+       }
        *addr = data;
        return 0;
 }
@@ -105,7 +125,7 @@ static inline int put_reg(struct task_struct *task, int regno,
  */
 static inline void singlestep_disable(struct task_struct *child)
 {
-       unsigned long tmp = get_reg(child, PT_SR) & ~(TRACE_BITS << 16);
+       unsigned long tmp = get_reg(child, PT_SR) & ~TRACE_BITS;
        put_reg(child, PT_SR, tmp);
        clear_tsk_thread_flag(child, TIF_DELAYED_TRACE);
 }
@@ -118,18 +138,30 @@ void ptrace_disable(struct task_struct *child)
        singlestep_disable(child);
 }
 
+void user_enable_single_step(struct task_struct *child)
+{
+       unsigned long tmp = get_reg(child, PT_SR) & ~TRACE_BITS;
+       put_reg(child, PT_SR, tmp | T1_BIT);
+       set_tsk_thread_flag(child, TIF_DELAYED_TRACE);
+}
+
+void user_enable_block_step(struct task_struct *child)
+{
+       unsigned long tmp = get_reg(child, PT_SR) & ~TRACE_BITS;
+       put_reg(child, PT_SR, tmp | T0_BIT);
+}
+
+void user_disable_single_step(struct task_struct *child)
+{
+       singlestep_disable(child);
+}
+
 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 {
        unsigned long tmp;
        int i, ret = 0;
 
        switch (request) {
-       /* when I and D space are separate, these will need to be fixed. */
-       case PTRACE_PEEKTEXT:   /* read word at location addr. */
-       case PTRACE_PEEKDATA:
-               ret = generic_ptrace_peekdata(child, addr, data);
-               break;
-
        /* read the word at location addr in the USER area. */
        case PTRACE_PEEKUSR:
                if (addr & 3)
@@ -138,8 +170,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
                if (addr >= 0 && addr < 19) {
                        tmp = get_reg(child, addr);
-                       if (addr == PT_SR)
-                               tmp >>= 16;
                } else if (addr >= 21 && addr < 49) {
                        tmp = child->thread.fp[addr - 21];
                        /* Convert internal fpu reg representation
@@ -149,16 +179,10 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                tmp = ((tmp & 0xffff0000) << 15) |
                                      ((tmp & 0x0000ffff) << 16);
                } else
-                       break;
+                       goto out_eio;
                ret = put_user(tmp, (unsigned long *)data);
                break;
 
-       /* when I and D space are separate, this will have to be fixed. */
-       case PTRACE_POKETEXT:   /* write the word at location addr. */
-       case PTRACE_POKEDATA:
-               ret = generic_ptrace_pokedata(child, addr, data);
-               break;
-
        case PTRACE_POKEUSR:    /* write the word at location addr in the USER area */
                if (addr & 3)
                        goto out_eio;
@@ -166,9 +190,9 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
                if (addr == PT_SR) {
                        data &= SR_MASK;
-                       data <<= 16;
-                       data |= get_reg(child, PT_SR) & ~(SR_MASK << 16);
-               } else if (addr >= 0 && addr < 19) {
+                       data |= get_reg(child, PT_SR) & ~SR_MASK;
+               }
+               if (addr >= 0 && addr < 19) {
                        if (put_reg(child, addr, data))
                                goto out_eio;
                } else if (addr >= 21 && addr < 48) {
@@ -185,52 +209,9 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                        goto out_eio;
                break;
 
-       case PTRACE_SYSCALL:    /* continue and stop at next (return from) syscall */
-       case PTRACE_CONT:       /* restart after signal. */
-               if (!valid_signal(data))
-                       goto out_eio;
-
-               if (request == PTRACE_SYSCALL)
-                       set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               else
-                       clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               child->exit_code = data;
-               singlestep_disable(child);
-               wake_up_process(child);
-               break;
-
-       /*
-        * make the child exit.  Best I can do is send it a sigkill.
-        * perhaps it should be put in the status that it wants to
-        * exit.
-        */
-       case PTRACE_KILL:
-               if (child->exit_state == EXIT_ZOMBIE) /* already dead */
-                       break;
-               child->exit_code = SIGKILL;
-               singlestep_disable(child);
-               wake_up_process(child);
-               break;
-
-       case PTRACE_SINGLESTEP: /* set the trap flag. */
-               if (!valid_signal(data))
-                       goto out_eio;
-
-               clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               tmp = get_reg(child, PT_SR) | (TRACE_BITS << 16);
-               put_reg(child, PT_SR, tmp);
-               set_tsk_thread_flag(child, TIF_DELAYED_TRACE);
-
-               child->exit_code = data;
-               /* give it a chance to run. */
-               wake_up_process(child);
-               break;
-
        case PTRACE_GETREGS:    /* Get all gp regs from the child. */
                for (i = 0; i < 19; i++) {
                        tmp = get_reg(child, i);
-                       if (i == PT_SR)
-                               tmp >>= 16;
                        ret = put_user(tmp, (unsigned long *)data);
                        if (ret)
                                break;
@@ -245,8 +226,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                break;
                        if (i == PT_SR) {
                                tmp &= SR_MASK;
-                               tmp <<= 16;
-                               tmp |= get_reg(child, PT_SR) & ~(SR_MASK << 16);
+                               tmp |= get_reg(child, PT_SR) & ~SR_MASK;
                        }
                        put_reg(child, i, tmp);
                        data += sizeof(long);
index 47eac19..878be5f 100644 (file)
@@ -2,6 +2,7 @@
 
 #include <asm-generic/vmlinux.lds.h>
 #include <asm/page.h>
+#include <asm/thread_info.h>
 
 OUTPUT_FORMAT("elf32-m68k", "elf32-m68k", "elf32-m68k")
 OUTPUT_ARCH(m68k)
@@ -22,73 +23,37 @@ SECTIONS
 
   _etext = .;                  /* End of text section */
 
-  . = ALIGN(16);               /* Exception table */
-  __start___ex_table = .;
-  __ex_table : { *(__ex_table) }
-  __stop___ex_table = .;
+  EXCEPTION_TABLE(16)
 
   RODATA
 
-  .data : {                    /* Data */
-       DATA_DATA
-       CONSTRUCTORS
-       }
+  RW_DATA_SECTION(16, PAGE_SIZE, THREAD_SIZE)
 
-  . = ALIGN(16);
-  .data.cacheline_aligned : { *(.data.cacheline_aligned) }
-
-  .bss : { *(.bss) }           /* BSS */
+  BSS_SECTION(0, 0, 0)
 
   _edata = .;                  /* End of data section */
 
   /* will be freed after init */
   . = ALIGN(PAGE_SIZE);                /* Init code and data */
   __init_begin = .;
-  .init.text : {
-       _sinittext = .;
-       INIT_TEXT
-       _einittext = .;
-  } :data
-  .init.data : { INIT_DATA }
-  . = ALIGN(16);
-  __setup_start = .;
-  .init.setup : { *(.init.setup) }
-  __setup_end = .;
-  __initcall_start = .;
-  .initcall.init : {
-       INITCALLS
-  }
-  __initcall_end = .;
-  __con_initcall_start = .;
-  .con_initcall.init : { *(.con_initcall.init) }
-  __con_initcall_end = .;
+  INIT_TEXT_SECTION(PAGE_SIZE) :data
+  INIT_DATA_SECTION(16)
   .m68k_fixup : {
        __start_fixup = .;
        *(.m68k_fixup)
        __stop_fixup = .;
   }
-  SECURITY_INIT
-#ifdef CONFIG_BLK_DEV_INITRD
-  . = ALIGN(8192);
-  __initramfs_start = .;
-  .init.ramfs : { *(.init.ramfs) }
-  __initramfs_end = .;
-#endif
   NOTES
-  . = ALIGN(8192);
-  __init_end = .;
-
-  .data.init_task : { *(.data.init_task) }     /* The initial task and kernel stack */
+  .init_end : {
+       /* This ALIGN be in a section so that _end is at the end of the
+          load segment. */
+       . = ALIGN(PAGE_SIZE);
+       __init_end = .;
+  }
 
   _end = . ;
 
-  /* Stabs debugging sections.  */
-  .stab 0 : { *(.stab) }
-  .stabstr 0 : { *(.stabstr) }
-  .stab.excl 0 : { *(.stab.excl) }
-  .stab.exclstr 0 : { *(.stab.exclstr) }
-  .stab.index 0 : { *(.stab.index) }
-  .stab.indexstr 0 : { *(.stab.indexstr) }
+  STABS_DEBUG
   .comment 0 : { *(.comment) }
 
   /* Sections to be discarded */
index 03efaf0..1ad6b7a 100644 (file)
@@ -2,6 +2,7 @@
 
 #include <asm-generic/vmlinux.lds.h>
 #include <asm/page.h>
+#include <asm/thread_info.h>
 
 OUTPUT_FORMAT("elf32-m68k", "elf32-m68k", "elf32-m68k")
 OUTPUT_ARCH(m68k)
@@ -23,14 +24,8 @@ SECTIONS
 
   _etext = .;                  /* End of text section */
 
-  .data : {                    /* Data */
-       DATA_DATA
-       CONSTRUCTORS
-       . = ALIGN(16);          /* Exception table */
-       __start___ex_table = .;
-       *(__ex_table)
-       __stop___ex_table = .;
-       } :data
+  EXCEPTION_TABLE(16) :data
+  RW_DATA_SECTION(16, PAGE_SIZE, THREAD_SIZE) :data
   /* End of data goes *here* so that freeing init code works properly. */
   _edata = .;
   NOTES
@@ -38,56 +33,21 @@ SECTIONS
   /* will be freed after init */
   . = ALIGN(PAGE_SIZE);        /* Init code and data */
 __init_begin = .;
-       .init.text : {
-               _sinittext = .;
-               INIT_TEXT
-               _einittext = .;
-       }
-       .init.data : { INIT_DATA }
-       . = ALIGN(16);
-       __setup_start = .;
-       .init.setup : { *(.init.setup) }
-       __setup_end = .;
-       __initcall_start = .;
-       .initcall.init : {
-               INITCALLS
-       }
-       __initcall_end = .;
-       __con_initcall_start = .;
-       .con_initcall.init : { *(.con_initcall.init) }
-       __con_initcall_end = .;
+       INIT_TEXT_SECTION(PAGE_SIZE)
+       INIT_DATA_SECTION(16)
        .m68k_fixup : {
                __start_fixup = .;
                *(.m68k_fixup)
                __stop_fixup = .;
        }
-       SECURITY_INIT
-#ifdef CONFIG_BLK_DEV_INITRD
-       . = ALIGN(PAGE_SIZE);
-       __initramfs_start = .;
-       .init.ramfs : { *(.init.ramfs) }
-       __initramfs_end = .;
-#endif
        . = ALIGN(PAGE_SIZE);
        __init_end = .;
-       .data.init.task : { *(.data.init_task) }
-
 
-  .bss : { *(.bss) }           /* BSS */
+  BSS_SECTION(0, 0, 0)
 
   _end = . ;
 
-  .crap : {
-       /* Stabs debugging sections.  */
-       *(.stab)
-       *(.stabstr)
-       *(.stab.excl)
-       *(.stab.exclstr)
-       *(.stab.index)
-       *(.stab.indexstr)
-       *(.comment)
-       *(.note)
-  }
+  STABS_DEBUG
 
   /* Sections to be discarded */
   DISCARDS
index ef70ca0..4d38289 100644 (file)
@@ -86,6 +86,20 @@ static inline int put_reg(struct task_struct *task, int regno,
        return 0;
 }
 
+void user_enable_single_step(struct task_struct *task)
+{
+       unsigned long srflags;
+       srflags = get_reg(task, PT_SR) | (TRACE_BITS << 16);
+       put_reg(task, PT_SR, srflags);
+}
+
+void user_disable_single_step(struct task_struct *task)
+{
+       unsigned long srflags;
+       srflags = get_reg(task, PT_SR) & ~(TRACE_BITS << 16);
+       put_reg(task, PT_SR, srflags);
+}
+
 /*
  * Called by kernel/ptrace.c when detaching..
  *
@@ -93,10 +107,8 @@ static inline int put_reg(struct task_struct *task, int regno,
  */
 void ptrace_disable(struct task_struct *child)
 {
-       unsigned long tmp;
        /* make sure the single step bit is not set. */
-       tmp = get_reg(child, PT_SR) & ~(TRACE_BITS << 16);
-       put_reg(child, PT_SR, tmp);
+       user_disable_single_step(child);
 }
 
 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
index 9c0c9af..a7b174e 100644 (file)
@@ -140,5 +140,4 @@ postcore_initcall(dio_driver_init);
 EXPORT_SYMBOL(dio_match_device);
 EXPORT_SYMBOL(dio_register_driver);
 EXPORT_SYMBOL(dio_unregister_driver);
-EXPORT_SYMBOL(dio_dev_driver);
 EXPORT_SYMBOL(dio_bus_type);
index 6dec9ba..362db31 100644 (file)
@@ -386,7 +386,7 @@ static void __exit parport_mfc3_exit(void)
                if (!this_port[i])
                        continue;
                parport_remove_port(this_port[i]);
-               if (!this_port[i]->irq != PARPORT_IRQ_NONE) {
+               if (this_port[i]->irq != PARPORT_IRQ_NONE) {
                        if (--use_cnt == 0) 
                                free_irq(IRQ_AMIGA_PORTS, &pp_mfc3_ops);
                }
index e11e1cd..f2e1004 100644 (file)
@@ -509,6 +509,15 @@ config RTC_DRV_M48T59
          This driver can also be built as a module, if so, the module
          will be called "rtc-m48t59".
 
+config RTC_DRV_MSM6242
+       tristate "Oki MSM6242"
+       help
+         If you say yes here you get support for the Oki MSM6242
+         timekeeping chip. It is used in some Amiga models (e.g. A2000).
+
+         This driver can also be built as a module. If so, the module
+         will be called rtc-msm6242.
+
 config RTC_MXC
        tristate "Freescale MXC Real Time Clock"
        depends on ARCH_MXC
@@ -529,6 +538,16 @@ config RTC_DRV_BQ4802
          This driver can also be built as a module. If so, the module
          will be called rtc-bq4802.
 
+config RTC_DRV_RP5C01
+       tristate "Ricoh RP5C01"
+       help
+         If you say yes here you get support for the Ricoh RP5C01
+         timekeeping chip. It is used in some Amiga models (e.g. A3000
+         and A4000).
+
+         This driver can also be built as a module. If so, the module
+         will be called rtc-rp5c01.
+
 config RTC_DRV_V3020
        tristate "EM Microelectronic V3020"
        help
index aa3fbd5..af1ba7a 100644 (file)
@@ -52,6 +52,7 @@ obj-$(CONFIG_RTC_DRV_M48T86)  += rtc-m48t86.o
 obj-$(CONFIG_RTC_MXC)          += rtc-mxc.o
 obj-$(CONFIG_RTC_DRV_MAX6900)  += rtc-max6900.o
 obj-$(CONFIG_RTC_DRV_MAX6902)  += rtc-max6902.o
+obj-$(CONFIG_RTC_DRV_MSM6242)  += rtc-msm6242.o
 obj-$(CONFIG_RTC_DRV_MV)       += rtc-mv.o
 obj-$(CONFIG_RTC_DRV_OMAP)     += rtc-omap.o
 obj-$(CONFIG_RTC_DRV_PCAP)     += rtc-pcap.o
@@ -64,6 +65,7 @@ obj-$(CONFIG_RTC_DRV_PL031)   += rtc-pl031.o
 obj-$(CONFIG_RTC_DRV_PS3)      += rtc-ps3.o
 obj-$(CONFIG_RTC_DRV_PXA)      += rtc-pxa.o
 obj-$(CONFIG_RTC_DRV_R9701)    += rtc-r9701.o
+obj-$(CONFIG_RTC_DRV_RP5C01)   += rtc-rp5c01.o
 obj-$(CONFIG_RTC_DRV_RS5C313)  += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_RS5C348)  += rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_RS5C372)  += rtc-rs5c372.o
diff --git a/drivers/rtc/rtc-msm6242.c b/drivers/rtc/rtc-msm6242.c
new file mode 100644 (file)
index 0000000..5f5968a
--- /dev/null
@@ -0,0 +1,269 @@
+/*
+ *  Oki MSM6242 RTC Driver
+ *
+ *  Copyright 2009 Geert Uytterhoeven
+ *
+ *  Based on the A2000 TOD code in arch/m68k/amiga/config.c
+ *  Copyright (C) 1993 Hamish Macdonald
+ */
+
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+
+
+enum {
+       MSM6242_SECOND1         = 0x0,  /* 1-second digit register */
+       MSM6242_SECOND10        = 0x1,  /* 10-second digit register */
+       MSM6242_MINUTE1         = 0x2,  /* 1-minute digit register */
+       MSM6242_MINUTE10        = 0x3,  /* 10-minute digit register */
+       MSM6242_HOUR1           = 0x4,  /* 1-hour digit register */
+       MSM6242_HOUR10          = 0x5,  /* PM/AM, 10-hour digit register */
+       MSM6242_DAY1            = 0x6,  /* 1-day digit register */
+       MSM6242_DAY10           = 0x7,  /* 10-day digit register */
+       MSM6242_MONTH1          = 0x8,  /* 1-month digit register */
+       MSM6242_MONTH10         = 0x9,  /* 10-month digit register */
+       MSM6242_YEAR1           = 0xa,  /* 1-year digit register */
+       MSM6242_YEAR10          = 0xb,  /* 10-year digit register */
+       MSM6242_WEEK            = 0xc,  /* Week register */
+       MSM6242_CD              = 0xd,  /* Control Register D */
+       MSM6242_CE              = 0xe,  /* Control Register E */
+       MSM6242_CF              = 0xf,  /* Control Register F */
+};
+
+#define MSM6242_HOUR10_AM      (0 << 2)
+#define MSM6242_HOUR10_PM      (1 << 2)
+#define MSM6242_HOUR10_HR_MASK (3 << 0)
+
+#define MSM6242_WEEK_SUNDAY    0
+#define MSM6242_WEEK_MONDAY    1
+#define MSM6242_WEEK_TUESDAY   2
+#define MSM6242_WEEK_WEDNESDAY 3
+#define MSM6242_WEEK_THURSDAY  4
+#define MSM6242_WEEK_FRIDAY    5
+#define MSM6242_WEEK_SATURDAY  6
+
+#define MSM6242_CD_30_S_ADJ    (1 << 3)        /* 30-second adjustment */
+#define MSM6242_CD_IRQ_FLAG    (1 << 2)
+#define MSM6242_CD_BUSY                (1 << 1)
+#define MSM6242_CD_HOLD                (1 << 0)
+
+#define MSM6242_CE_T_MASK      (3 << 2)
+#define MSM6242_CE_T_64HZ      (0 << 2)        /* period 1/64 second */
+#define MSM6242_CE_T_1HZ       (1 << 2)        /* period 1 second */
+#define MSM6242_CE_T_1MINUTE   (2 << 2)        /* period 1 minute */
+#define MSM6242_CE_T_1HOUR     (3 << 2)        /* period 1 hour */
+
+#define MSM6242_CE_ITRPT_STND  (1 << 1)
+#define MSM6242_CE_MASK                (1 << 0)        /* STD.P output control */
+
+#define MSM6242_CF_TEST                (1 << 3)
+#define MSM6242_CF_12H         (0 << 2)
+#define MSM6242_CF_24H         (1 << 2)
+#define MSM6242_CF_STOP                (1 << 1)
+#define MSM6242_CF_REST                (1 << 0)        /* reset */
+
+
+struct msm6242_priv {
+       u32 __iomem *regs;
+       struct rtc_device *rtc;
+};
+
+static inline unsigned int msm6242_read(struct msm6242_priv *priv,
+                                      unsigned int reg)
+{
+       return __raw_readl(&priv->regs[reg]) & 0xf;
+}
+
+static inline void msm6242_write(struct msm6242_priv *priv, unsigned int val,
+                               unsigned int reg)
+{
+       return __raw_writel(val, &priv->regs[reg]);
+}
+
+static inline void msm6242_set(struct msm6242_priv *priv, unsigned int val,
+                              unsigned int reg)
+{
+       msm6242_write(priv, msm6242_read(priv, reg) | val, reg);
+}
+
+static inline void msm6242_clear(struct msm6242_priv *priv, unsigned int val,
+                                unsigned int reg)
+{
+       msm6242_write(priv, msm6242_read(priv, reg) & ~val, reg);
+}
+
+static void msm6242_lock(struct msm6242_priv *priv)
+{
+       int cnt = 5;
+
+       msm6242_set(priv, MSM6242_CD_HOLD, MSM6242_CD);
+
+       while ((msm6242_read(priv, MSM6242_CD) & MSM6242_CD_BUSY) && cnt) {
+               msm6242_clear(priv, MSM6242_CD_HOLD, MSM6242_CD);
+               udelay(70);
+               msm6242_set(priv, MSM6242_CD_HOLD, MSM6242_CD);
+               cnt--;
+       }
+
+       if (!cnt)
+               pr_warning("msm6242: timed out waiting for RTC (0x%x)\n",
+                          msm6242_read(priv, MSM6242_CD));
+}
+
+static void msm6242_unlock(struct msm6242_priv *priv)
+{
+       msm6242_clear(priv, MSM6242_CD_HOLD, MSM6242_CD);
+}
+
+static int msm6242_read_time(struct device *dev, struct rtc_time *tm)
+{
+       struct msm6242_priv *priv = dev_get_drvdata(dev);
+
+       msm6242_lock(priv);
+
+       tm->tm_sec  = msm6242_read(priv, MSM6242_SECOND10) * 10 +
+                     msm6242_read(priv, MSM6242_SECOND1);
+       tm->tm_min  = msm6242_read(priv, MSM6242_MINUTE10) * 10 +
+                     msm6242_read(priv, MSM6242_MINUTE1);
+       tm->tm_hour = (msm6242_read(priv, MSM6242_HOUR10 & 3)) * 10 +
+                     msm6242_read(priv, MSM6242_HOUR1);
+       tm->tm_mday = msm6242_read(priv, MSM6242_DAY10) * 10 +
+                     msm6242_read(priv, MSM6242_DAY1);
+       tm->tm_wday = msm6242_read(priv, MSM6242_WEEK);
+       tm->tm_mon  = msm6242_read(priv, MSM6242_MONTH10) * 10 +
+                     msm6242_read(priv, MSM6242_MONTH1) - 1;
+       tm->tm_year = msm6242_read(priv, MSM6242_YEAR10) * 10 +
+                     msm6242_read(priv, MSM6242_YEAR1);
+       if (tm->tm_year <= 69)
+               tm->tm_year += 100;
+
+       if (!(msm6242_read(priv, MSM6242_CF) & MSM6242_CF_24H)) {
+               unsigned int pm = msm6242_read(priv, MSM6242_HOUR10) &
+                                 MSM6242_HOUR10_PM;
+               if (!pm && tm->tm_hour == 12)
+                       tm->tm_hour = 0;
+               else if (pm && tm->tm_hour != 12)
+                       tm->tm_hour += 12;
+       }
+
+       msm6242_unlock(priv);
+
+       return rtc_valid_tm(tm);
+}
+
+static int msm6242_set_time(struct device *dev, struct rtc_time *tm)
+{
+       struct msm6242_priv *priv = dev_get_drvdata(dev);
+
+       msm6242_lock(priv);
+
+       msm6242_write(priv, tm->tm_sec / 10, MSM6242_SECOND10);
+       msm6242_write(priv, tm->tm_sec % 10, MSM6242_SECOND1);
+       msm6242_write(priv, tm->tm_min / 10, MSM6242_MINUTE10);
+       msm6242_write(priv, tm->tm_min % 10, MSM6242_MINUTE1);
+       if (msm6242_read(priv, MSM6242_CF) & MSM6242_CF_24H)
+               msm6242_write(priv, tm->tm_hour / 10, MSM6242_HOUR10);
+       else if (tm->tm_hour >= 12)
+               msm6242_write(priv, MSM6242_HOUR10_PM + (tm->tm_hour - 12) / 10,
+                             MSM6242_HOUR10);
+       else
+               msm6242_write(priv, tm->tm_hour / 10, MSM6242_HOUR10);
+       msm6242_write(priv, tm->tm_hour % 10, MSM6242_HOUR1);
+       msm6242_write(priv, tm->tm_mday / 10, MSM6242_DAY10);
+       msm6242_write(priv, tm->tm_mday % 10, MSM6242_DAY1);
+       if (tm->tm_wday != -1)
+               msm6242_write(priv, tm->tm_wday, MSM6242_WEEK);
+       msm6242_write(priv, (tm->tm_mon + 1) / 10, MSM6242_MONTH10);
+       msm6242_write(priv, (tm->tm_mon + 1) % 10, MSM6242_MONTH1);
+       if (tm->tm_year >= 100)
+               tm->tm_year -= 100;
+       msm6242_write(priv, tm->tm_year / 10, MSM6242_YEAR10);
+       msm6242_write(priv, tm->tm_year % 10, MSM6242_YEAR1);
+
+       msm6242_unlock(priv);
+       return 0;
+}
+
+static const struct rtc_class_ops msm6242_rtc_ops = {
+       .read_time      = msm6242_read_time,
+       .set_time       = msm6242_set_time,
+};
+
+static int __init msm6242_rtc_probe(struct platform_device *dev)
+{
+       struct resource *res;
+       struct msm6242_priv *priv;
+       struct rtc_device *rtc;
+       int error;
+
+       res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+       if (!res)
+               return -ENODEV;
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->regs = ioremap(res->start, resource_size(res));
+       if (!priv->regs) {
+               error = -ENOMEM;
+               goto out_free_priv;
+       }
+
+       rtc = rtc_device_register("rtc-msm6242", &dev->dev, &msm6242_rtc_ops,
+                                 THIS_MODULE);
+       if (IS_ERR(rtc)) {
+               error = PTR_ERR(rtc);
+               goto out_unmap;
+       }
+
+       priv->rtc = rtc;
+       platform_set_drvdata(dev, priv);
+       return 0;
+
+out_unmap:
+       iounmap(priv->regs);
+out_free_priv:
+       kfree(priv);
+       return error;
+}
+
+static int __exit msm6242_rtc_remove(struct platform_device *dev)
+{
+       struct msm6242_priv *priv = platform_get_drvdata(dev);
+
+       rtc_device_unregister(priv->rtc);
+       iounmap(priv->regs);
+       kfree(priv);
+       return 0;
+}
+
+static struct platform_driver msm6242_rtc_driver = {
+       .driver = {
+               .name   = "rtc-msm6242",
+               .owner  = THIS_MODULE,
+       },
+       .remove = __exit_p(msm6242_rtc_remove),
+};
+
+static int __init msm6242_rtc_init(void)
+{
+       return platform_driver_probe(&msm6242_rtc_driver, msm6242_rtc_probe);
+}
+
+static void __exit msm6242_rtc_fini(void)
+{
+       platform_driver_unregister(&msm6242_rtc_driver);
+}
+
+module_init(msm6242_rtc_init);
+module_exit(msm6242_rtc_fini);
+
+MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Oki MSM6242 RTC driver");
+MODULE_ALIAS("platform:rtc-msm6242");
diff --git a/drivers/rtc/rtc-rp5c01.c b/drivers/rtc/rtc-rp5c01.c
new file mode 100644 (file)
index 0000000..e1313fe
--- /dev/null
@@ -0,0 +1,222 @@
+/*
+ *  Ricoh RP5C01 RTC Driver
+ *
+ *  Copyright 2009 Geert Uytterhoeven
+ *
+ *  Based on the A3000 TOD code in arch/m68k/amiga/config.c
+ *  Copyright (C) 1993 Hamish Macdonald
+ */
+
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+
+
+enum {
+       RP5C01_1_SECOND         = 0x0,  /* MODE 00 */
+       RP5C01_10_SECOND        = 0x1,  /* MODE 00 */
+       RP5C01_1_MINUTE         = 0x2,  /* MODE 00 and MODE 01 */
+       RP5C01_10_MINUTE        = 0x3,  /* MODE 00 and MODE 01 */
+       RP5C01_1_HOUR           = 0x4,  /* MODE 00 and MODE 01 */
+       RP5C01_10_HOUR          = 0x5,  /* MODE 00 and MODE 01 */
+       RP5C01_DAY_OF_WEEK      = 0x6,  /* MODE 00 and MODE 01 */
+       RP5C01_1_DAY            = 0x7,  /* MODE 00 and MODE 01 */
+       RP5C01_10_DAY           = 0x8,  /* MODE 00 and MODE 01 */
+       RP5C01_1_MONTH          = 0x9,  /* MODE 00 */
+       RP5C01_10_MONTH         = 0xa,  /* MODE 00 */
+       RP5C01_1_YEAR           = 0xb,  /* MODE 00 */
+       RP5C01_10_YEAR          = 0xc,  /* MODE 00 */
+
+       RP5C01_12_24_SELECT     = 0xa,  /* MODE 01 */
+       RP5C01_LEAP_YEAR        = 0xb,  /* MODE 01 */
+
+       RP5C01_MODE             = 0xd,  /* all modes */
+       RP5C01_TEST             = 0xe,  /* all modes */
+       RP5C01_RESET            = 0xf,  /* all modes */
+};
+
+#define RP5C01_12_24_SELECT_12 (0 << 0)
+#define RP5C01_12_24_SELECT_24 (1 << 0)
+
+#define RP5C01_10_HOUR_AM      (0 << 1)
+#define RP5C01_10_HOUR_PM      (1 << 1)
+
+#define RP5C01_MODE_TIMER_EN   (1 << 3)        /* timer enable */
+#define RP5C01_MODE_ALARM_EN   (1 << 2)        /* alarm enable */
+
+#define RP5C01_MODE_MODE_MASK  (3 << 0)
+#define RP5C01_MODE_MODE00     (0 << 0)        /* time */
+#define RP5C01_MODE_MODE01     (1 << 0)        /* alarm, 12h/24h, leap year */
+#define RP5C01_MODE_RAM_BLOCK10        (2 << 0)        /* RAM 4 bits x 13 */
+#define RP5C01_MODE_RAM_BLOCK11        (3 << 0)        /* RAM 4 bits x 13 */
+
+#define RP5C01_RESET_1HZ_PULSE (1 << 3)
+#define RP5C01_RESET_16HZ_PULSE        (1 << 2)
+#define RP5C01_RESET_SECOND    (1 << 1)        /* reset divider stages for */
+                                               /* seconds or smaller units */
+#define RP5C01_RESET_ALARM     (1 << 0)        /* reset all alarm registers */
+
+
+struct rp5c01_priv {
+       u32 __iomem *regs;
+       struct rtc_device *rtc;
+};
+
+static inline unsigned int rp5c01_read(struct rp5c01_priv *priv,
+                                      unsigned int reg)
+{
+       return __raw_readl(&priv->regs[reg]) & 0xf;
+}
+
+static inline void rp5c01_write(struct rp5c01_priv *priv, unsigned int val,
+                               unsigned int reg)
+{
+       return __raw_writel(val, &priv->regs[reg]);
+}
+
+static void rp5c01_lock(struct rp5c01_priv *priv)
+{
+       rp5c01_write(priv, RP5C01_MODE_MODE00, RP5C01_MODE);
+}
+
+static void rp5c01_unlock(struct rp5c01_priv *priv)
+{
+       rp5c01_write(priv, RP5C01_MODE_TIMER_EN | RP5C01_MODE_MODE01,
+                    RP5C01_MODE);
+}
+
+static int rp5c01_read_time(struct device *dev, struct rtc_time *tm)
+{
+       struct rp5c01_priv *priv = dev_get_drvdata(dev);
+
+       rp5c01_lock(priv);
+
+       tm->tm_sec  = rp5c01_read(priv, RP5C01_10_SECOND) * 10 +
+                     rp5c01_read(priv, RP5C01_1_SECOND);
+       tm->tm_min  = rp5c01_read(priv, RP5C01_10_MINUTE) * 10 +
+                     rp5c01_read(priv, RP5C01_1_MINUTE);
+       tm->tm_hour = rp5c01_read(priv, RP5C01_10_HOUR) * 10 +
+                     rp5c01_read(priv, RP5C01_1_HOUR);
+       tm->tm_mday = rp5c01_read(priv, RP5C01_10_DAY) * 10 +
+                     rp5c01_read(priv, RP5C01_1_DAY);
+       tm->tm_wday = rp5c01_read(priv, RP5C01_DAY_OF_WEEK);
+       tm->tm_mon  = rp5c01_read(priv, RP5C01_10_MONTH) * 10 +
+                     rp5c01_read(priv, RP5C01_1_MONTH) - 1;
+       tm->tm_year = rp5c01_read(priv, RP5C01_10_YEAR) * 10 +
+                     rp5c01_read(priv, RP5C01_1_YEAR);
+       if (tm->tm_year <= 69)
+               tm->tm_year += 100;
+
+       rp5c01_unlock(priv);
+
+       return rtc_valid_tm(tm);
+}
+
+static int rp5c01_set_time(struct device *dev, struct rtc_time *tm)
+{
+       struct rp5c01_priv *priv = dev_get_drvdata(dev);
+
+       rp5c01_lock(priv);
+
+       rp5c01_write(priv, tm->tm_sec / 10, RP5C01_10_SECOND);
+       rp5c01_write(priv, tm->tm_sec % 10, RP5C01_1_SECOND);
+       rp5c01_write(priv, tm->tm_min / 10, RP5C01_10_MINUTE);
+       rp5c01_write(priv, tm->tm_min % 10, RP5C01_1_MINUTE);
+       rp5c01_write(priv, tm->tm_hour / 10, RP5C01_10_HOUR);
+       rp5c01_write(priv, tm->tm_hour % 10, RP5C01_1_HOUR);
+       rp5c01_write(priv, tm->tm_mday / 10, RP5C01_10_DAY);
+       rp5c01_write(priv, tm->tm_mday % 10, RP5C01_1_DAY);
+       if (tm->tm_wday != -1)
+               rp5c01_write(priv, tm->tm_wday, RP5C01_DAY_OF_WEEK);
+       rp5c01_write(priv, (tm->tm_mon + 1) / 10, RP5C01_10_MONTH);
+       rp5c01_write(priv, (tm->tm_mon + 1) % 10, RP5C01_1_MONTH);
+       if (tm->tm_year >= 100)
+               tm->tm_year -= 100;
+       rp5c01_write(priv, tm->tm_year / 10, RP5C01_10_YEAR);
+       rp5c01_write(priv, tm->tm_year % 10, RP5C01_1_YEAR);
+
+       rp5c01_unlock(priv);
+       return 0;
+}
+
+static const struct rtc_class_ops rp5c01_rtc_ops = {
+       .read_time      = rp5c01_read_time,
+       .set_time       = rp5c01_set_time,
+};
+
+static int __init rp5c01_rtc_probe(struct platform_device *dev)
+{
+       struct resource *res;
+       struct rp5c01_priv *priv;
+       struct rtc_device *rtc;
+       int error;
+
+       res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+       if (!res)
+               return -ENODEV;
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->regs = ioremap(res->start, resource_size(res));
+       if (!priv->regs) {
+               error = -ENOMEM;
+               goto out_free_priv;
+       }
+
+       rtc = rtc_device_register("rtc-rp5c01", &dev->dev, &rp5c01_rtc_ops,
+                                 THIS_MODULE);
+       if (IS_ERR(rtc)) {
+               error = PTR_ERR(rtc);
+               goto out_unmap;
+       }
+
+       priv->rtc = rtc;
+       platform_set_drvdata(dev, priv);
+       return 0;
+
+out_unmap:
+       iounmap(priv->regs);
+out_free_priv:
+       kfree(priv);
+       return error;
+}
+
+static int __exit rp5c01_rtc_remove(struct platform_device *dev)
+{
+       struct rp5c01_priv *priv = platform_get_drvdata(dev);
+
+       rtc_device_unregister(priv->rtc);
+       iounmap(priv->regs);
+       kfree(priv);
+       return 0;
+}
+
+static struct platform_driver rp5c01_rtc_driver = {
+       .driver = {
+               .name   = "rtc-rp5c01",
+               .owner  = THIS_MODULE,
+       },
+       .remove = __exit_p(rp5c01_rtc_remove),
+};
+
+static int __init rp5c01_rtc_init(void)
+{
+       return platform_driver_probe(&rp5c01_rtc_driver, rp5c01_rtc_probe);
+}
+
+static void __exit rp5c01_rtc_fini(void)
+{
+       platform_driver_unregister(&rp5c01_rtc_driver);
+}
+
+module_init(rp5c01_rtc_init);
+module_exit(rp5c01_rtc_fini);
+
+MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Ricoh RP5C01 RTC driver");
+MODULE_ALIAS("platform:rtc-rp5c01");
index 37624f7..b7687c5 100644 (file)
@@ -2242,6 +2242,9 @@ static int ext_setcolreg(unsigned int regno, unsigned int red,
        if (!external_vgaiobase)
                return 1;
 
+       if (regno > 255)
+               return 1;
+
        switch (external_card_type) {
        case IS_VGA:
                OUTB(0x3c8, regno);
index e6c4390..53180a3 100644 (file)
@@ -156,5 +156,4 @@ postcore_initcall(zorro_driver_init);
 EXPORT_SYMBOL(zorro_match_device);
 EXPORT_SYMBOL(zorro_register_driver);
 EXPORT_SYMBOL(zorro_unregister_driver);
-EXPORT_SYMBOL(zorro_dev_driver);
 EXPORT_SYMBOL(zorro_bus_type);