rtai.c

rtai-3.1-test3的源代码(Real-Time Application Interface )

/* arch/arm/rtai.c
COPYRIGHT (C) 2001 Paolo Mantegazza ([e-mail])
COPYRIGHT (C) 2001 Alex Z黳ke, SYSGO RTS GmbH ([e-mail])
COPYRIGHT (C) 2002 Wolfgang M黮ler ([e-mail])
COPYRIGHT (C) 2002 Guennadi Liakhovetski, DSA GmbH ([e-mail])
COPYRIGHT (C) 2002 Thomas Gleixner ([e-mail])

This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.

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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
/*
--------------------------------------------------------------------------
Changelog

03-10-2002	TG	added support for trap handling.
			added function rt_is_linux.

11-07-2003	GL	First of a series of fixes, proposed by Thomas
			Gleixner. Disable interrupts on return from
			dispatch_[irq|srq]().

12-07-2003	GL	Move closer to Linux. Remove re-declaration
			of irq_desc, replace IBIT with Linux' I_BIT,
			remove unneeded rtai_irq_t type.

21-07-2003	GL	Fix a race in linux_sti(), created by making
			linux_sti() re-entrant.

28-07-2003	GL	Improve handling of pending interrupts to Linux,
			put debugging BUG() statement, idea of which
			belongs to Thomas Gleixner.

29-07-2003	GL	Initial support for 2.4.19-rmk7 for StrongARM.

28-08-2003	GL	Use native Linux masking for linux-only
			interrupts. Handle unmasking of RTAI-Linux
			shared interrupts, deliver them, if new
			ones arrived, while the interrupt line
			was masked by Linux.
*/

#include <linux/config.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/compiler.h>

#include <asm/system.h>
#include <asm/smp.h>
#include <asm/io.h>
#include <linux/bitops.h>
#include <asm/atomic.h>

#ifdef CONFIG_PROC_FS
#include <linux/stat.h>
#include <linux/proc_fs.h>
#include <rtai_proc_fs.h>
#endif

#include <asm/rtai.h>
#include <asm/rtai_srq.h>
#include <rtai_version.h>
#include <rtai_trace.h>

#undef CONFIG_RTAI_MOUNT_ON_LOAD

// proc filesystem additions.
#ifdef CONFIG_PROC_FS
static int rtai_proc_register(void);
static void rtai_proc_unregister(void);
#endif
// End of proc filesystem additions.

/* Some define */

#define NR_SYSRQS  	 	32
#define NR_TRAPS		32

/* these are prototypes for timer-handling abstraction */
extern void linux_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs);
extern void soft_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs);

struct global_rt_status {
	volatile unsigned int used_by_linux;
	volatile unsigned int locked_cpus;
	volatile int irq_in, irq_out, lost_irqs;
	volatile rtai_irq_mask_t pending_srqs;
	volatile rtai_irq_mask_t active_srqs;
	struct list_head pending_linux_irq;
	spinlock_t data_lock;
	spinlock_t ic_lock;
};

static struct global_rt_status global __attribute__ ((aligned(32)));

volatile unsigned int *locked_cpus = &global.locked_cpus;

/* VERY IMPORTANT, since I saw no way to just ack, we mask_ack always, so	*/
/* it is likely we have to recall to set an arch dependent call to unmask	*/
/* in the scheduler timer handler. Other arch allow just to ack, maybe we'll	*/
/* we can get along as it is now, let's recall this point.			*/

#include <asm/mach/irq.h>

extern struct irqdesc irq_desc[];

#include <asm/rtai_irqops.h>

/* Most of our data */

static struct irq_handling {
	void (*handler)(int irq, void *dev_id, struct pt_regs *regs);
	void *dev_id;
	unsigned long count;
} global_irq[NR_IRQS] __attribute__ ((__aligned__(32)));

static struct irqdesc shadow_irq_desc[NR_IRQS];

static struct sysrq_t {
	unsigned int label;
	void (*rtai_handler)(void);
	long long (*user_handler)(unsigned int whatever);
} sysrq[NR_SYSRQS];

static RT_TRAP_HANDLER rtai_trap_handler[NR_TRAPS];

// The main items to be saved-restored to make Linux our humble slave

static struct rt_hal linux_rthal;

static struct pt_regs rtai_regs;  // Dummy registers.

static void *saved_timer_action_handler; // Saved timer-action handler

static struct cpu_own_status {
	volatile unsigned int intr_flag;
	volatile unsigned int linux_intr_flag;
	volatile rtai_irq_mask_t pending_irqs;
	volatile rtai_irq_mask_t active_irqs;
} processor[NR_RT_CPUS];

