/**
* Read from the device
*
* This function is called when the device is read in real-time context.
*
*/
static ssize_t mpu9150_rtdm_read_rt(struct rtdm_dev_context *context,
rtdm_user_info_t * user_info, void *buf,
size_t nbyte)
{
int ret;
if( mpu9150_device )
{
/* take the semaphore */
rtdm_sem_down( &sem );
mpu9150_read_accel();
mpu9150_read_gyro();
mpu9150_read_mag();
mpu9150_read_temp();
ret = rtdm_safe_copy_to_user(user_info, buf, buffer.data.alldata, DATA_BUFFER_SIZE);
/* if an error has occurred, send it to user */
if( ret )
return ret;
/* release the semaphore */
rtdm_sem_up( &sem );
}
else
return 0;
return DATA_BUFFER_SIZE;
}
/***
* rt_packet_rcv
*/
int rt_packet_rcv(struct rtskb *skb, struct rtpacket_type *pt)
{
struct rtsocket *sock = (struct rtsocket *)(((u8 *)pt) -
((u8 *)&((struct rtsocket *)0)->prot.packet));
int ifindex = sock->prot.packet.ifindex;
void (*callback_func)(struct rtdm_dev_context *, void *);
void *callback_arg;
rtdm_lockctx_t context;
if (((ifindex != 0) && (ifindex != skb->rtdev->ifindex)) ||
(rtskb_acquire(skb, &sock->skb_pool) != 0))
kfree_rtskb(skb);
else {
rtdev_reference(skb->rtdev);
rtskb_queue_tail(&sock->incoming, skb);
rtdm_sem_up(&sock->pending_sem);
rtdm_lock_get_irqsave(&sock->param_lock, context);
callback_func = sock->callback_func;
callback_arg = sock->callback_arg;
rtdm_lock_put_irqrestore(&sock->param_lock, context);
if (callback_func)
callback_func(rt_socket_context(sock), callback_arg);
}
return 0;
}
/* ************************************************************************
* hard_xmit
*
* This function runs in linux kernel context and is executed whenever
* there is a frame to be sent out.
* ************************************************************************ */
static int rtnetproxy_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct net_device_stats *stats = dev->priv;
if (write_to_ringbuffer(&ring_skb_kernel_rtnet, skb))
{
stats->tx_packets++;
stats->tx_bytes+=skb->len;
}
else
{
/* No space in the ringbuffer... */
printk("rtnetproxy_xmit - no space in queue\n");
dev_kfree_skb(skb); /* Free the standard skb. */
}
/* Signal rtnet that there are packets waiting to be processed...
* */
rtdm_sem_up(&rtnetproxy_sem);
/* Delete all "used" skbs that already have been processed... */
{
struct sk_buff *del_skb;
while ((del_skb = read_from_ringbuffer(&ring_skb_rtnet_kernel)) != 0)
{
dev_kfree_skb(del_skb); /* Free the standard skb. */
}
}
return 0;
}
void task1(void *cookie)
{
while (1) {
rtdm_sem_down(&sem1);
rtdm_sem_up(&sem2);
}
}
/* ************************************************************************
* This function runs in kernel mode.
* It is activated from rtnetproxy_recv whenever rtnet received a frame to
* be processed by rtnetproxy.
* ************************************************************************ */
static void rtnetproxy_signal_handler(rtdm_nrtsig_t nrtsig)
{
struct rtskb *rtskb;
while ( (rtskb = read_from_ringbuffer(&ring_rtskb_rtnet_kernel)) != 0)
{
rtnetproxy_kernel_recv(rtskb);
/* Place "used" rtskb in backqueue... */
while (0 == write_to_ringbuffer(&ring_rtskb_kernel_rtnet, rtskb)) {
rtdm_sem_up(&rtnetproxy_sem);
}
}
/* Signal rtnet that there are "used" rtskbs waiting to be processed...
* Resume the rtnetproxy_thread to recycle "used" rtskbs
* */
rtdm_sem_up(&rtnetproxy_sem);
}
static void rtcan_rcv_deliver(struct rtcan_recv *recv_listener,
struct rtcan_skb *skb)
{
int size_free;
size_t cpy_size, first_part_size;
struct rtcan_rb_frame *frame = &skb->rb_frame;
struct rtcan_socket *sock = recv_listener->sock;
struct rtdm_dev_context *context = rtcan_socket_context(sock);
cpy_size = skb->rb_frame_size;
/* Check if socket wants to receive a timestamp */
if (test_bit(RTCAN_GET_TIMESTAMP, &context->context_flags)) {
cpy_size += RTCAN_TIMESTAMP_SIZE;
frame->can_dlc |= RTCAN_HAS_TIMESTAMP;
} else
frame->can_dlc &= RTCAN_HAS_NO_TIMESTAMP;
/* Calculate free size in the ring buffer */
size_free = sock->recv_head - sock->recv_tail;
if (size_free <= 0)
size_free += RTCAN_RXBUF_SIZE;
/* Test if ring buffer has enough space. */
if (size_free > cpy_size) {
/* Check if we must wrap around the end of buffer */
if ((sock->recv_tail + cpy_size) > RTCAN_RXBUF_SIZE) {
/* Wrap around: Two memcpy operations */
first_part_size = RTCAN_RXBUF_SIZE - sock->recv_tail;
memcpy(&sock->recv_buf[sock->recv_tail], (void *)frame,
first_part_size);
memcpy(&sock->recv_buf[0], (void *)frame +
first_part_size, cpy_size - first_part_size);
} else
memcpy(&sock->recv_buf[sock->recv_tail], (void *)frame,
cpy_size);
/* Adjust tail */
sock->recv_tail = (sock->recv_tail + cpy_size) &
(RTCAN_RXBUF_SIZE - 1);
/*Notify the delivery of the message */
rtdm_sem_up(&sock->recv_sem);
} else {
/* Overflow of socket's ring buffer! */
sock->rx_buf_full++;
RTCAN_RTDM_DBG("%s: socket buffer overflow (fd=%d), message discarded\n",
rtcan_proto_raw_dev.driver_name, context->fd);
}
}
void task1(void *cookie)
{
long varl;
rtdm_mutex_lock(&mutex);
rtdm_sem_down(&sem);
rtdm_mutex_unlock(&mutex);
rtdm_sem_up(&sem);
rtdm_sem_down(&sem);
while (1) {
rtdm_mutex_lock(&mutex);
rtdm_mutex_lock(&mutex);
varl = ++var;
rtdm_mutex_unlock(&mutex);
rtdm_mutex_unlock(&mutex);
while(varl == var) rt_sleep(nano2count(TIMEOUT));
if ((var - varl) != 1) {
rt_printk("WRONG INCREMENT OF VARIABLE IN TASK1\n");
break;
}
}
}
/***
* rt_packet_rcv
*/
static int rt_packet_rcv(struct rtskb *skb, struct rtpacket_type *pt)
{
struct rtsocket *sock = container_of(pt, struct rtsocket,
prot.packet.packet_type);
int ifindex = sock->prot.packet.ifindex;
void (*callback_func)(struct rtdm_fd *, void *);
void *callback_arg;
rtdm_lockctx_t context;
if (unlikely((ifindex != 0) && (ifindex != skb->rtdev->ifindex)))
return -EUNATCH;
#ifdef CONFIG_XENO_DRIVERS_NET_ETH_P_ALL
if (pt->type == htons(ETH_P_ALL)) {
struct rtskb *clone_skb = rtskb_clone(skb, &sock->skb_pool);
if (clone_skb == NULL)
goto out;
skb = clone_skb;
} else
#endif /* CONFIG_XENO_DRIVERS_NET_ETH_P_ALL */
if (unlikely(rtskb_acquire(skb, &sock->skb_pool) < 0)) {
kfree_rtskb(skb);
goto out;
}
rtskb_queue_tail(&sock->incoming, skb);
rtdm_sem_up(&sock->pending_sem);
rtdm_lock_get_irqsave(&sock->param_lock, context);
callback_func = sock->callback_func;
callback_arg = sock->callback_arg;
rtdm_lock_put_irqrestore(&sock->param_lock, context);
if (callback_func)
callback_func(rt_socket_fd(sock), callback_arg);
out:
return 0;
}
static ssize_t handleWr(
struct rtdm_dev_context * ctx,
rtdm_user_info_t * usr,
const void * src,
size_t bytes) {
rtdm_lockctx_t lockCtx;
struct devCtx * devCtx;
ssize_t write;
write = 0;
devCtx = getDevCtx(
ctx);
/*-- Set activity: disable configuration -------------------------------------*/
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
devCtx->actvCnt++;
if (1u == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
rtdm_sem_down(
&devCtx->actvLock);
} else {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
}
/*-- Reset activity: enable configuration ------------------------------------*/
devCtx->actvCnt--;
if (0u == devCtx->actvCnt) {
rtdm_sem_up(
&devCtx->actvLock);
}
return (write);
}
static int handleIOctl(
struct rtdm_dev_context * ctx,
rtdm_user_info_t * usr,
unsigned int req,
void __user * arg) {
struct devCtx * devCtx;
int retval;
retval = 0;
devCtx = getDevCtx(
ctx);
/*-- Set activity: disable communication -------------------------------------*/
rtdm_sem_down(
&devCtx->actvLock);
switch (req) {
/*-- XSPI_IOC_SET_CURRENT_CHN ------------------------------------------------*/
case XSPI_IOC_SET_CURRENT_CHN : {
retval = (int)cfgChnSet(
ctx,
(enum xspiChn)arg);
break;
}
/*-- XSPI_IOC_GET_CURRENT_CHN ------------------------------------------------*/
case XSPI_IOC_GET_CURRENT_CHN : {
enum xspiChn chn;
cfgChnGet(
ctx,
&chn);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&chn,
sizeof(int));
} else {
*(int *)arg = (int)chn;
}
break;
}
/*-- XSPI_IOC_SET_FIFO_MODE --------------------------------------------------*/
case XSPI_IOC_SET_FIFO_CHN : {
retval = (int)cfgFIFOChnSet(
ctx,
(enum xspiFifoChn)arg);
break;
}
/*-- XSPI_IOC_GET_FIFO_MODE --------------------------------------------------*/
case XSPI_IOC_GET_FIFO_CHN : {
enum xspiFifoChn fifoChn;
cfgFIFOChnGet(
ctx,
&fifoChn);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&fifoChn,
sizeof(int));
} else {
*(int *)arg = (int)fifoChn;
}
break;
}
/*-- XSPI_IOC_SET_CS_MODE ----------------------------------------------------*/
case XSPI_IOC_SET_CS_MODE : {
retval = (int)cfgCsModeSet(
ctx,
(enum xspiCsMode)arg);
break;
}
/*-- XSPI_IOC_GET_CS_MODE ----------------------------------------------------*/
case XSPI_IOC_GET_CS_MODE : {
enum xspiCsMode csMode;
cfgCsModeGet(
ctx,
&csMode);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&csMode,
sizeof(int));
} else {
*(int *)arg = (int)csMode;
}
break;
}
/*-- XSPI_IOC_SET_MODE -------------------------------------------------------*/
case XSPI_IOC_SET_MODE : {
retval = (int)cfgModeSet(
ctx,
(enum xspiMode)arg);
break;
}
/*-- XSPI_IOC_GET_MODE -------------------------------------------------------*/
case XSPI_IOC_GET_MODE : {
enum xspiMode mode;
cfgModeGet(
ctx,
&mode);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&mode,
sizeof(int));
} else {
*(int *)arg = (int)mode;
}
break;
}
/*-- XSPI_IOC_SET_CHANNEL_MODE -----------------------------------------------*/
case XSPI_IOC_SET_CHANNEL_MODE : {
retval = (int)cfgChannelModeSet(
ctx,
(enum xspiChannelMode)arg);
break;
}
/*-- XSPI_IOC_GET_CHANNEL_MODE -----------------------------------------------*/
case XSPI_IOC_GET_CHANNEL_MODE : {
enum xspiChannelMode channelMode;
cfgChannelModeGet(
ctx,
&channelMode);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&channelMode,
sizeof(int));
} else {
*(int *)arg = (int)channelMode;
}
break;
}
/*-- XSPI_IOC_SET_INITIAL_DELAY ----------------------------------------------*/
case XSPI_IOC_SET_INITIAL_DELAY : {
retval = (int)cfgInitialDelaySet(
ctx,
(enum xspiInitialDelay)arg);
break;
}
/*-- XSPI_IOC_GET_INITIAL_DELAY ----------------------------------------------*/
case XSPI_IOC_GET_INITIAL_DELAY : {
enum xspiInitialDelay initialDelay;
cfgInitialDelayGet(
ctx,
&initialDelay);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&initialDelay,
sizeof(int));
} else {
*(int *)arg = (int)initialDelay;
}
break;
}
/*-- XSPI_IOC_SET_TRANSFER_MODE ----------------------------------------------*/
case XSPI_IOC_SET_TRANSFER_MODE : {
retval = (int)cfgChnTransferModeSet(
ctx,
(enum xspiTransferMode)arg);
break;
}
/*-- XSPI_IOC_GET_TRANSFER_MODE ----------------------------------------------*/
case XSPI_IOC_GET_TRANSFER_MODE : {
enum xspiTransferMode transferMode;
cfgChnTransferModeGet(
ctx,
&transferMode);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&transferMode,
sizeof(int));
} else {
*(int *)arg = (int)transferMode;
}
break;
}
/*-- XSPI_IOC_SET_PIN_LAYOUT -------------------------------------------------*/
case XSPI_IOC_SET_PIN_LAYOUT : {
retval = (int)cfgChnPinLayoutSet(
ctx,
(enum xspiPinLayout)arg);
break;
}
/*-- XSPI_IOC_GET_PIN_LAYOUT -------------------------------------------------*/
case XSPI_IOC_GET_PIN_LAYOUT : {
enum xspiPinLayout pinLayout;
cfgChnPinLayoutGet(
ctx,
&pinLayout);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&pinLayout,
sizeof(int));
} else {
*(int *)arg = (int)pinLayout;
}
break;
}
/*-- XSPI_IOC_SET_WORD_LENGTH ------------------------------------------------*/
case XSPI_IOC_SET_WORD_LENGTH : {
retval = (int)cfgChnWordLengthSet(
ctx,
(uint32_t)arg);
break;
}
/*-- XSPI_IOC_GET_WORD_LENGTH ------------------------------------------------*/
case XSPI_IOC_GET_WORD_LENGTH : {
uint32_t wordLength;
cfgChnWordLengthGet(
ctx,
&wordLength);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&wordLength,
sizeof(int));
} else {
*(int *)arg = (int)wordLength;
}
break;
}
/*-- XSPI_IOC_SET_CS_DELAY ---------------------------------------------------*/
case XSPI_IOC_SET_CS_DELAY : {
retval = (int)cfgChnCsDelaySet(
ctx,
(enum xspiCsDelay)arg);
break;
}
/*-- XSPI_IOC_GET_CS_DELAY ---------------------------------------------------*/
case XSPI_IOC_GET_CS_DELAY : {
enum xspiCsDelay csDelay;
cfgChnCsDelayGet(
ctx,
&csDelay);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&csDelay,
sizeof(int));
} else {
*(int *)arg = (int)csDelay;
}
break;
}
/*-- XSPI_IOC_SET_CS_POLARITY ------------------------------------------------*/
case XSPI_IOC_SET_CS_POLARITY : {
retval = (int)cfgChnCsPolaritySet(
ctx,
(enum xspiCsPolarity)arg);
break;
}
/*-- XSPI_IOC_GET_CS_POLARITY ------------------------------------------------*/
case XSPI_IOC_GET_CS_POLARITY : {
enum xspiCsPolarity csPolarity;
cfgChnCsPolarityGet(
ctx,
&csPolarity);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&csPolarity,
sizeof(int));
} else {
*(int *)arg = (int)csPolarity;
}
break;
}
/*-- XSPI_IOC_SET_CS_STATE ---------------------------------------------------*/
case XSPI_IOC_SET_CS_STATE : {
retval = (int)cfgChnCsStateSet(
ctx,
(enum xspiCsState)arg);
break;
}
/*-- XSPI_IOC_GET_CS_STATE ---------------------------------------------------*/
case XSPI_IOC_GET_CS_STATE : {
enum xspiCsState csState;
cfgChnCsStateGet(
ctx,
&csState);
if (NULL != usr) {
retval = rtdm_safe_copy_to_user(
usr,
arg,
&csState,
sizeof(int));
} else {
*(int *)arg = (int)csState;
}
break;
}
/*-- XSPI_IOC_SET_CLOCK_FREQ -------------------------------------------------*/
case XSPI_IOC_SET_CLOCK_FREQ : {
}
/*-- XSPI_IOC_GET_CLOCK_FREQ -------------------------------------------------*/
case XSPI_IOC_GET_CLOCK_FREQ : {
}
/*-- Unhandled request -------------------------------------------------------*/
default : {
LOG_DBG("IOC: unknown request (%d) received", req);
retval = -EINVAL;
}
}
if (0 != retval) {
LOG_INFO("IOC: failed to execute IO request, err: %d", -retval);
}
/*-- Reset activity: enable communication ------------------------------------*/
rtdm_sem_up(
&devCtx->actvLock);
return (retval);
}
void task2(void *cookie)
{
long i, max;
nanosecs_abs_t t, dt;
rt_printk("TESTING TIMING OUT TIMEDDOWN ...");
for (max = i = 0; i < LOOPS; i++) {
t = rtdm_clock_read();
if (rtdm_sem_timeddown(&sem2, DELAY, NULL) == -ETIMEDOUT) {
dt = rtdm_clock_read() - t - DELAY;
if (dt > max) {
max = dt;
}
} else {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK [%lu (ns)].\n", max);
} else {
rt_printk(" NOT OK [MAXLAT %lu (ns)].\n", max);
}
rt_printk("TESTING FAILING TRY DOWN ...");
for (i = 0; i < LOOPS; i++) {
if (rtdm_sem_timeddown(&sem2, RTDM_TIMEOUT_NONE, NULL) != -EWOULDBLOCK) {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
rt_printk("TESTING SUCCEEDING TRY DOWN ...");
rtdm_sem_up(&sem2);
for (i = 0; i < LOOPS; i++) {
if (!rtdm_sem_timeddown(&sem2, RTDM_TIMEOUT_NONE, NULL)) {
rtdm_sem_up(&sem2);
} else {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
rt_printk("TESTING DOWN/UP ...");
rtdm_sem_down(&sem2);
for (i = 0; i < LOOPS; i++) {
rtdm_sem_up(&sem1);
if (rtdm_sem_down(&sem2)) {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
rt_printk("TESTING NOT TIMING OUT TIMEDDOWN ...");
for (i = 0; i < LOOPS; i++) {
rtdm_sem_up(&sem1);
if (rtdm_sem_timeddown(&sem2, DELAY, NULL)) {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
}
static int rtdmtest_ioctl(struct rtdm_dev_context *context,
rtdm_user_info_t *user_info,
unsigned int request,
void *arg)
{
struct rtdmtest_context *ctx;
struct rttst_rtdmtest_config config_buf, *config;
rtdm_toseq_t toseq_local, *toseq = NULL;
int i, err = 0;
ctx = (struct rtdmtest_context *)context->dev_private;
switch (request) {
case RTTST_RTIOC_RTDMTEST_SEM_TIMEDDOWN:
case RTTST_RTIOC_RTDMTEST_EVENT_TIMEDWAIT:
case RTTST_RTIOC_RTDMTEST_MUTEX_TIMEDTEST:
case RTTST_RTIOC_RTDMTEST_MUTEX_TEST:
config = arg;
if (user_info) {
if (rtdm_safe_copy_from_user
(user_info, &config_buf, arg,
sizeof(struct rttst_rtdmtest_config)) < 0)
return -EFAULT;
config = &config_buf;
}
if (!config->seqcount)
config->seqcount = 1;
if (config->timeout && config->seqcount > 1) {
toseq = &toseq_local;
rtdm_toseq_init(toseq, config->timeout);
}
switch(request) {
case RTTST_RTIOC_RTDMTEST_SEM_TIMEDDOWN:
for (i = 0; i < config->seqcount; i++) {
err = rtdm_sem_timeddown(&ctx->sem,
config->timeout,
toseq);
if (err)
break;
}
break;
case RTTST_RTIOC_RTDMTEST_EVENT_TIMEDWAIT:
for (i = 0; i < config->seqcount; i++) {
err = rtdm_event_timedwait(&ctx->event,
config->timeout,
toseq);
if (err)
break;
}
break;
case RTTST_RTIOC_RTDMTEST_MUTEX_TIMEDTEST:
for (i = 0; i < config->seqcount; i++) {
err = rtdm_mutex_timedlock(&ctx->mutex,
config->timeout,
toseq);
if (err)
break;
if (config->delay_jiffies) {
__set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(config->delay_jiffies);
}
rtdm_lock_count++;
rtdm_mutex_unlock(&ctx->mutex);
}
break;
case RTTST_RTIOC_RTDMTEST_MUTEX_TEST:
for (i = 0; i < config->seqcount; i++) {
if ((err = rtdm_mutex_lock(&ctx->mutex)))
break;
rtdm_lock_count++;
rtdm_mutex_unlock(&ctx->mutex);
}
break;
}
break;
case RTTST_RTIOC_RTDMTEST_SEM_DOWN:
err = rtdm_sem_down(&ctx->sem);
break;
case RTTST_RTIOC_RTDMTEST_SEM_UP:
rtdm_sem_up(&ctx->sem);
break;
case RTTST_RTIOC_RTDMTEST_SEM_DESTROY:
rtdm_sem_destroy(&ctx->sem);
break;
case RTTST_RTIOC_RTDMTEST_EVENT_WAIT:
err = rtdm_event_wait(&ctx->event);
break;
case RTTST_RTIOC_RTDMTEST_EVENT_SIGNAL:
rtdm_event_signal(&ctx->event);
break;
case RTTST_RTIOC_RTDMTEST_EVENT_DESTROY:
rtdm_event_destroy(&ctx->event);
break;
case RTTST_RTIOC_RTDMTEST_MUTEX_DESTROY:
rtdm_mutex_destroy(&ctx->mutex);
break;
case RTTST_RTIOC_RTDMTEST_MUTEX_GETSTAT:
printk("RTTST_RTIOC_RTDMTEST_MUTEX_GETSTAT\n");
if (user_info)
config = &config_buf;
else
config = arg;
config->seqcount = rtdm_lock_count;
if (user_info) {
if (rtdm_safe_copy_to_user
(user_info, arg, &config_buf,
sizeof(struct rttst_rtdmtest_config)) < 0)
return -EFAULT;
}
break;
case RTTST_RTIOC_RTDMTEST_NRTSIG_PEND:
rtdm_nrtsig_pend(&ctx->nrtsig);
break;
case RTTST_RTIOC_RTDMTEST_TASK_CREATE:
case RTTST_RTIOC_RTDMTEST_TASK_SET_PRIO:
config = arg;
if (user_info) {
if (rtdm_safe_copy_from_user
(user_info, &config_buf, arg,
sizeof(struct rttst_rtdmtest_config)) < 0)
return -EFAULT;
config = &config_buf;
}
if (request == RTTST_RTIOC_RTDMTEST_TASK_CREATE) {
task_period = config->timeout;
rtdm_task_init(&task, "RTDMTEST",
rtdmtest_task, (void *)config,
config->priority, 0);
} else {
rtdm_task_set_priority(&task, config->priority);
}
break;
case RTTST_RTIOC_RTDMTEST_TASK_DESTROY:
rtdm_task_destroy(&task);
rtdm_task_join_nrt(&task, 100);
break;
default:
printk("request=%d\n", request);
err = -ENOTTY;
}
return err;
}
void task2(void *cookie)
{
long i, max, varl;
nanosecs_abs_t t, dt;
rt_printk("TESTING TIMING OUT TIMEDLOCK ...");
for (max = i = 0; i < LOOPS; i++) {
t = rtdm_clock_read();
if (rtdm_mutex_timedlock(&mutex, DELAY, NULL) == -ETIMEDOUT) {
dt = rtdm_clock_read() - t - DELAY;
if (dt > max) {
max = dt;
}
} else {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK [%lu (ns)].\n", max);
} else {
rt_printk(" NOT OK [MAXLAT %lu (ns)].\n", max);
}
rt_printk("TESTING FAILING TRY LOCK ...");
for (i = 0; i < LOOPS; i++) {
if (rtdm_mutex_timedlock(&mutex, RTDM_TIMEOUT_NONE, NULL) != -EWOULDBLOCK) {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
rt_printk("TESTING SUCCEEDING TRY LOCK ...");
rtdm_sem_up(&sem);
for (i = 0; i < LOOPS; i++) {
if (!rtdm_mutex_timedlock(&mutex, RTDM_TIMEOUT_NONE, NULL)) {
rtdm_mutex_unlock(&mutex);
} else {
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
rt_printk("TESTING LOCK/UNLOCK ...");
rtdm_sem_up(&sem);
rtdm_sem_down(&sem);
for (i = 0; i < LOOPS; i++) {
if (rtdm_mutex_lock(&mutex)) {
break;
}
varl = ++var;
if (rtdm_mutex_lock(&mutex)) {
break;
}
rtdm_mutex_unlock(&mutex);
rtdm_mutex_unlock(&mutex);
while(varl == var) rt_sleep(nano2count(TIMEOUT));
if ((var - varl) != 1) {
rt_printk("WRONG INCREMENT OF VARIABLE IN TASK2\n");
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
rt_printk("TESTING NOT TIMING OUT TIMEDLOCK ...");
for (i = 0; i < LOOPS; i++) {
if (rtdm_mutex_timedlock(&mutex, DELAY, NULL)) {
break;
}
if (rtdm_mutex_lock(&mutex)) {
break;
}
varl = ++var;
rtdm_mutex_unlock(&mutex);
rtdm_mutex_unlock(&mutex);
while(varl == var) rt_sleep(nano2count(TIMEOUT));
if ((var - varl) != 1) {
rt_printk("WRONG INCREMENT OF VARIABLE IN TASK2\n");
break;
}
}
if (i == LOOPS) {
rt_printk(" OK.\n");
} else {
rt_printk(" NOT OK.\n", max);
}
}
