tbx.c

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

	}
	sched_free(tbx->bufadr); 
	sched_free(tbx->bcbadr); 
	return 0;
}

int rt_tbx_send(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_NORMAL;
	DECLARE_RT_CURRENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait(tbx, &(tbx->sndsmx), rt_current)) {
		return msg_size;
	}
   	if (tbx_wait_room(tbx, &tbx->frbs, msg_size + sizeof(type), rt_current)) {
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return msg_size;
	}
	msg_size = tbxput(tbx, (char **)(&msg), msg_size, type);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->sndsmx));
	return msg_size;
}

int rt_tbx_send_if(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_NORMAL;
	CHK_TBX_MAGIC;

	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	if (tbx_check_room(tbx, &tbx->frbs, (msg_size + sizeof(type)))) {
		tbxput(tbx, (char **)(&msg), msg_size, type);
		tbx_signal(tbx);
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return 0;
	}
	return msg_size;
}

int rt_tbx_send_until(TBX *tbx, void *msg, int msg_size, RTIME time)
{
	unsigned char type = TYPE_NORMAL;
	DECLARE_RT_CURRENT;

	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait_until(tbx, &(tbx->sndsmx), time, rt_current)) {
		return msg_size;
	}
	if (tbx_wait_room_until(tbx, &tbx->frbs, msg_size + sizeof(type), time, rt_current)) {
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return msg_size;
	}
	msg_size = tbxput(tbx, (char **)(&msg), msg_size, type);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->sndsmx));
	return msg_size;
}

int rt_tbx_send_timed(TBX *tbx, void *msg, int msg_size, RTIME delay)
{
	return rt_tbx_send_until(tbx, msg, msg_size, get_time() + delay);
}

int rt_tbx_receive(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_NONE, lock = 0;  
	char* temp;
	DECLARE_RT_CURRENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait(tbx, &(tbx->rcvsmx), rt_current)) {
		return msg_size;
	}
	temp = msg;
	if (tbx_wait_msg(tbx, &tbx->avbs, msg_size + sizeof(type), &type, rt_current)) {
		tbx_smx_signal(tbx, &(tbx->rcvsmx));
		return msg_size;
	}
	tbx_receive_core(tbx, msg, &msg_size, type, &lock);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->rcvsmx));
	if (lock == 1) {
        	rt_sem_wait(&(tbx->bcbsmx));
	}
	return msg_size;
}

int rt_tbx_receive_if(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_NONE, lock = 0; 
	char* temp;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	temp = msg;
	if (tbx_check_msg(tbx, &tbx->avbs, (msg_size + sizeof(type)), &type)) {
        	tbx_receive_core(tbx, msg, &msg_size, type, &lock);
	        tbx_signal(tbx);
        	tbx_smx_signal(tbx, &(tbx->rcvsmx));
	        if(lock == 1) {
			rt_sem_wait(&(tbx->bcbsmx));
	        }
	}
	return msg_size;
}

int rt_tbx_receive_until(TBX *tbx, void *msg, int msg_size, RTIME time)
{
	unsigned char type = TYPE_NONE, lock = 0;
	char* temp;
	DECLARE_RT_CURRENT;

	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait_until(tbx, &(tbx->rcvsmx), time, rt_current)) {
		return msg_size;
	}
	temp = msg;
	if (tbx_wait_msg_until(tbx, &tbx->avbs, msg_size + sizeof(type), time, &type, rt_current)) {
		tbx_smx_signal(tbx, &(tbx->rcvsmx));
		return msg_size;
	}
	tbx_receive_core(tbx, msg, &msg_size, type, &lock);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->rcvsmx));
	if(lock == 1) {
		rt_sem_wait(&(tbx->bcbsmx));
	}
	return msg_size;
}

int rt_tbx_receive_timed(TBX *tbx, void *msg, int msg_size, RTIME delay)
{
	return rt_tbx_receive_until(tbx, msg, msg_size, get_time() + delay);
}

int rt_tbx_broadcast(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_BROADCAST; 
	int wakedup;
	DECLARE_RT_CURRENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	wakedup = tbx->waiting_nr;
	if (wakedup == 0) {
		return wakedup;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait(tbx, &(tbx->sndsmx), rt_current)) {
		return 0;
	}
	if (tbx_wait_room(tbx, &tbx->frbs, msg_size + sizeof(type), rt_current)) {
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return 0;
	}
	msg_size = tbxput(tbx, (char **)(&msg), msg_size, type);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->sndsmx));
	return wakedup;
}