void send_ipi_shorthand(unsigned int shorthand, unsigned int irq) { }

void send_ipi_logical(unsigned long dest, unsigned int irq) { }

//static void hard_lock_all_handler(void) { }

volatile union rtai_tsc rtai_tsc;

static void linux_cli(void)
{
	processor[hard_cpu_id()].intr_flag = 0;
}

static void (*ic_mask_ack_irq[NR_IRQS])(unsigned int irq);
static void (*ic_mask_irq[NR_IRQS])(unsigned int irq);
static void (*ic_unmask_irq[NR_IRQS])(unsigned int irq);

/**
 * linux_sti() must be re-entrant.
 */
static void linux_sti(void)
{
	unsigned int irq;
	unsigned long flags;
	unsigned long cpuid;
	struct cpu_own_status *cpu;

	cpu = processor + (cpuid = hard_cpu_id());

	hard_save_flags(flags);
	if (unlikely(flags & I_BIT)) {
		hard_sti();
		BUG();
	}

	rt_spin_lock_irq(&(global.data_lock));
	while (have_pending_irq() != NO_IRQ || have_pending_srq()) {
		cpu->intr_flag = 0; /* cli */
		while ((irq = have_pending_irq()) != NO_IRQ) {
			struct irqdesc *desc = irq_desc + irq;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,19)
			if (desc->pending || desc->disable_depth || ! list_empty(&desc->pend)) {
				printk(KERN_CRIT "IRQ %d: pending %d, disable_depth %d, running %d, list %sempty\n",
				       irq, desc->pending, desc->disable_depth, desc->running,
				       list_empty(&desc->pend) ? "" : "not ");
				BUG();
			}
#else
			if (! desc->enabled) {
				printk(KERN_CRIT "IRQ %d: disabled\n", irq);
				BUG();
			}
#endif

			clear_pending_irq(irq);
			/* Emulate Linux behaviour, i.e. serve multiplexed interrupts 1 at a time */
			if (isdemuxirq(irq))
				irq_desc[ARCH_MUX_IRQ].running = 1;
			rt_spin_unlock_irq(&(global.data_lock));

			// ** call old Linux do_IRQ() to handle IRQ
			linux_rthal.do_IRQ(irq, &rtai_regs);

			/* Unmasking is done in do_IRQ above - don't do twice */
			rt_spin_lock_irq(&(global.data_lock));
			if (isdemuxirq(irq))
				irq_desc[ARCH_MUX_IRQ].running = 0;
		}

		// Local IRQ Handling - missing here ... only on SMP

		cpu->intr_flag = I_BIT | (1 << cpuid); // sti()
		if (have_pending_srq()) {
			// SRQ Handling - same as on PPC
			irq = pending_srq();
			activate_srq(irq);
			clear_pending_srq(irq);
			rt_spin_unlock_irq(&(global.data_lock));
			if (sysrq[irq].rtai_handler) {
				sysrq[irq].rtai_handler();
			}
			rt_spin_lock_irq(&(global.data_lock));
			deactivate_srq(irq);
		}
	}
	rt_spin_unlock_irq(&(global.data_lock));
	cpu->intr_flag = I_BIT | (1 << cpuid);
}

/* we need to return faked, but real flags
 *
 * imagine a function calling our linux_save_flags() while rtai is loaded
 * and restoring flags when rtai is unloaded. CPSR is broken ...
 */
static unsigned int linux_save_flags(void)
{
	unsigned long flags;

	hard_save_flags( flags );
	/* check if we are in CLI, then set I bit in flags */
	return (flags & ~I_BIT) | ( processor[hard_cpu_id()].intr_flag ? 0 : I_BIT );
}

static void linux_restore_flags(unsigned int flags)
{
	/* check if CLI-bit is set */
	if (flags & I_BIT) {
		processor[hard_cpu_id()].intr_flag = 0;
	} else {
		linux_sti();
	}
}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21)
static unsigned int linux_save_flags_sti(void)
{
	unsigned long flags;

	flags = linux_save_flags();
	linux_sti();
	return flags;
}
#endif

unsigned int linux_save_flags_and_cli(void)
{
	unsigned long flags;

	flags = linux_save_flags();
        processor[hard_cpu_id()].intr_flag = 0;
	return flags;
}

unsigned long linux_save_flags_and_cli_cpuid(int cpuid)
{
	return linux_save_flags_and_cli();
}

