Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 69961c375288bdab7604e0bb1c8d22999bb8a347

Authored by Geert Uytterhoeven 2006-10-10 04:23:31 +0800

Committed by Linus Torvalds 2006-10-10 05:54:46 +0800

[PATCH] m68k/Atari: Interrupt updates

Misc Atari fixes:
  - initialize correct number of atari irqs
  - silence vbl interrupt until it's used by atafb
  - use mdelay() to read clock if necessary

Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 3 changed files with 15 additions and 4 deletions Inline Diff

arch/m68k/atari/ataints.c
arch/m68k/atari/time.c
arch/m68k/kernel/ints.c

arch/m68k/atari/ataints.c

Diff comments View file @ 69961c3

 /*
  * arch/m68k/atari/ataints.c -- Atari Linux interrupt handling code
  *
  * 5/2/94 Roman Hodek:
  *  Added support for TT interrupts; setup for TT SCU (may someone has
  *  twiddled there and we won't get the right interrupts :-()
  *
  *  Major change: The device-independent code in m68k/ints.c didn't know
  *  about non-autovec ints yet. It hardcoded the number of possible ints to
  *  7 (IRQ1...IRQ7). But the Atari has lots of non-autovec ints! I made the
  *  number of possible ints a constant defined in interrupt.h, which is
  *  47 for the Atari. So we can call request_irq() for all Atari interrupts
  *  just the normal way. Additionally, all vectors >= 48 are initialized to
  *  call trap() instead of inthandler(). This must be changed here, too.
  *
  * 1995-07-16 Lars Brinkhoff <f93labr@dd.chalmers.se>:
  *  Corrected a bug in atari_add_isr() which rejected all SCC
  *  interrupt sources if there were no TT MFP!
  *
  * 12/13/95: New interface functions atari_level_triggered_int() and
  *  atari_register_vme_int() as support for level triggered VME interrupts.
  *
  * 02/12/96: (Roman)
  *  Total rewrite of Atari interrupt handling, for new scheme see comments
  *  below.
  *
  * 1996-09-03 lars brinkhoff <f93labr@dd.chalmers.se>:
  *  Added new function atari_unregister_vme_int(), and
  *  modified atari_register_vme_int() as well as IS_VALID_INTNO()
  *  to work with it.
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
  *
  */
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/kernel_stat.h>
 #include <linux/init.h>
 #include <linux/seq_file.h>
 #include <asm/system.h>
 #include <asm/traps.h>
 #include <asm/atarihw.h>
 #include <asm/atariints.h>
 #include <asm/atari_stdma.h>
 #include <asm/irq.h>
 #include <asm/entry.h>
 /*
  * Atari interrupt handling scheme:
  * --------------------------------
  *
  * All interrupt source have an internal number (defined in
  * <asm/atariints.h>): Autovector interrupts are 1..7, then follow ST-MFP,
  * TT-MFP, SCC, and finally VME interrupts. Vector numbers for the latter can
  * be allocated by atari_register_vme_int().
  *
  * Each interrupt can be of three types:
  *
  *  - SLOW: The handler runs with all interrupts enabled, except the one it
  *    was called by (to avoid reentering). This should be the usual method.
  *    But it is currently possible only for MFP ints, since only the MFP
  *    offers an easy way to mask interrupts.
  *
  *  - FAST: The handler runs with all interrupts disabled. This should be used
  *    only for really fast handlers, that just do actions immediately
  *    necessary, and let the rest do a bottom half or task queue.
  *
  *  - PRIORITIZED: The handler can be interrupted by higher-level ints
  *    (greater IPL, no MFP priorities!). This is the method of choice for ints
  *    which should be slow, but are not from a MFP.
  *
  * The feature of more than one handler for one int source is still there, but
  * only applicable if all handers are of the same type. To not slow down
  * processing of ints with only one handler by the chaining feature, the list
  * calling function atari_call_irq_list() is only plugged in at the time the
  * second handler is registered.
  *
  * Implementation notes: For fast-as-possible int handling, there are separate
  * entry points for each type (slow/fast/prio). The assembler handler calls
  * the irq directly in the usual case, no C wrapper is involved. In case of
  * multiple handlers, atari_call_irq_list() is registered as handler and calls
  * in turn the real irq's. To ease access from assembler level to the irq
  * function pointer and accompanying data, these two are stored in a separate
  * array, irq_handler[]. The rest of data (type, name) are put into a second
  * array, irq_param, that is accessed from C only. For each slow interrupt (32
  * in all) there are separate handler functions, which makes it possible to
  * hard-code the MFP register address and value, are necessary to mask the
  * int. If there'd be only one generic function, lots of calculations would be
  * needed to determine MFP register and int mask from the vector number :-(
  *
  * Furthermore, slow ints may not lower the IPL below its previous value
  * (before the int happened). This is needed so that an int of class PRIO, on
  * that this int may be stacked, cannot be reentered. This feature is
  * implemented as follows: If the stack frame format is 1 (throwaway), the int
  * is not stacked, and the IPL is anded with 0xfbff, resulting in a new level
  * 2, which still blocks the HSYNC, but no interrupts of interest. If the
  * frame format is 0, the int is nested, and the old IPL value can be found in
  * the sr copy in the frame.
  */
 #if 0
 #define	NUM_INT_SOURCES	(8 + NUM_ATARI_SOURCES)
 typedef void (*asm_irq_handler)(void);
 struct irqhandler {
 	irqreturn_t (*handler)(int, void *, struct pt_regs *);
 	void	*dev_id;
 };
 struct irqparam {
 	unsigned long	flags;
 	const char	*devname;
 };
 /*
  * Array with irq's and their parameter data. This array is accessed from low
  * level assembler code, so an element size of 8 allows usage of index scaling
  * addressing mode.
  */
 static struct irqhandler irq_handler[NUM_INT_SOURCES];
 /*
  * This array hold the rest of parameters of int handlers: type
  * (slow,fast,prio) and the name of the handler. These values are only
  * accessed from C
  */
 static struct irqparam irq_param[NUM_INT_SOURCES];
 /* check for valid int number (complex, sigh...) */
 #define	IS_VALID_INTNO(n)											\
 	((n) > 0 &&														\
 	 /* autovec and ST-MFP ok anyway */								\
 	 (((n) < TTMFP_SOURCE_BASE) ||									\
 	  /* TT-MFP ok if present */									\
 	  ((n) >= TTMFP_SOURCE_BASE && (n) < SCC_SOURCE_BASE &&			\
 	   ATARIHW_PRESENT(TT_MFP)) ||									\
 	  /* SCC ok if present and number even */						\
 	  ((n) >= SCC_SOURCE_BASE && (n) < VME_SOURCE_BASE &&			\
 	   !((n) & 1) && ATARIHW_PRESENT(SCC)) ||						\
 	  /* greater numbers ok if they are registered VME vectors */		\
 	  ((n) >= VME_SOURCE_BASE && (n) < VME_SOURCE_BASE + VME_MAX_SOURCES && \
 		  free_vme_vec_bitmap & (1 << ((n) - VME_SOURCE_BASE)))))
 /*
  * Here start the assembler entry points for interrupts
  */
 #define IRQ_NAME(nr) atari_slow_irq_##nr##_handler(void)
 #define	BUILD_SLOW_IRQ(n)						   \
 asmlinkage void IRQ_NAME(n);						   \
 /* Dummy function to allow asm with operands.  */			   \
 void atari_slow_irq_##n##_dummy (void) {				   \
 __asm__ (__ALIGN_STR "\n"						   \
 "atari_slow_irq_" #n "_handler:\t"					   \
 "	addl	%6,%5\n"	/* preempt_count() += HARDIRQ_OFFSET */	   \
 	SAVE_ALL_INT "\n"						   \
 	GET_CURRENT(%%d0) "\n"						   \
 "	andb	#~(1<<(%c3&7)),%a4:w\n"	/* mask this interrupt */	   \
 	/* get old IPL from stack frame */				   \
 "	bfextu	%%sp@(%c2){#5,#3},%%d0\n"				   \
 "	movew	%%sr,%%d1\n"						   \
 "	bfins	%%d0,%%d1{#21,#3}\n"					   \
 "	movew	%%d1,%%sr\n"		/* set IPL = previous value */	   \
 "	addql	#1,%a0\n"						   \
 "	lea	%a1,%%a0\n"						   \
 "	pea	%%sp@\n"		/* push addr of frame */	   \
 "	movel	%%a0@(4),%%sp@-\n"	/* push handler data */		   \
 "	pea	(%c3+8)\n"		/* push int number */		   \
 "	movel	%%a0@,%%a0\n"						   \
 "	jbsr	%%a0@\n"		/* call the handler */		   \
 "	addql	#8,%%sp\n"						   \
 "	addql	#4,%%sp\n"						   \
 "	orw	#0x0600,%%sr\n"						   \
 "	andw	#0xfeff,%%sr\n"		/* set IPL = 6 again */		   \
 "	orb	#(1<<(%c3&7)),%a4:w\n"	/* now unmask the int again */	   \
 "	jbra	ret_from_interrupt\n"					   \
 	 : : "i" (&kstat_cpu(0).irqs[n+8]), "i" (&irq_handler[n+8]),	   \
 	     "n" (PT_OFF_SR), "n" (n),					   \
 	     "i" (n & 8 ? (n & 16 ? &tt_mfp.int_mk_a : &mfp.int_mk_a)	   \
 		        : (n & 16 ? &tt_mfp.int_mk_b : &mfp.int_mk_b)),	   \
 	     "m" (preempt_count()), "di" (HARDIRQ_OFFSET)		   \
 );									   \
 	for (;;);			/* fake noreturn */		   \
 }
 BUILD_SLOW_IRQ(0);
 BUILD_SLOW_IRQ(1);
 BUILD_SLOW_IRQ(2);
 BUILD_SLOW_IRQ(3);
 BUILD_SLOW_IRQ(4);
 BUILD_SLOW_IRQ(5);
 BUILD_SLOW_IRQ(6);
 BUILD_SLOW_IRQ(7);
 BUILD_SLOW_IRQ(8);
 BUILD_SLOW_IRQ(9);
 BUILD_SLOW_IRQ(10);
 BUILD_SLOW_IRQ(11);
 BUILD_SLOW_IRQ(12);
 BUILD_SLOW_IRQ(13);
 BUILD_SLOW_IRQ(14);
 BUILD_SLOW_IRQ(15);
 BUILD_SLOW_IRQ(16);
 BUILD_SLOW_IRQ(17);
 BUILD_SLOW_IRQ(18);
 BUILD_SLOW_IRQ(19);
 BUILD_SLOW_IRQ(20);
 BUILD_SLOW_IRQ(21);
 BUILD_SLOW_IRQ(22);
 BUILD_SLOW_IRQ(23);
 BUILD_SLOW_IRQ(24);
 BUILD_SLOW_IRQ(25);
 BUILD_SLOW_IRQ(26);
 BUILD_SLOW_IRQ(27);
 BUILD_SLOW_IRQ(28);
 BUILD_SLOW_IRQ(29);
 BUILD_SLOW_IRQ(30);
 BUILD_SLOW_IRQ(31);
 asm_irq_handler slow_handlers[32] = {
 	[0]	= atari_slow_irq_0_handler,
 	[1]	= atari_slow_irq_1_handler,
 	[2]	= atari_slow_irq_2_handler,
 	[3]	= atari_slow_irq_3_handler,
 	[4]	= atari_slow_irq_4_handler,
 	[5]	= atari_slow_irq_5_handler,
 	[6]	= atari_slow_irq_6_handler,
 	[7]	= atari_slow_irq_7_handler,
 	[8]	= atari_slow_irq_8_handler,
 	[9]	= atari_slow_irq_9_handler,
 	[10]	= atari_slow_irq_10_handler,
 	[11]	= atari_slow_irq_11_handler,
 	[12]	= atari_slow_irq_12_handler,
 	[13]	= atari_slow_irq_13_handler,
 	[14]	= atari_slow_irq_14_handler,
 	[15]	= atari_slow_irq_15_handler,
 	[16]	= atari_slow_irq_16_handler,
 	[17]	= atari_slow_irq_17_handler,
 	[18]	= atari_slow_irq_18_handler,
 	[19]	= atari_slow_irq_19_handler,
 	[20]	= atari_slow_irq_20_handler,
 	[21]	= atari_slow_irq_21_handler,
 	[22]	= atari_slow_irq_22_handler,
 	[23]	= atari_slow_irq_23_handler,
 	[24]	= atari_slow_irq_24_handler,
 	[25]	= atari_slow_irq_25_handler,
 	[26]	= atari_slow_irq_26_handler,
 	[27]	= atari_slow_irq_27_handler,
 	[28]	= atari_slow_irq_28_handler,
 	[29]	= atari_slow_irq_29_handler,
 	[30]	= atari_slow_irq_30_handler,
 	[31]	= atari_slow_irq_31_handler
 };
 asmlinkage void atari_fast_irq_handler( void );
 asmlinkage void atari_prio_irq_handler( void );
 /* Dummy function to allow asm with operands.  */
 void atari_fast_prio_irq_dummy (void) {
 __asm__ (__ALIGN_STR "\n"
 "atari_fast_irq_handler:\n\t"
 	"orw	#0x700,%%sr\n"		/* disable all interrupts */
 "atari_prio_irq_handler:\n\t"
 	"addl	%3,%2\n\t"		/* preempt_count() += HARDIRQ_OFFSET */
 	SAVE_ALL_INT "\n\t"
 	GET_CURRENT(%%d0) "\n\t"
 	/* get vector number from stack frame and convert to source */
 	"bfextu	%%sp@(%c1){#4,#10},%%d0\n\t"
 	"subw	#(0x40-8),%%d0\n\t"
 	"jpl	1f\n\t"
 	"addw	#(0x40-8-0x18),%%d0\n"
     "1:\tlea	%a0,%%a0\n\t"
 	"addql	#1,%%a0@(%%d0:l:4)\n\t"
 	"lea	irq_handler,%%a0\n\t"
 	"lea	%%a0@(%%d0:l:8),%%a0\n\t"
 	"pea	%%sp@\n\t"		/* push frame address */
 	"movel	%%a0@(4),%%sp@-\n\t"	/* push handler data */
 	"movel	%%d0,%%sp@-\n\t"	/* push int number */
 	"movel	%%a0@,%%a0\n\t"
 	"jsr	%%a0@\n\t"		/* and call the handler */
 	"addql	#8,%%sp\n\t"
 	"addql	#4,%%sp\n\t"
 	"jbra	ret_from_interrupt"
 	 : : "i" (&kstat_cpu(0).irqs), "n" (PT_OFF_FORMATVEC),
 	     "m" (preempt_count()), "di" (HARDIRQ_OFFSET)
 );
 	for (;;);
 }
 #endif
 /*
  * Bitmap for free interrupt vector numbers
  * (new vectors starting from 0x70 can be allocated by
  * atari_register_vme_int())
  */
 static int free_vme_vec_bitmap;
 /* GK:
  * HBL IRQ handler for Falcon. Nobody needs it :-)
  * ++andreas: raise ipl to disable further HBLANK interrupts.
  */
 asmlinkage void falcon_hblhandler(void);
 asm(".text\n"
 __ALIGN_STR "\n\t"
 "falcon_hblhandler:\n\t"
 	"orw	#0x200,%sp@\n\t"	/* set saved ipl to 2 */
 	"rte");
 extern void atari_microwire_cmd(int cmd);
 extern int atari_SCC_reset_done;
 static int atari_startup_irq(unsigned int irq)
 {
 	m68k_irq_startup(irq);
 	atari_turnon_irq(irq);
 	atari_enable_irq(irq);
 	return 0;
 }
 static void atari_shutdown_irq(unsigned int irq)
 {
 	atari_disable_irq(irq);
 	atari_turnoff_irq(irq);
 	m68k_irq_shutdown(irq);
+	if (irq == IRQ_AUTO_4)
+	    vectors[VEC_INT4] = falcon_hblhandler;
 }
 static struct irq_controller atari_irq_controller = {
 	.name		= "atari",
 	.lock		= SPIN_LOCK_UNLOCKED,
 	.startup	= atari_startup_irq,
 	.shutdown	= atari_shutdown_irq,
 	.enable		= atari_enable_irq,
 	.disable	= atari_disable_irq,
 };
 /*
  * void atari_init_IRQ (void)
  *
  * Parameters:	None
  *
  * Returns:	Nothing
  *
  * This function should be called during kernel startup to initialize
  * the atari IRQ handling routines.
  */
 void __init atari_init_IRQ(void)
 {
-	m68k_setup_user_interrupt(VEC_USER, 192, NULL);
+	m68k_setup_user_interrupt(VEC_USER, NUM_ATARI_SOURCES - IRQ_USER, NULL);
 	m68k_setup_irq_controller(&atari_irq_controller, 1, NUM_ATARI_SOURCES - 1);
 	/* Initialize the MFP(s) */
 #ifdef ATARI_USE_SOFTWARE_EOI
 	mfp.vec_adr  = 0x48;	/* Software EOI-Mode */
 #else
 	mfp.vec_adr  = 0x40;	/* Automatic EOI-Mode */
 #endif
 	mfp.int_en_a = 0x00;	/* turn off MFP-Ints */
 	mfp.int_en_b = 0x00;
 	mfp.int_mk_a = 0xff;	/* no Masking */
 	mfp.int_mk_b = 0xff;
 	if (ATARIHW_PRESENT(TT_MFP)) {
 #ifdef ATARI_USE_SOFTWARE_EOI
 		tt_mfp.vec_adr  = 0x58;		/* Software EOI-Mode */
 #else
 		tt_mfp.vec_adr  = 0x50;		/* Automatic EOI-Mode */
 #endif
 		tt_mfp.int_en_a = 0x00;		/* turn off MFP-Ints */
 		tt_mfp.int_en_b = 0x00;
 		tt_mfp.int_mk_a = 0xff;		/* no Masking */
 		tt_mfp.int_mk_b = 0xff;
 	}
 	if (ATARIHW_PRESENT(SCC) && !atari_SCC_reset_done) {
 		scc.cha_a_ctrl = 9;
 		MFPDELAY();
 		scc.cha_a_ctrl = (char) 0xc0; /* hardware reset */
 	}
 	if (ATARIHW_PRESENT(SCU)) {
 		/* init the SCU if present */
 		tt_scu.sys_mask = 0x10;		/* enable VBL (for the cursor) and
 									 * disable HSYNC interrupts (who
 									 * needs them?)  MFP and SCC are
 									 * enabled in VME mask
 									 */
 		tt_scu.vme_mask = 0x60;		/* enable MFP and SCC ints */
 	} else {
 		/* If no SCU and no Hades, the HSYNC interrupt needs to be
 		 * disabled this way. (Else _inthandler in kernel/sys_call.S
 		 * gets overruns)
 		 */
-		if (!MACH_IS_HADES)
+		if (!MACH_IS_HADES) {
 			vectors[VEC_INT2] = falcon_hblhandler;
+			vectors[VEC_INT4] = falcon_hblhandler;
+		}
 	}
 	if (ATARIHW_PRESENT(PCM_8BIT) && ATARIHW_PRESENT(MICROWIRE)) {
 		/* Initialize the LM1992 Sound Controller to enable
 		   the PSG sound.  This is misplaced here, it should
 		   be in an atasound_init(), that doesn't exist yet. */
 		atari_microwire_cmd(MW_LM1992_PSG_HIGH);
 	}
 	stdma_init();
 	/* Initialize the PSG: all sounds off, both ports output */
 	sound_ym.rd_data_reg_sel = 7;
 	sound_ym.wd_data = 0xff;
 }
 /*
  * atari_register_vme_int() returns the number of a free interrupt vector for
  * hardware with a programmable int vector (probably a VME board).
  */
 unsigned long atari_register_vme_int(void)
 {
 	int i;
 	for (i = 0; i < 32; i++)
 		if ((free_vme_vec_bitmap & (1 << i)) == 0)
 			break;
 	if (i == 16)
 		return 0;
 	free_vme_vec_bitmap |= 1 << i;
 	return VME_SOURCE_BASE + i;
 }
 void atari_unregister_vme_int(unsigned long irq)
 {
 	if (irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) {
 		irq -= VME_SOURCE_BASE;
 		free_vme_vec_bitmap &= ~(1 << irq);
 	}
 }

