low.h

PCI总线在DOS操作系统下的驱动程序源代码

#ifndef __LOW_H__
#define __LOW_H__

#include "typedef.h"
#include "list.h"

#define PAGE_SHIFT	12
#define PAGE_SIZE	(1UL << PAGE_SHIFT)

#define MAX_EXTEND_MEMORY_SIZE 0xfffffffcL
#define EXTEND_MEMORY_BASE 0x100000L

#define BIOS_BASE_MEMORY_SIZE 0x12
#define BIOS_EXTEND_MEMORY 0x15
#define FUNCTION_MEMORY_SIZE 0x8800
#define FUNCTION_MOVE_MEMORY 0x87

#define MASTER_PIC	 0x20             // Base Addr. Master PIC
#define SLAVE_PIC    0xa0             // Base Addr. Slave PIC
#define EOI	     0x60	      // PIC EndOfInterrupt Command

#define MY_STACK_SIZE 8192

#ifdef DEBUG_HARDWARE_INTERRUPT

	#define ZEROPAD	1		/* pad with zero */
	#define SIGN	2		/* unsigned/signed long */
	#define PLUS	4		/* show plus */
	#define SPACE	8		/* space if plus */
	#define LEFT	16		/* left justified */
	#define SPECIAL	32		/* 0x */
	#define LARGE	64

#endif

struct LDT {
	char a[16];
	unsigned short src_size;
	unsigned short src_base_0_15;
	unsigned char src_base_16_23;
	unsigned char src_attr;
	unsigned char src_seg_limit_hi;
	unsigned char src_base_24_31;
	unsigned short dest_size;
	unsigned short dest_base_0_15;
	unsigned char dest_base_16_23;
	unsigned char dest_attr;
	unsigned char dest_seg_limit_hi;
	unsigned char dest_base_24_31;
	unsigned char c[16];
	unsigned char d[16];
};

#define ROUND_UP(x, a)		((((unsigned long)(x)) + ((unsigned long)(a)) - 1L) & ~(((unsigned long)(a)) - 1L))

#define MATH_ROUND_UP(x)    (((double)(x) >= 0.5)?((double)(x) + 1.0):((double)(x))

#define ROUND_UP_TICK_COUNT(ms) ((unsigned long)MATH_ROUND_UP((double)ms / 54.95)))

struct TickCountVal {
	unsigned long start;
	unsigned long end;
};

typedef struct {
	void far * p_start;
	void far * p_align;
	u32 abs_addr;
} align_pointer;

typedef struct { 
	long count;
} atomic_t;

#define ATOMIC_INIT(i)	{ (i) }

/**
 * atomic_read - read atomic variable
 * @v: pointer of type atomic_t
 * 
 * Atomically reads the value of @v.  Note that the guaranteed
 * useful range of an atomic_t is only 24 bits.
 */ 
#define atomic_read(v)		((v)->count)

/**
 * atomic_set - set atomic variable
 * @v: pointer of type atomic_t
 * @i: required value
 * 
 * Atomically sets the value of @v to @i.  Note that the guaranteed
 * useful range of an atomic_t is only 24 bits.
 */ 
#define atomic_set(v,i)		(((v)->count) = (i))

#define atomic_equal(v1,v2)     (((v1)->count) == ((v2)->count))

void atomic_add(long i,atomic_t far * v);
void atomic_sub(long i,atomic_t far * v);
long atomic_sub_and_test(long i,atomic_t far * v);
void atomic_inc(atomic_t far * v);
long atomic_dec_and_test(atomic_t far * v);
void atomic_dec(atomic_t far * v);
long atomic_inc_and_test(atomic_t far * v);

struct irq_action {
	struct list_head node;	
	void (_far *handler)(long irq,void far * __hcd);
	void far * __hcd;
};

struct irq_table {
	struct list_head irq_action_list;	
	unsigned short vect_num;
	void (_interrupt _far * old_handler)(void);
	void (_interrupt _far * new_handler)(void);
};

#define irq_action_a(n) list_entry(n, struct irq_action, node)

#define irq_for_each_action(action,irq) \
for(action = irq_action_a(global_irq_table[irq].irq_action_list.next); \
action != irq_action_a(&(global_irq_table[irq].irq_action_list)); \
action = irq_action_a(action->node.next))

struct event_item {
	struct list_head node;	

	void (_far *event_handler)(void far * priv);
	void  far * priv;

	enum {
		EVENT_TIMER,
		EVENT_THREAD,
		EVENT_TASKLET
	} event_type;

	unsigned long tick_count_limit;
	unsigned long tick_count;
	unsigned short is_active : 1;
	unsigned short is_skip : 1;

	void (_far *event_handler_bak)(void far * priv);

	void  far * priv_bak;

	unsigned long * pid;
};

#define event_item_i(n) list_entry(n, struct event_item, node)

struct TimerDef {
	unsigned long tick_count_limit;
	void (_far *event_handler)(void far * priv);
	void  far * priv;
	unsigned long * pid;
};

struct ThreadDef {
	unsigned long tick_count_limit;
	void (_far *event_handler)(void far * priv);
	void  far * priv;
	unsigned long * pid;
	unsigned char is_skip;
};

struct TaskletDef {
	void (_far *event_handler)(void far * priv);
	void  far * priv;
	unsigned long * pid;
};

#define MAXEVENT 32768UL

struct eventmap {
	unsigned long eventmap[MAXEVENT / (8 * sizeof(unsigned long))];
};

unsigned long is_interrupt(void);

void local_irq_save(unsigned long irq);
void local_irq_restore(unsigned long irq);

void global_irq_save(void);
void global_irq_restore(void);

