kernelcalls.c

1. 8623L平台

	wait_queue_head_t *trueq;
	trueq = (wait_queue_head_t *) vmalloc(sizeof(wait_queue_head_t));
	init_waitqueue_head(trueq);

	*q = (struct kc_wait_queue_head_t *) trueq;
}

/** free the memory used by a waitqueue_head
 * @param q pointer to the struct kc_wait_queue_head_t to free
 */
EXPORT_SYMBOL(kc_deinit_waitqueue_head);
void kc_deinit_waitqueue_head(struct kc_wait_queue_head_t *q)
{
	vfree(q);
}

/** wake_up_interruptible abstraction
 * ...
 */
EXPORT_SYMBOL(kc_wake_up_interruptible);
void kc_wake_up_interruptible(struct kc_wait_queue_head_t *q)
{
	wake_up_interruptible((wait_queue_head_t *) q);
}

/** interruptible_sleep_on_timeout abstraction
 * ...
 */
EXPORT_SYMBOL(kc_interruptible_sleep_on_timeout);
long kc_interruptible_sleep_on_timeout(struct kc_wait_queue_head_t *q,
				       signed long timeout)
{
	if (timeout == 0) return 0;
	return interruptible_sleep_on_timeout((wait_queue_head_t *) q, timeout);
}

/** signal_pending abstraction for current process
 * ...
 */
EXPORT_SYMBOL(kc_signal_pending_current);
int kc_signal_pending_current()
{
	return signal_pending(current);
}

/** get current pid
 */
EXPORT_SYMBOL(kc_currentpid);
int kc_currentpid()
{
	return current->pid;
}

/** Wait for an event with given timeout
 * @param wq the wait_queue
 * @param condition the condition to wait
 * @timeout maximum wait
 * @return time remaining
 */
EXPORT_SYMBOL(kc_wait_event_interruptible_timeout);
long kc_wait_event_interruptible_timeout(struct kc_wait_queue_head_t *wq, 
					 unsigned int (*condition)(void *cookie), signed long timeout,void *cookie)
{
	long __ret = timeout;
        if (!(condition(cookie)))                       
                __wait_event_interruptible_timeout( 
			     *(wait_queue_head_t *)wq, condition(cookie), __ret);
        return __ret;
}


//
// atomic
// 

/** allocate a new atomic_t
 * @param v pointer to struct kc_atomic_t *
 */
EXPORT_SYMBOL(kc_atomic_init);
void kc_atomic_init(struct kc_atomic_t **v)
{
	atomic_t *truev;
	truev = (atomic_t *) vmalloc(sizeof(atomic_t));

	*v = (struct kc_atomic_t *) truev;
}


/** Free memory used by a struct kc_atomic_t
 * @param v struct kc_atomic_t to free
 */
EXPORT_SYMBOL(kc_atomic_deinit);
void kc_atomic_deinit(struct kc_atomic_t *v)
{
	vfree(v);
}

/** atomic_read abstraction
 * ...
 */
EXPORT_SYMBOL(kc_atomic_read);
int kc_atomic_read(struct kc_atomic_t *v)
{
	return atomic_read((atomic_t *) v);
}

/** atomic_set abstraction
 * ...
 */
EXPORT_SYMBOL(kc_atomic_set);
void kc_atomic_set(struct kc_atomic_t *v, int i)
{
	atomic_set((atomic_t *) v, i);
}


/** atomic_inc abstraction
 * ...
 */
EXPORT_SYMBOL(kc_atomic_inc);
void kc_atomic_inc(struct kc_atomic_t *v)
{
	atomic_inc((atomic_t *) v);
}


/** atomic_add_negative abstraction
 * ...
 */
EXPORT_SYMBOL(kc_atomic_add_negative);
int kc_atomic_add_negative(int i, struct kc_atomic_t *v)
{
	return atomic_add_negative(i, (atomic_t *) v);
}


/** atomic_dec_and_test abstraction
 * ...
 */
EXPORT_SYMBOL(kc_atomic_dec_and_test);
int kc_atomic_dec_and_test(struct kc_atomic_t *v)
{
	return atomic_dec_and_test((atomic_t *) v);
}

//
// bitops
// 

/** test_and_set_bit abstraction
 * ...
 */