arch/m68k/atari/time.c

Diff comments View file @ 69961c3

 /*
  * linux/arch/m68k/atari/time.c
  *
  * Atari time and real time clock stuff
  *
  * Assembled of parts of former atari/config.c 97-12-18 by Roman Hodek
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
  */
 #include <linux/types.h>
 #include <linux/mc146818rtc.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
+#include <linux/delay.h>
 #include <asm/atariints.h>
 void __init
 atari_sched_init(irq_handler_t timer_routine)
 {
     /* set Timer C data Register */
     mfp.tim_dt_c = INT_TICKS;
     /* start timer C, div = 1:100 */
     mfp.tim_ct_cd = (mfp.tim_ct_cd & 15) | 0x60;
     /* install interrupt service routine for MFP Timer C */
     request_irq(IRQ_MFP_TIMC, timer_routine, IRQ_TYPE_SLOW,
                 "timer", timer_routine);
 }
 /* ++andreas: gettimeoffset fixed to check for pending interrupt */
 #define TICK_SIZE 10000
 /* This is always executed with interrupts disabled.  */
 unsigned long atari_gettimeoffset (void)
 {
   unsigned long ticks, offset = 0;
   /* read MFP timer C current value */
   ticks = mfp.tim_dt_c;
   /* The probability of underflow is less than 2% */
   if (ticks > INT_TICKS - INT_TICKS / 50)
     /* Check for pending timer interrupt */
     if (mfp.int_pn_b & (1 << 5))
       offset = TICK_SIZE;
   ticks = INT_TICKS - ticks;
   ticks = ticks * 10000L / INT_TICKS;
   return ticks + offset;
 }
 static void mste_read(struct MSTE_RTC *val)
 {
 #define COPY(v) val->v=(mste_rtc.v & 0xf)
 	do {
 		COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ;
 		COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ;
 		COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ;
 		COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ;
 		COPY(year_tens) ;
 	/* prevent from reading the clock while it changed */
 	} while (val->sec_ones != (mste_rtc.sec_ones & 0xf));
 #undef COPY
 }
 static void mste_write(struct MSTE_RTC *val)
 {
 #define COPY(v) mste_rtc.v=val->v
 	do {
 		COPY(sec_ones) ; COPY(sec_tens) ; COPY(min_ones) ;
 		COPY(min_tens) ; COPY(hr_ones) ; COPY(hr_tens) ;
 		COPY(weekday) ; COPY(day_ones) ; COPY(day_tens) ;
 		COPY(mon_ones) ; COPY(mon_tens) ; COPY(year_ones) ;
 		COPY(year_tens) ;
 	/* prevent from writing the clock while it changed */
 	} while (val->sec_ones != (mste_rtc.sec_ones & 0xf));
 #undef COPY
 }
 #define	RTC_READ(reg)				\
     ({	unsigned char	__val;			\
 		(void) atari_writeb(reg,&tt_rtc.regsel);	\
 		__val = tt_rtc.data;		\
 		__val;				\
 	})
 #define	RTC_WRITE(reg,val)			\
     do {					\
 		atari_writeb(reg,&tt_rtc.regsel);	\
 		tt_rtc.data = (val);		\
 	} while(0)
 #define HWCLK_POLL_INTERVAL	5
 int atari_mste_hwclk( int op, struct rtc_time *t )
 {
     int hour, year;
     int hr24=0;
     struct MSTE_RTC val;
     mste_rtc.mode=(mste_rtc.mode | 1);
     hr24=mste_rtc.mon_tens & 1;
     mste_rtc.mode=(mste_rtc.mode & ~1);
     if (op) {
         /* write: prepare values */
         val.sec_ones = t->tm_sec % 10;
         val.sec_tens = t->tm_sec / 10;
         val.min_ones = t->tm_min % 10;
         val.min_tens = t->tm_min / 10;
         hour = t->tm_hour;
         if (!hr24) {
 	    if (hour > 11)
 		hour += 20 - 12;
 	    if (hour == 0 || hour == 20)
 		hour += 12;
         }
         val.hr_ones = hour % 10;
         val.hr_tens = hour / 10;
         val.day_ones = t->tm_mday % 10;
         val.day_tens = t->tm_mday / 10;
         val.mon_ones = (t->tm_mon+1) % 10;
         val.mon_tens = (t->tm_mon+1) / 10;
         year = t->tm_year - 80;
         val.year_ones = year % 10;
         val.year_tens = year / 10;
         val.weekday = t->tm_wday;
         mste_write(&val);
         mste_rtc.mode=(mste_rtc.mode | 1);
         val.year_ones = (year % 4);	/* leap year register */
         mste_rtc.mode=(mste_rtc.mode & ~1);
     }
     else {
         mste_read(&val);
         t->tm_sec = val.sec_ones + val.sec_tens * 10;
         t->tm_min = val.min_ones + val.min_tens * 10;
         hour = val.hr_ones + val.hr_tens * 10;
 	if (!hr24) {
 	    if (hour == 12 || hour == 12 + 20)
 		hour -= 12;
 	    if (hour >= 20)
                 hour += 12 - 20;
         }
 	t->tm_hour = hour;
 	t->tm_mday = val.day_ones + val.day_tens * 10;
         t->tm_mon  = val.mon_ones + val.mon_tens * 10 - 1;
         t->tm_year = val.year_ones + val.year_tens * 10 + 80;
         t->tm_wday = val.weekday;
     }
     return 0;
 }
 int atari_tt_hwclk( int op, struct rtc_time *t )
 {
     int sec=0, min=0, hour=0, day=0, mon=0, year=0, wday=0;
     unsigned long	flags;
     unsigned char	ctrl;
     int pm = 0;
     ctrl = RTC_READ(RTC_CONTROL); /* control registers are
                                    * independent from the UIP */
     if (op) {
         /* write: prepare values */
         sec  = t->tm_sec;
         min  = t->tm_min;
         hour = t->tm_hour;
         day  = t->tm_mday;
         mon  = t->tm_mon + 1;
         year = t->tm_year - atari_rtc_year_offset;
         wday = t->tm_wday + (t->tm_wday >= 0);
         if (!(ctrl & RTC_24H)) {
 	    if (hour > 11) {
 		pm = 0x80;
 		if (hour != 12)
 		    hour -= 12;
 	    }
 	    else if (hour == 0)
 		hour = 12;
         }
         if (!(ctrl & RTC_DM_BINARY)) {
             BIN_TO_BCD(sec);
             BIN_TO_BCD(min);
             BIN_TO_BCD(hour);
             BIN_TO_BCD(day);
             BIN_TO_BCD(mon);
             BIN_TO_BCD(year);
             if (wday >= 0) BIN_TO_BCD(wday);
         }
     }
     /* Reading/writing the clock registers is a bit critical due to
      * the regular update cycle of the RTC. While an update is in
      * progress, registers 0..9 shouldn't be touched.
      * The problem is solved like that: If an update is currently in
      * progress (the UIP bit is set), the process sleeps for a while
      * (50ms). This really should be enough, since the update cycle
      * normally needs 2 ms.
      * If the UIP bit reads as 0, we have at least 244 usecs until the
      * update starts. This should be enough... But to be sure,
      * additionally the RTC_SET bit is set to prevent an update cycle.
      */
-    while( RTC_READ(RTC_FREQ_SELECT) & RTC_UIP )
+    while( RTC_READ(RTC_FREQ_SELECT) & RTC_UIP ) {
-        schedule_timeout_interruptible(HWCLK_POLL_INTERVAL);
+	if (in_atomic() || irqs_disabled())
+	    mdelay(1);
+	else
+	    schedule_timeout_interruptible(HWCLK_POLL_INTERVAL);
+    }
     local_irq_save(flags);
     RTC_WRITE( RTC_CONTROL, ctrl | RTC_SET );
     if (!op) {
         sec  = RTC_READ( RTC_SECONDS );
         min  = RTC_READ( RTC_MINUTES );
         hour = RTC_READ( RTC_HOURS );
         day  = RTC_READ( RTC_DAY_OF_MONTH );
         mon  = RTC_READ( RTC_MONTH );
         year = RTC_READ( RTC_YEAR );
         wday = RTC_READ( RTC_DAY_OF_WEEK );
     }
     else {
         RTC_WRITE( RTC_SECONDS, sec );
         RTC_WRITE( RTC_MINUTES, min );
         RTC_WRITE( RTC_HOURS, hour + pm);
         RTC_WRITE( RTC_DAY_OF_MONTH, day );
         RTC_WRITE( RTC_MONTH, mon );
         RTC_WRITE( RTC_YEAR, year );
         if (wday >= 0) RTC_WRITE( RTC_DAY_OF_WEEK, wday );
     }
     RTC_WRITE( RTC_CONTROL, ctrl & ~RTC_SET );
     local_irq_restore(flags);
     if (!op) {
         /* read: adjust values */
         if (hour & 0x80) {
 	    hour &= ~0x80;
 	    pm = 1;
 	}
 	if (!(ctrl & RTC_DM_BINARY)) {
             BCD_TO_BIN(sec);
             BCD_TO_BIN(min);
             BCD_TO_BIN(hour);
             BCD_TO_BIN(day);
             BCD_TO_BIN(mon);
             BCD_TO_BIN(year);
             BCD_TO_BIN(wday);
         }
         if (!(ctrl & RTC_24H)) {
 	    if (!pm && hour == 12)
 		hour = 0;
 	    else if (pm && hour != 12)
 		hour += 12;
         }
         t->tm_sec  = sec;
         t->tm_min  = min;
         t->tm_hour = hour;
         t->tm_mday = day;
         t->tm_mon  = mon - 1;
         t->tm_year = year + atari_rtc_year_offset;
         t->tm_wday = wday - 1;
     }
     return( 0 );
 }
 int atari_mste_set_clock_mmss (unsigned long nowtime)
 {
     short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60;
     struct MSTE_RTC val;
     unsigned char rtc_minutes;
     mste_read(&val);
     rtc_minutes= val.min_ones + val.min_tens * 10;
     if ((rtc_minutes < real_minutes
          ? real_minutes - rtc_minutes
          : rtc_minutes - real_minutes) < 30)
     {
         val.sec_ones = real_seconds % 10;
         val.sec_tens = real_seconds / 10;
         val.min_ones = real_minutes % 10;
         val.min_tens = real_minutes / 10;
         mste_write(&val);
     }
     else
         return -1;
     return 0;
 }
 int atari_tt_set_clock_mmss (unsigned long nowtime)
 {
     int retval = 0;
     short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60;
     unsigned char save_control, save_freq_select, rtc_minutes;
     save_control = RTC_READ (RTC_CONTROL); /* tell the clock it's being set */
     RTC_WRITE (RTC_CONTROL, save_control | RTC_SET);
     save_freq_select = RTC_READ (RTC_FREQ_SELECT); /* stop and reset prescaler */
     RTC_WRITE (RTC_FREQ_SELECT, save_freq_select | RTC_DIV_RESET2);
     rtc_minutes = RTC_READ (RTC_MINUTES);
     if (!(save_control & RTC_DM_BINARY))
         BCD_TO_BIN (rtc_minutes);
     /* Since we're only adjusting minutes and seconds, don't interfere
        with hour overflow.  This avoids messing with unknown time zones
        but requires your RTC not to be off by more than 30 minutes.  */
     if ((rtc_minutes < real_minutes
          ? real_minutes - rtc_minutes
          : rtc_minutes - real_minutes) < 30)
         {
             if (!(save_control & RTC_DM_BINARY))
                 {
                     BIN_TO_BCD (real_seconds);
                     BIN_TO_BCD (real_minutes);
                 }
             RTC_WRITE (RTC_SECONDS, real_seconds);
             RTC_WRITE (RTC_MINUTES, real_minutes);
         }
     else
         retval = -1;
     RTC_WRITE (RTC_FREQ_SELECT, save_freq_select);
     RTC_WRITE (RTC_CONTROL, save_control);
     return retval;
 }
 /*
  * Local variables:
  *  c-indent-level: 4
  *  tab-width: 8
  * End:
  */