void rtai_just_copy_back(unsigned long flags, int cpuid)
{
	/* also check if CLI-bit is set and set up intr_flag accordingly */
	if (flags & I_BIT) {
	        processor[cpuid].intr_flag = 0;
	} else {
	        processor[cpuid].intr_flag = I_BIT | (1 << cpuid);
	}
}

// For the moment we just do mask_ack_unmask, maybe it has to be adjusted

static void do_nothing_picfun(unsigned int irq) { }
static void linux_mask_ack(unsigned int irq)
{
	irq_desc[irq].masked = 1;
}

unsigned int rt_startup_irq(unsigned int irq)
{
	unsigned int flags;
	struct irqdesc *irq_desc;

	if ((irq_desc = &shadow_irq_desc[irq])/* && irq_desc->unmask*/) {
		flags = rt_spin_lock_irqsave(&global.ic_lock);
		irq_desc->probing = 0;
		irq_desc->triggered = 0;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
		irq_desc->enabled = 1;
#else
		irq_desc->disable_depth = 0;
#endif
		irq_desc->unmask(irq);
		rt_spin_unlock_irqrestore(flags, &global.ic_lock);
	}
	return 0;
}

void rt_shutdown_irq(unsigned int irq)
{
	unsigned int flags;
	struct irqdesc *irq_desc;

	if ((irq_desc = &shadow_irq_desc[irq])) {
		flags = rt_spin_lock_irqsave(&global.ic_lock);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
		irq_desc->enabled = 0;
#else
		irq_desc->disable_depth = (unsigned int)-1;
#endif
		irq_desc->mask(irq);
		rt_spin_unlock_irqrestore(flags, &global.ic_lock);
	}
}

void rt_enable_irq(unsigned int irq)
{
	unsigned int flags;
	struct irqdesc *irq_desc;

	if ((irq_desc = &shadow_irq_desc[irq])) {
		flags = rt_spin_lock_irqsave(&global.ic_lock);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
		irq_desc->probing = 0;
		irq_desc->triggered = 0;
		irq_desc->enabled = 1;
		ic_unmask_irq[irq](irq);
#else
		if ( ! irq_desc->disable_depth ) {
			printk("enable_irq(%u) unbalanced from %p\n", irq, __builtin_return_address(0));
		} else if ( ! --irq_desc->disable_depth ) {
			irq_desc->probing = 0;
			ic_unmask_irq[irq](irq);
		}
#endif
		rt_spin_unlock_irqrestore(flags, &global.ic_lock);
	}
}

void rt_disable_irq(unsigned int irq)
{
	unsigned int flags;
	struct irqdesc *irq_desc;

	if ((irq_desc = &shadow_irq_desc[irq])) {
		flags = rt_spin_lock_irqsave(&global.ic_lock);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
		irq_desc->enabled = 0;
		ic_mask_irq[irq](irq);
#else
		if ( ! irq_desc->disable_depth++ )
			ic_mask_irq[irq](irq);
#endif
		rt_spin_unlock_irqrestore(flags, &global.ic_lock);
	}
}

void rt_mask_ack_irq(unsigned int irq)
{
	unsigned int flags;

	flags = rt_spin_lock_irqsave(&global.ic_lock);
	ic_mask_ack_irq[irq](irq);
	rt_spin_unlock_irqrestore(flags, &global.ic_lock);
}

void rt_mask_irq(unsigned int irq)
{
	unsigned int flags;

	flags = rt_spin_lock_irqsave(&global.ic_lock);
	ic_mask_irq[irq](irq);
	rt_spin_unlock_irqrestore(flags, &global.ic_lock);
}

void rt_unmask_irq(unsigned int irq)
{
	unsigned int flags;

	flags = rt_spin_lock_irqsave(&global.ic_lock);
	ic_unmask_irq[irq](irq);
	rt_spin_unlock_irqrestore(flags, &global.ic_lock);
}

/*
 * A real time handler must unmask ASAP. Especially important for the timer
 * ISR. When RTAI is mounted, this should be done in the macro
 * DO_TIMER_PROPER_OP(), called on entry to the rt_timer_handler().
 */