EXPORT_SYMBOL(kc_test_and_set_bit);
int kc_test_and_set_bit(int nr, volatile void *addr)
{
	return test_and_set_bit(nr, addr);
}

/** test_and_clear_bit abstraction
 * ...
 */
EXPORT_SYMBOL(kc_test_and_clear_bit);
int kc_test_and_clear_bit(int nr, volatile void *addr)
{
	return test_and_clear_bit(nr, addr);
}

/** clear_bit abstraction
 * ...
 */
EXPORT_SYMBOL(kc_clear_bit);
void kc_clear_bit(int nr, volatile void *addr)
{
	clear_bit(nr, addr);
}

/** test_bit abstraction
 * ...
 */
EXPORT_SYMBOL(kc_test_bit);
int kc_test_bit(int nr, volatile void *addr)
{
	return test_bit(nr, (void *) addr);
}

/** set_bit abstraction
 * ...
 */
EXPORT_SYMBOL(kc_set_bit);
void kc_set_bit(int nr, volatile void *addr)
{
	set_bit(nr, addr);
}

//
// string
// 

/** memcpy abstraction
 * ...
 */
EXPORT_SYMBOL(kc_memcpy);
void *kc_memcpy(void *const dest, const void *src, unsigned long n)
{
	return memcpy(dest, src, n);
}

/** memset abstraction
 * ...
 */
EXPORT_SYMBOL(kc_memset);
void *kc_memset(void *d, int c, unsigned int l)
{
	return memset(d, c, l);
}

/** memcmp abstraction
 * ...
 */
EXPORT_SYMBOL(kc_memcmp);
int kc_memcmp(const void *d, const void *s, unsigned int l)
{
	return memcmp(d, s, l);
}

/** strncpy abstraction
 * ...
 */
EXPORT_SYMBOL(kc_strncpy);
char *kc_strncpy(char *d, const char *s, unsigned int l)
{
	return strncpy(d, s, l);
}


/** strcat abstraction
 * ...
 */
EXPORT_SYMBOL(kc_strcat);
char *kc_strcat(char *d, const char *s)
{
	return strcat(d, s);
}


/** strcpy abstraction
 * ...
 */
EXPORT_SYMBOL(kc_strcpy);
char *kc_strcpy(char *d, const char *s)
{
	return strcpy(d, s);
}

/** strlen abstraction
 * ...
 */
EXPORT_SYMBOL(kc_strlen);
unsigned int kc_strlen(const char *d)
{
	return strlen(d);
}

/** strnicmp
 * ...
 */
EXPORT_SYMBOL(kc_strnicmp);
int kc_strnicmp(const char *d, const char *s, unsigned int l)
{
	return strnicmp(d, s, l);
}

//
// tophalf & tasklet
// 


/** tasklet_init abstraction
 * ...
 */
EXPORT_SYMBOL(kc_tasklet_init);
void kc_tasklet_init(struct kc_tasklet_struct **t,
	void (*func) (unsigned long), unsigned long data)
{
	*t = (struct kc_tasklet_struct *) vmalloc(sizeof(struct tasklet_struct));
	tasklet_init((struct tasklet_struct *) *t, func, data);
}

/** free a kc_tasklet_struct
 * @param t the tasklet ro destroy
 */
EXPORT_SYMBOL(kc_tasklet_deinit);
void kc_tasklet_deinit(struct kc_tasklet_struct *t)
{
	vfree(t);
}

/** tasklet_disable abstraction
 * ...
 */
EXPORT_SYMBOL(kc_tasklet_disable);
void kc_tasklet_disable(struct kc_tasklet_struct *t)
{
	tasklet_disable((struct tasklet_struct *) t);
}


/** virt/phys/page abstraction
 * ...
 */
EXPORT_SYMBOL(kc_virt_to_page);
struct kc_page * kc_virt_to_page(unsigned long addr)
{
	return (struct kc_page *)virt_to_page((void *)addr);
}

EXPORT_SYMBOL(kc_virt_to_phys);
unsigned long kc_virt_to_phys(unsigned long addr)
{
#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
	/* virt_to_xxx can not handle uncached address correctly */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
	kcinfo("kc_virt_to_phys: virt = %p to -> phys= %p\n", addr, PHYSADDR(addr));
	return PHYSADDR((void *)addr);
#else
	kcinfo("kc_virt_to_phys: virt = %p to -> phys= %p\n", addr, CPHYSADDR(addr));
	return CPHYSADDR((void *)addr);
#endif
#else
	return (unsigned long) virt_to_phys(addr);
#endif /* (EM86XX_CHIP==EM86XX_CHIPID_TANGO2) */
}