arch/m68k/kernel/ints.c

Diff comments View file @ 69961c3

 /*
  * linux/arch/m68k/kernel/ints.c -- Linux/m68k general interrupt handling code
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
  *
  * 07/03/96: Timer initialization, and thus mach_sched_init(),
  *           removed from request_irq() and moved to init_time().
  *           We should therefore consider renaming our add_isr() and
  *           remove_isr() to request_irq() and free_irq()
  *           respectively, so they are compliant with the other
  *           architectures.                                     /Jes
  * 11/07/96: Changed all add_/remove_isr() to request_/free_irq() calls.
  *           Removed irq list support, if any machine needs an irq server
  *           it must implement this itself (as it's already done), instead
  *           only default handler are used with mach_default_handler.
  *           request_irq got some flags different from other architectures:
  *           - IRQ_FLG_REPLACE : Replace an existing handler (the default one
  *                               can be replaced without this flag)
  *           - IRQ_FLG_LOCK : handler can't be replaced
  *           There are other machine depending flags, see there
  *           If you want to replace a default handler you should know what
  *           you're doing, since it might handle different other irq sources
  *           which must be served                               /Roman Zippel
  */
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/kernel_stat.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/irq.h>
 #include <asm/traps.h>
 #include <asm/page.h>
 #include <asm/machdep.h>
 #include <asm/cacheflush.h>
 #include <asm/irq_regs.h>
 #ifdef CONFIG_Q40
 #include <asm/q40ints.h>
 #endif
 extern u32 auto_irqhandler_fixup[];
 extern u32 user_irqhandler_fixup[];
 extern u16 user_irqvec_fixup[];
 /* table for system interrupt handlers */
 static struct irq_node *irq_list[NR_IRQS];
 static struct irq_controller *irq_controller[NR_IRQS];
 static int irq_depth[NR_IRQS];
 static int m68k_first_user_vec;
 static struct irq_controller auto_irq_controller = {
 	.name		= "auto",
 	.lock		= SPIN_LOCK_UNLOCKED,
 	.startup	= m68k_irq_startup,
 	.shutdown	= m68k_irq_shutdown,
 };
 static struct irq_controller user_irq_controller = {
 	.name		= "user",
 	.lock		= SPIN_LOCK_UNLOCKED,
 	.startup	= m68k_irq_startup,
 	.shutdown	= m68k_irq_shutdown,
 };
 #define NUM_IRQ_NODES 100
 static irq_node_t nodes[NUM_IRQ_NODES];
 /*
  * void init_IRQ(void)
  *
  * Parameters:	None
  *
  * Returns:	Nothing
  *
  * This function should be called during kernel startup to initialize
  * the IRQ handling routines.
  */
 void __init init_IRQ(void)
 {
 	int i;
 	/* assembly irq entry code relies on this... */
 	if (HARDIRQ_MASK != 0x00ff0000) {
 		extern void hardirq_mask_is_broken(void);
 		hardirq_mask_is_broken();
 	}
 	for (i = IRQ_AUTO_1; i <= IRQ_AUTO_7; i++)
 		irq_controller[i] = &auto_irq_controller;
 	mach_init_IRQ();
 }
 /**
  * m68k_setup_auto_interrupt
  * @handler: called from auto vector interrupts
  *
  * setup the handler to be called from auto vector interrupts instead of the
  * standard __m68k_handle_int(), it will be called with irq numbers in the range
  * from IRQ_AUTO_1 - IRQ_AUTO_7.
  */
 void __init m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *))
 {
 	if (handler)
 		*auto_irqhandler_fixup = (u32)handler;
 	flush_icache();
 }
 /**
  * m68k_setup_user_interrupt
  * @vec: first user vector interrupt to handle
  * @cnt: number of active user vector interrupts
  * @handler: called from user vector interrupts
  *
  * setup user vector interrupts, this includes activating the specified range
  * of interrupts, only then these interrupts can be requested (note: this is
  * different from auto vector interrupts). An optional handler can be installed
  * to be called instead of the default __m68k_handle_int(), it will be called
  * with irq numbers starting from IRQ_USER.
  */
 void __init m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
 				      void (*handler)(unsigned int, struct pt_regs *))
 {
 	int i;
+	BUG_ON(IRQ_USER + cnt >= NR_IRQS);
 	m68k_first_user_vec = vec;
 	for (i = 0; i < cnt; i++)
 		irq_controller[IRQ_USER + i] = &user_irq_controller;
 	*user_irqvec_fixup = vec - IRQ_USER;
 	if (handler)
 		*user_irqhandler_fixup = (u32)handler;
 	flush_icache();
 }
 /**
  * m68k_setup_irq_controller
  * @contr: irq controller which controls specified irq
  * @irq: first irq to be managed by the controller
  *
  * Change the controller for the specified range of irq, which will be used to
  * manage these irq. auto/user irq already have a default controller, which can
  * be changed as well, but the controller probably should use m68k_irq_startup/
  * m68k_irq_shutdown.
  */
 void m68k_setup_irq_controller(struct irq_controller *contr, unsigned int irq,
 			       unsigned int cnt)
 {
 	int i;
 	for (i = 0; i < cnt; i++)
 		irq_controller[irq + i] = contr;
 }
 irq_node_t *new_irq_node(void)
 {
 	irq_node_t *node;
 	short i;
 	for (node = nodes, i = NUM_IRQ_NODES-1; i >= 0; node++, i--) {
 		if (!node->handler) {
 			memset(node, 0, sizeof(*node));
 			return node;
 		}
 	}
 	printk ("new_irq_node: out of nodes\n");
 	return NULL;
 }
 int setup_irq(unsigned int irq, struct irq_node *node)
 {
 	struct irq_controller *contr;
 	struct irq_node **prev;
 	unsigned long flags;
 	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
 		printk("%s: Incorrect IRQ %d from %s\n",
 		       __FUNCTION__, irq, node->devname);
 		return -ENXIO;
 	}
 	spin_lock_irqsave(&contr->lock, flags);
 	prev = irq_list + irq;
 	if (*prev) {
 		/* Can't share interrupts unless both agree to */
 		if (!((*prev)->flags & node->flags & IRQF_SHARED)) {
 			spin_unlock_irqrestore(&contr->lock, flags);
 			return -EBUSY;
 		}
 		while (*prev)
 			prev = &(*prev)->next;
 	}
 	if (!irq_list[irq]) {
 		if (contr->startup)
 			contr->startup(irq);
 		else
 			contr->enable(irq);
 	}
 	node->next = NULL;
 	*prev = node;
 	spin_unlock_irqrestore(&contr->lock, flags);
 	return 0;
 }
 int request_irq(unsigned int irq,
 		irq_handler_t handler,
 		unsigned long flags, const char *devname, void *dev_id)
 {
 	struct irq_node *node;
 	int res;
 	node = new_irq_node();
 	if (!node)
 		return -ENOMEM;
 	node->handler = handler;
 	node->flags   = flags;
 	node->dev_id  = dev_id;
 	node->devname = devname;
 	res = setup_irq(irq, node);
 	if (res)
 		node->handler = NULL;
 	return res;
 }
 EXPORT_SYMBOL(request_irq);
 void free_irq(unsigned int irq, void *dev_id)
 {
 	struct irq_controller *contr;
 	struct irq_node **p, *node;
 	unsigned long flags;
 	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
 		printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
 		return;
 	}
 	spin_lock_irqsave(&contr->lock, flags);
 	p = irq_list + irq;
 	while ((node = *p)) {
 		if (node->dev_id == dev_id)
 			break;
 		p = &node->next;
 	}
 	if (node) {
 		*p = node->next;
 		node->handler = NULL;
 	} else
 		printk("%s: Removing probably wrong IRQ %d\n",
 		       __FUNCTION__, irq);
 	if (!irq_list[irq]) {
 		if (contr->shutdown)
 			contr->shutdown(irq);
 		else
 			contr->disable(irq);
 	}
 	spin_unlock_irqrestore(&contr->lock, flags);
 }
 EXPORT_SYMBOL(free_irq);
 void enable_irq(unsigned int irq)
 {
 	struct irq_controller *contr;
 	unsigned long flags;
 	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
 		printk("%s: Incorrect IRQ %d\n",
 		       __FUNCTION__, irq);
 		return;
 	}
 	spin_lock_irqsave(&contr->lock, flags);
 	if (irq_depth[irq]) {
 		if (!--irq_depth[irq]) {
 			if (contr->enable)
 				contr->enable(irq);
 		}
 	} else
 		WARN_ON(1);
 	spin_unlock_irqrestore(&contr->lock, flags);
 }
 EXPORT_SYMBOL(enable_irq);
 void disable_irq(unsigned int irq)
 {
 	struct irq_controller *contr;
 	unsigned long flags;
 	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
 		printk("%s: Incorrect IRQ %d\n",
 		       __FUNCTION__, irq);
 		return;
 	}
 	spin_lock_irqsave(&contr->lock, flags);
 	if (!irq_depth[irq]++) {
 		if (contr->disable)
 			contr->disable(irq);
 	}
 	spin_unlock_irqrestore(&contr->lock, flags);
 }
 EXPORT_SYMBOL(disable_irq);
 int m68k_irq_startup(unsigned int irq)
 {
 	if (irq <= IRQ_AUTO_7)
 		vectors[VEC_SPUR + irq] = auto_inthandler;
 	else
 		vectors[m68k_first_user_vec + irq - IRQ_USER] = user_inthandler;
 	return 0;
 }
 void m68k_irq_shutdown(unsigned int irq)
 {
 	if (irq <= IRQ_AUTO_7)
 		vectors[VEC_SPUR + irq] = bad_inthandler;
 	else
 		vectors[m68k_first_user_vec + irq - IRQ_USER] = bad_inthandler;
 }
 /*
  * Do we need these probe functions on the m68k?
  *
  *  ... may be useful with ISA devices
  */
 unsigned long probe_irq_on (void)
 {
 #ifdef CONFIG_Q40
 	if (MACH_IS_Q40)
 		return q40_probe_irq_on();
 #endif
 	return 0;
 }
 EXPORT_SYMBOL(probe_irq_on);
 int probe_irq_off (unsigned long irqs)
 {
 #ifdef CONFIG_Q40
 	if (MACH_IS_Q40)
 		return q40_probe_irq_off(irqs);
 #endif
 	return 0;
 }
 EXPORT_SYMBOL(probe_irq_off);
 unsigned int irq_canonicalize(unsigned int irq)
 {
 #ifdef CONFIG_Q40
 	if (MACH_IS_Q40 && irq == 11)
 		irq = 10;
 #endif
 	return irq;
 }
 EXPORT_SYMBOL(irq_canonicalize);
 asmlinkage void m68k_handle_int(unsigned int irq)
 {
 	struct irq_node *node;
 	kstat_cpu(0).irqs[irq]++;
 	node = irq_list[irq];
 	do {
 		node->handler(irq, node->dev_id);
 		node = node->next;
 	} while (node);
 }
 asmlinkage void __m68k_handle_int(unsigned int irq, struct pt_regs *regs)
 {
 	struct pt_regs *old_regs;
 	old_regs = set_irq_regs(regs);
 	m68k_handle_int(irq);
 	set_irq_regs(old_regs);
 }
 asmlinkage void handle_badint(struct pt_regs *regs)
 {
 	kstat_cpu(0).irqs[0]++;
 	printk("unexpected interrupt from %u\n", regs->vector);
 }
 int show_interrupts(struct seq_file *p, void *v)
 {
 	struct irq_controller *contr;
 	struct irq_node *node;
 	int i = *(loff_t *) v;
 	/* autovector interrupts */
 	if (irq_list[i]) {
 		contr = irq_controller[i];
 		node = irq_list[i];
 		seq_printf(p, "%-8s %3u: %10u %s", contr->name, i, kstat_cpu(0).irqs[i], node->devname);
 		while ((node = node->next))
 			seq_printf(p, ", %s", node->devname);
 		seq_puts(p, "\n");
 	}
 	return 0;
 }
 void init_irq_proc(void)
 {
 	/* Insert /proc/irq driver here */
 }