unsigned long get_base_memory_size(void);
unsigned long get_extend_memory_size(void);
void init_moveld(void);
long basemem_to_extmem(void far * p,unsigned long ext_base,unsigned short size_w);
long extmem_to_basemem(void far * p,unsigned long ext_base,unsigned short size_w);

unsigned char readb(unsigned long abs_addr);
unsigned short readw(unsigned long abs_addr);
unsigned long readl(unsigned long abs_addr);
void writeb(unsigned char b,unsigned long abs_addr);
void writew(unsigned short b,unsigned long abs_addr);
void writel(unsigned long b,unsigned long abs_addr);

u8 inb(u16 port);
u16 inw(u16 port);
u32 inl(u16 port);

void outb(u8 value,u16 port);
void outw(u16 value,u16 port);
void outl(u32 value,u16 port);

dma_addr_t ptr_to_dma(void far * p);
void far * MK_FP(unsigned long p);

void far * malloc_align(align_pointer far * p,unsigned long size,
	unsigned long align_size);
void free_align(align_pointer far * p);
void copy_align_pointer(align_pointer far * dst,align_pointer far * src);

unsigned long GetTickCount(void);
int is_reach_time_limit(struct TickCountVal far * pTickCount);
void udelay(unsigned long ms);

unsigned long ffs(unsigned long value);
unsigned long ffz(unsigned long value);

void set_bit(unsigned long nr, void far * addr);
void clear_bit(unsigned long nr,void far * addr);
void change_bit(unsigned long nr,void far * addr);
unsigned long test_and_set_bit(unsigned long nr, void far * addr);
unsigned long test_and_clear_bit(unsigned long nr,void far * addr);
unsigned long test_and_change_bit(unsigned long nr,void far * addr);
unsigned long find_next_zero_bit(void * addr,unsigned long size, unsigned long offset);

#define find_first_zero_bit(addr, size) \
	find_next_zero_bit((addr), (size), 0)

void common_new_handler(long irq);
void _interrupt new_handler_0(void);
void _interrupt new_handler_1(void);
void _interrupt new_handler_2(void);
void _interrupt new_handler_3(void);
void _interrupt new_handler_4(void);
void _interrupt new_handler_5(void);
void _interrupt new_handler_6(void);
void _interrupt new_handler_7(void);
void _interrupt new_handler_8(void);
void _interrupt new_handler_9(void);
void _interrupt new_handler_10(void);
void _interrupt new_handler_11(void);
void _interrupt new_handler_12(void);
void _interrupt new_handler_13(void);
void _interrupt new_handler_14(void);
void _interrupt new_handler_15(void);

void init_irq_table(void);
long request_irq(long irq, void (far * hcd_irq)(long,void far *), void far * hcd);
void free_irq(long irq,void far * hcd);

void interrupt far new_int1c_handler(void);
void interrupt far new_int8_handler(void);
void init_event_handling(void);
void cleanup_evevnt_handling(void);
struct event_item far * add_event(enum event_type type,unsigned long limit,
	void (_far * handler)(void far * priv),void far * priv,unsigned char is_active,
	unsigned char is_skip,unsigned long * pid);
void internal_remove_event(struct event_item far * item);
long register_timer(struct TimerDef far * timer_def);
int timer_pending(struct TimerDef far * timer_def);
long register_thread(struct ThreadDef far * thread_def);
long register_tasklet(struct TaskletDef far * tasklet_def);
void unregister_event(unsigned long id,
       void (_far * handler)(void far * priv),
       void far * priv);

long check_item_valid(struct event_item far * item);

void copy_thread_def(struct ThreadDef far * p_thread_def,struct event_item far * item);

void event_loop(void);

long schedule_timeout(unsigned long timeout,int (* check_status)(void far * priv),
	void far * priv);

void SendEOI(unsigned short irq);
void EnableIRQ(unsigned short irq);
void DisableIRQ(unsigned short irq);

void zero_is_chain(void);

void AddLogToXms(const char _FAR_ * szFmt, ...);

void safe_printf(const char _FAR_ * szFmt, ...);

#ifdef DEBUG_HARDWARE_INTERRUPT

struct XMSSTRU
{
   unsigned long lLength;
   unsigned short iSrcHandle;
   unsigned long lSrcOff;
   unsigned short iDestHandle;
   unsigned long lDestOff;
};

void interrupt far new_flush_handler(void);

long skip_atoi(char **s);
unsigned long strnlen(char far * string,unsigned long count);
unsigned do_div(unsigned long * pnum,unsigned short base);
char * number(char * buf, char * end, long num, long base, long size, long precision, 
	long type);
long vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
long my_vsprintf(char *buf, const char *fmt, va_list args);

long XMSExist(void);
int IsXmsExist(void);
long XMS_GetFreeSize(unsigned long * pMaxFree,unsigned long * pMaxTotal);
long XMS_Alloc(unsigned long XmsSize, unsigned short * pXmsHandle);
long XMS_Free(unsigned short XmsHandle);
long XMS_Lock(unsigned short XmsHandle, unsigned long * pAbsAddr);
long XMS_Unlock(unsigned short XmsHandle);
long movexms1(struct XMSSTRU far * psXmsStru);
long XMS_Move(struct XMSSTRU * psXmsStru);
long XMS_StoreToXMS(unsigned char far * pcStr, unsigned short MemHandle, 
	unsigned long lOffset, short Length);
long XMS_LoadFromXMS(unsigned short MemHandle, unsigned long lOffset, 
	unsigned char far * pcStr, short Length);
void InitLog(unsigned short begin_count,unsigned short end_count);
void CleanupLog(void);
void FlushLog(void);

void BeginLog(void);
void EndLog(void);
void UnCheckLog(void);

#endif

#endif