2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* \file drm_os_linux.h
|
|
|
|
* OS abstraction macros.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/interrupt.h> /* For task queue support */
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
2009-02-26 07:12:10 +07:00
|
|
|
#ifndef readq
|
2009-03-31 11:14:39 +07:00
|
|
|
static inline u64 readq(void __iomem *reg)
|
2009-02-26 07:12:10 +07:00
|
|
|
{
|
|
|
|
return ((u64) readl(reg)) | (((u64) readl(reg + 4UL)) << 32);
|
|
|
|
}
|
|
|
|
|
2009-03-31 11:14:39 +07:00
|
|
|
static inline void writeq(u64 val, void __iomem *reg)
|
2009-02-26 07:12:10 +07:00
|
|
|
{
|
|
|
|
writel(val & 0xffffffff, reg);
|
|
|
|
writel(val >> 32, reg + 0x4UL);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/** Current process ID */
|
2007-10-19 13:40:40 +07:00
|
|
|
#define DRM_CURRENTPID task_pid_nr(current)
|
2005-11-12 17:52:46 +07:00
|
|
|
#define DRM_SUSER(p) capable(CAP_SYS_ADMIN)
|
2005-04-17 05:20:36 +07:00
|
|
|
#define DRM_UDELAY(d) udelay(d)
|
|
|
|
/** Read a byte from a MMIO region */
|
|
|
|
#define DRM_READ8(map, offset) readb(((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Read a word from a MMIO region */
|
|
|
|
#define DRM_READ16(map, offset) readw(((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Read a dword from a MMIO region */
|
|
|
|
#define DRM_READ32(map, offset) readl(((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Write a byte into a MMIO region */
|
|
|
|
#define DRM_WRITE8(map, offset, val) writeb(val, ((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Write a word into a MMIO region */
|
|
|
|
#define DRM_WRITE16(map, offset, val) writew(val, ((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Write a dword into a MMIO region */
|
|
|
|
#define DRM_WRITE32(map, offset, val) writel(val, ((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Read memory barrier */
|
2009-02-26 07:12:10 +07:00
|
|
|
|
|
|
|
/** Read a qword from a MMIO region - be careful using these unless you really understand them */
|
|
|
|
#define DRM_READ64(map, offset) readq(((void __iomem *)(map)->handle) + (offset))
|
|
|
|
/** Write a qword into a MMIO region */
|
|
|
|
#define DRM_WRITE64(map, offset, val) writeq(val, ((void __iomem *)(map)->handle) + (offset))
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define DRM_READMEMORYBARRIER() rmb()
|
|
|
|
/** Write memory barrier */
|
|
|
|
#define DRM_WRITEMEMORYBARRIER() wmb()
|
|
|
|
/** Read/write memory barrier */
|
|
|
|
#define DRM_MEMORYBARRIER() mb()
|
|
|
|
|
|
|
|
/** IRQ handler arguments and return type and values */
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
#define DRM_IRQ_ARGS int irq, void *arg
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/** AGP types */
|
|
|
|
#if __OS_HAS_AGP
|
|
|
|
#define DRM_AGP_MEM struct agp_memory
|
|
|
|
#define DRM_AGP_KERN struct agp_kern_info
|
|
|
|
#else
|
|
|
|
/* define some dummy types for non AGP supporting kernels */
|
|
|
|
struct no_agp_kern {
|
2005-09-25 11:28:13 +07:00
|
|
|
unsigned long aper_base;
|
|
|
|
unsigned long aper_size;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
#define DRM_AGP_MEM int
|
|
|
|
#define DRM_AGP_KERN struct no_agp_kern
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/** Other copying of data to kernel space */
|
|
|
|
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
|
|
|
|
copy_from_user(arg1, arg2, arg3)
|
|
|
|
/** Other copying of data from kernel space */
|
|
|
|
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
|
|
|
|
copy_to_user(arg1, arg2, arg3)
|
|
|
|
|
|
|
|
#define DRM_HZ HZ
|
|
|
|
|
|
|
|
#define DRM_WAIT_ON( ret, queue, timeout, condition ) \
|
|
|
|
do { \
|
|
|
|
DECLARE_WAITQUEUE(entry, current); \
|
|
|
|
unsigned long end = jiffies + (timeout); \
|
|
|
|
add_wait_queue(&(queue), &entry); \
|
|
|
|
\
|
|
|
|
for (;;) { \
|
|
|
|
__set_current_state(TASK_INTERRUPTIBLE); \
|
|
|
|
if (condition) \
|
|
|
|
break; \
|
|
|
|
if (time_after_eq(jiffies, end)) { \
|
|
|
|
ret = -EBUSY; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
schedule_timeout((HZ/100 > 1) ? HZ/100 : 1); \
|
|
|
|
if (signal_pending(current)) { \
|
|
|
|
ret = -EINTR; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
__set_current_state(TASK_RUNNING); \
|
|
|
|
remove_wait_queue(&(queue), &entry); \
|
|
|
|
} while (0)
|
|
|
|
|
2009-09-16 03:57:32 +07:00
|
|
|
#define DRM_WAKEUP( queue ) wake_up( queue )
|
2005-04-17 05:20:36 +07:00
|
|
|
#define DRM_INIT_WAITQUEUE( queue ) init_waitqueue_head( queue )
|