int rt_tbx_broadcast_if(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_BROADCAST; 
	int wakedup;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
		return -EMSGSIZE;
	}
	wakedup = tbx->waiting_nr;
	if (wakedup == 0) {
		return wakedup;
	}
	if (tbx_check_room(tbx, &tbx->frbs, (msg_size + sizeof(type)))) {
		msg_size = tbxput(tbx, (char **)(&msg), msg_size, type);
		tbx_signal(tbx);
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return wakedup;
	}
	return 0;
}

int rt_tbx_broadcast_until(TBX *tbx, void *msg, int msg_size, RTIME time)
{
	unsigned char type = TYPE_BROADCAST; 
	int wakedup;
	DECLARE_RT_CURRENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
        	return -EMSGSIZE;
	}
	wakedup = tbx->waiting_nr;
	if (wakedup == 0) {
        	return wakedup;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait_until(tbx, &(tbx->sndsmx), time, rt_current)) {
		return 0;
	}
	if (tbx_wait_room_until(tbx, &tbx->frbs, (msg_size + sizeof(type)), time, rt_current)) {
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return 0;
	}
	msg_size = tbxput(tbx, (char **)(&msg), msg_size, type);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->sndsmx));
	return wakedup;
}

int rt_tbx_broadcast_timed(TBX *tbx, void *msg, int msg_size, RTIME delay)
{
	return rt_tbx_broadcast_until(tbx, msg, msg_size, get_time() + delay);
}

int rt_tbx_urgent(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_URGENT;
	DECLARE_RT_CURRENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
        	return -EMSGSIZE;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait(tbx, &(tbx->sndsmx), rt_current)) {
		return msg_size;
	}
	if (tbx_wait_room(tbx, &tbx->frbs, msg_size + sizeof(type), rt_current)) {
        	tbx_smx_signal(tbx, &(tbx->sndsmx));
		return msg_size;
	}
	msg_size = tbxbackput(tbx, (char **)(&msg), msg_size, type);
	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->sndsmx));
	return msg_size;
}

int rt_tbx_urgent_if(TBX *tbx, void *msg, int msg_size)
{
	unsigned char type = TYPE_URGENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
        	return -EMSGSIZE;
	}
	if (tbx_check_room(tbx, &tbx->frbs, (msg_size + sizeof(type)))) {
        	msg_size = tbxbackput(tbx, (char **)(&msg), msg_size, type);
		tbx_signal(tbx);
		tbx_smx_signal(tbx, &(tbx->sndsmx));
		return 0;
	}
	return msg_size;
}

int rt_tbx_urgent_until(TBX *tbx, void *msg, int msg_size, RTIME time)
{
	unsigned char type = TYPE_URGENT;
	DECLARE_RT_CURRENT;
    
	CHK_TBX_MAGIC;
	if ((msg_size + sizeof(type)) > tbx->size) {
        	return -EMSGSIZE;
	}
	ASSIGN_RT_CURRENT;
	if (tbx_smx_wait_until(tbx, &(tbx->sndsmx), time, rt_current)) {
		return msg_size;
	}
	if (tbx_wait_room_until(tbx, &tbx->frbs, (msg_size + sizeof(type)), time, rt_current)) {
	        tbx_smx_signal(tbx, &(tbx->sndsmx));
        	return msg_size;
	}
	msg_size = tbxbackput(tbx, (char **)(&msg), msg_size, type);
    	tbx_signal(tbx);
	tbx_smx_signal(tbx, &(tbx->sndsmx));
	return msg_size;
}

int rt_tbx_urgent_timed(TBX *tbx, void *msg, int msg_size, RTIME delay)
{
	return rt_tbx_urgent_until(tbx, msg, msg_size, get_time() + delay);
}

/* ++++++++++++++++++++++++ NAMED TYPED MAIL BOXES ++++++++++++++++++++++++++ */

#include <rtai_registry.h>

TBX *rt_named_tbx_init(const char *tbx_name, int value, int type)
{
	TBX *tbx;
	unsigned long name;

	if ((tbx = rt_get_adr(name = nam2num(tbx_name)))) {
		return tbx;
	}
	if ((tbx = rt_malloc(sizeof(SEM)))) {
		rt_tbx_init(tbx, value, type);
		if (rt_register(name, tbx, IS_SEM, 0)) {
			return tbx;
		}
		rt_tbx_delete(tbx);
	}
	rt_free(tbx);
	return (TBX *)0;
}

int rt_named_tbx_delete(TBX *tbx)
{
	if (!rt_tbx_delete(tbx)) {
		rt_free(tbx);
	}
	return rt_drg_on_adr(tbx);
}