asmlinkage void dispatch_irq(int irq, struct pt_regs *regs)
{
	rt_spin_lock(&global.ic_lock);

	if (irq >= 0 && irq < NR_IRQS) {
		ic_mask_ack_irq[irq](irq);
		irq_desc[irq].masked = 0;
		rt_spin_unlock(&global.ic_lock);

		TRACE_RTAI_GLOBAL_IRQ_ENTRY(irq, !user_mode(regs));

		// We just care about our own RT-Handlers installed

		if (global_irq[irq].handler) {
			/* If this interrupt happened in Linux, in the rt-handler below
			   we might context-switch to rt, and then back to Linux, at which
			   point linux_sti() might be called - which is a bit early yet.
			   Prevent it. */
			unsigned long flags = linux_save_flags_and_cli();
			global_irq[irq].count++;
			global_irq[irq].handler(irq, global_irq[irq].dev_id, regs);

			rtai_just_copy_back(flags, hard_cpu_id());
			rt_spin_lock_irq(&(global.data_lock));
			/* The timer interrupt should be unmasked in the handler, due
			   to RTAI's prioritisation of RT-tasks. Linux has a handler-flag
			   to mark handlers, that want their interrupts to be unmasked
			   immediately (hint). */
			ic_unmask_irq[irq](irq);
		} else {
			rt_spin_lock(&(global.data_lock));
			rt_pend_linux_irq(irq);
		}

		if (! isdemuxirq(irq) && (global.used_by_linux & processor[hard_cpu_id()].intr_flag)) {
			linux_cli();
			rt_spin_unlock_irq(&(global.data_lock));
			linux_sti();
		} else {
			rt_spin_unlock(&(global.data_lock));
		}
		TRACE_RTAI_GLOBAL_IRQ_EXIT();
	} else {
		rt_spin_unlock(&global.ic_lock);
		printk(KERN_ERR "RTAI-IRQ: spurious interrupt 0x%02x\n", irq);
	}
	hard_cli();
}

#define MIN_IDT_VEC 0xF0
#define MAX_IDT_VEC 0xFF

static unsigned long long (*idt_table[MAX_IDT_VEC - MIN_IDT_VEC + 1])(unsigned int srq, unsigned long name);

asmlinkage long long dispatch_srq(int srq, unsigned long whatever)
{
	unsigned long vec;
	long long retval = -1;

	if (!(vec = srq >> 24)) {
		TRACE_RTAI_SRQ_ENTRY(srq, 0);
		if (srq > 1 && srq < NR_SYSRQS && sysrq[srq].user_handler) {
			retval = sysrq[srq].user_handler(whatever);
		} else {
			for (srq = 2; srq < NR_SYSRQS; srq++) {
				if (sysrq[srq].label == whatever) {
					retval = srq;
				}
			}
		}
		TRACE_RTAI_SRQ_EXIT();
	} else {
		if ((vec >= MIN_IDT_VEC) && (vec <= MAX_IDT_VEC) && (idt_table[vec - MIN_IDT_VEC])) {
			TRACE_RTAI_SRQ_ENTRY(srq, 0);
			retval = idt_table[vec - MIN_IDT_VEC](srq & 0xFFFFFF, whatever);
			TRACE_RTAI_SRQ_EXIT();
		} else {
			printk("RTAI SRQ DISPATCHER: bad srq (0x%0x)\n", (int) vec);
		}
	}
	hard_cli();
	return retval;
}

struct desc_struct rt_set_full_intr_vect(unsigned int vector, int type, int dpl, void *handler)
{
	struct desc_struct fun = { 0 };
	if (vector >= MIN_IDT_VEC && vector <= MAX_IDT_VEC) {
		fun.fun = idt_table[vector - MIN_IDT_VEC];
		idt_table[vector - MIN_IDT_VEC] = handler;
		if (!rthal.do_SRQ) {
			rthal.do_SRQ = dispatch_srq;
		}
	}
	return fun;
}

void rt_reset_full_intr_vect(unsigned int vector, struct desc_struct idt_element)
{
	if (vector >= MIN_IDT_VEC && vector <= MAX_IDT_VEC) {
		idt_table[vector - MIN_IDT_VEC] = idt_element.fun;
	}
}

/*
 *	Dispatch Traps like Illegal instruction, ....
 *	Keep call compatible to x386 
 */
asmlinkage int dispatch_trap(int vector, struct pt_regs *regs)
{
	if ( (vector < NR_TRAPS) && (rtai_trap_handler[vector]) ) 
		return rtai_trap_handler[vector](vector, vector, regs, NULL);

	return 1;	/* Let Linux do the job */
}

RT_TRAP_HANDLER rt_set_rtai_trap_handler(int trap, RT_TRAP_HANDLER handler)
{
        RT_TRAP_HANDLER old_handler = NULL;

	if (trap < NR_TRAPS) {
		old_handler = rtai_trap_handler[trap];