EXPORT_SYMBOL(kc_virt_to_bus);
unsigned long kc_virt_to_bus(unsigned long addr)
{
#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
	/* virt_to_xxx can not handle uncached address correctly */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
	kcinfo("kc_virt_to_bus: virt = %p to -> bus = %p\n", addr, PHYSADDR(addr));
	return PHYSADDR((void *)addr);
#else
	kcinfo("kc_virt_to_bus: virt = %p to -> bus = %p\n", addr, CPHYSADDR(addr));
	return CPHYSADDR((void *)addr);
#endif
#else
	return (unsigned long) virt_to_bus(addr);
#endif /* (EM86XX_CHIP==EM86XX_CHIPID_TANGO2) */
}

EXPORT_SYMBOL(kc_phys_to_virt);
unsigned long kc_phys_to_virt(unsigned long addr){
#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
	/* kcinfo("kc_phys_to_virt: phys = %p to -> virt= %p\n", addr, KSEG0ADDR(addr)); */
	return KSEG0ADDR((void *)addr);
#else
	return (unsigned long) phys_to_virt(addr);
#endif /* (EM86XX_CHIP==EM86XX_CHIPID_TANGO2) */
}

//
// time
// 

/** jiffies abstraction
 * ...
 */
EXPORT_SYMBOL(kc_jiffies);
unsigned long kc_jiffies(void) { return jiffies; }

/** mdelay abstraction
 * ...
 */
EXPORT_SYMBOL(kc_mdelay);
void kc_mdelay(unsigned long n) { udelay(n*1000); }

/** udelay abstraction
 * ...
 */
EXPORT_SYMBOL(kc_udelay);
void kc_udelay(unsigned long n) { udelay(n); }

/** get time in ms
 * @return time in ms
 */
EXPORT_SYMBOL(kc_gettimems);
unsigned long kc_gettimems(void) 
{ 
	static int firsttimehere=TRUE;
	static struct timeval timeorigin;
	struct timeval now;
	
	if (firsttimehere) {
		do_gettimeofday(&timeorigin);
		firsttimehere=FALSE;
	}
	
	do_gettimeofday(&now);
	
	return (now.tv_sec-timeorigin.tv_sec)*1000+now.tv_usec/1000-timeorigin.tv_usec/1000;
}

/** get time in us
 * @return time in us
 */
EXPORT_SYMBOL(kc_gettimeus);
unsigned long long kc_gettimeus(void) 
{ 
	static int firsttimehere=TRUE;
	static struct timeval timeorigin;
	struct timeval now;
	
	if (firsttimehere) {
		do_gettimeofday(&timeorigin);
		firsttimehere=FALSE;
	}
	
	do_gettimeofday(&now);
	
	return 
		(unsigned long long)(
		 (
		  (long long)now.tv_sec
		  -(long long)timeorigin.tv_sec
		  )*1000000LL
		 +
		 ( 
		  (long long)now.tv_usec
		  -(long long)timeorigin.tv_usec
		  )
		 );
}

/** Invalidate data cache. 
 * @param pData the physical address to be flushed
 * @param size the size of the zone to flush
 */
void kc_invalidate_cache(void *pData, unsigned int size)
{
#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
                        dcache_range_i(KSEG0ADDR((unsigned long) pData), (unsigned long) size);
#else
			cpu_pt110_dcache_invalidate_range((unsigned long) pData,(unsigned long) size);
#endif

	kcinfo("cache invalidated : addr = %p, size = %lu\n", pData, size);
}


/** Flush data cache. 
 * @param pData the physical address to be flushed
 * @param size the size of the zone to flush
 */
EXPORT_SYMBOL(kc_flush_cache);
void kc_flush_cache(void *pData, unsigned int size)
{
#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
                        dcache_range_w(KSEG0ADDR((unsigned long) pData),(unsigned long) size);
#else
			cpu_pt110_dcache_clean_range( (unsigned long) pData,(unsigned long) size);
#endif

	kcinfo("cache flushed : addr = %p, size = %lu\n", pData, size);
}