int rt_tbx_init_u(unsigned long name, int size, int flags)
{
	TBX *tbx;
	if (rt_get_adr(name)) {
		return 0;
	}
	if ((tbx = rt_malloc(sizeof(TBX)))) {
		rt_tbx_init(tbx, size, flags);
		if (rt_register(name, tbx, IS_MBX, current)) {
			return (int)tbx;
		} else {
			rt_free(tbx);
		}
	}
	return 0;
}

int rt_tbx_delete_u(TBX *tbx)
{
	if (rt_tbx_delete(tbx)) {
		return -EFAULT;
	}
	rt_free(tbx);
	return rt_drg_on_adr(tbx);
}

struct rt_native_fun_entry rt_tbx_entries[] = {
	{ { 0, rt_tbx_init_u },                     TBX_INIT },
	{ { 0, rt_tbx_delete_u },                   TBX_DELETE },
	{ { 0, rt_named_tbx_init },               NAMED_TBX_INIT },
	{ { 0, rt_named_tbx_delete },             NAMED_TBX_DELETE },
	{ { UR1(2, 3), rt_tbx_send },             TBX_SEND },
	{ { UR1(2, 3), rt_tbx_send_if },          TBX_SEND_IF },
	{ { UR1(2, 3), rt_tbx_send_until },       TBX_SEND_UNTIL },
	{ { UR1(2, 3), rt_tbx_send_timed },       TBX_SEND_TIMED },
	{ { UW1(2, 3), rt_tbx_receive },          TBX_RECEIVE },
	{ { UW1(2, 3), rt_tbx_receive_if },       TBX_RECEIVE_IF },
	{ { UW1(2, 3), rt_tbx_receive_until },    TBX_RECEIVE_UNTIL },
	{ { UW1(2, 3), rt_tbx_receive_timed },    TBX_RECEIVE_TIMED },
	{ { UR1(2, 3), rt_tbx_broadcast },        TBX_BROADCAST },
	{ { UR1(2, 3), rt_tbx_broadcast_if },     TBX_BROADCAST_IF },
	{ { UR1(2, 3), rt_tbx_broadcast_until },  TBX_BROADCAST_UNTIL },
	{ { UR1(2, 3), rt_tbx_broadcast_timed },  TBX_BROADCAST_TIMED },
	{ { UR1(2, 3), rt_tbx_urgent },           TBX_URGENT },
	{ { UR1(2, 3), rt_tbx_urgent_if },        TBX_URGENT_IF },
	{ { UR1(2, 3), rt_tbx_urgent_until },     TBX_URGENT_UNTIL },
	{ { UR1(2, 3), rt_tbx_urgent_timed },     TBX_URGENT_TIMED },
	{ { 0, 0 },  		                  000 }
};

int __rtai_tbx_init (void)
{
	return set_rt_fun_entries(rt_tbx_entries);
}

void __rtai_tbx_exit (void)
{
	reset_rt_fun_entries(rt_tbx_entries);
}

#ifndef CONFIG_RTAI_TBX_BUILTIN
module_init(__rtai_tbx_init);
module_exit(__rtai_tbx_exit);
#endif /* !CONFIG_RTAI_TBX_BUILTIN */

#ifdef CONFIG_KBUILD
EXPORT_SYMBOL(rt_tbx_init);
EXPORT_SYMBOL(rt_tbx_delete);
EXPORT_SYMBOL(rt_tbx_send);
EXPORT_SYMBOL(rt_tbx_send_if);
EXPORT_SYMBOL(rt_tbx_send_until);
EXPORT_SYMBOL(rt_tbx_send_timed);
EXPORT_SYMBOL(rt_tbx_receive);
EXPORT_SYMBOL(rt_tbx_receive_if);
EXPORT_SYMBOL(rt_tbx_receive_until);
EXPORT_SYMBOL(rt_tbx_receive_timed);
EXPORT_SYMBOL(rt_tbx_broadcast);
EXPORT_SYMBOL(rt_tbx_broadcast_if);
EXPORT_SYMBOL(rt_tbx_broadcast_until);
EXPORT_SYMBOL(rt_tbx_broadcast_timed);
EXPORT_SYMBOL(rt_tbx_urgent);
EXPORT_SYMBOL(rt_tbx_urgent_if);
EXPORT_SYMBOL(rt_tbx_urgent_until);
EXPORT_SYMBOL(rt_tbx_urgent_timed);
EXPORT_SYMBOL(rt_named_tbx_init);
EXPORT_SYMBOL(rt_named_tbx_delete);
EXPORT_SYMBOL(rt_tbx_init_u);
EXPORT_SYMBOL(rt_tbx_delete_u);
#endif /* CONFIG_KBUILD */