static void do_slot_job(struct tdma_priv *tdma, struct tdma_slot *job,
rtdm_lockctx_t lockctx)
{
struct rtskb *rtskb;
if ((job->period != 1) &&
(tdma->current_cycle % job->period != job->phasing))
return;
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
/* wait for slot begin, then send one pending packet */
rtdm_task_sleep_abs(tdma->current_cycle_start + SLOT_JOB(job)->offset,
RTDM_TIMERMODE_REALTIME);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
rtskb = __rtskb_prio_dequeue(SLOT_JOB(job)->queue);
if (!rtskb)
return;
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
rtmac_xmit(rtskb);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
}
/***
* rt_loopback_xmit - begin packet transmission
* @skb: packet to be sent
* @dev: network device to which packet is sent
*
*/
static int rt_loopback_xmit(struct rtskb *skb, struct rtnet_device *rtdev)
{
unsigned short hash;
struct rtpacket_type *pt_entry;
rtdm_lockctx_t context;
/* write transmission stamp - in case any protocol ever gets the idea to
ask the lookback device for this service... */
if (skb->xmit_stamp)
*skb->xmit_stamp = cpu_to_be64(rtdm_clock_read() + *skb->xmit_stamp);
/* make sure that critical fields are re-intialised */
skb->chain_end = skb;
/* parse the Ethernet header as usual */
skb->protocol = rt_eth_type_trans(skb, rtdev);
skb->nh.raw = skb->data;
rtdev_reference(rtdev);
rtcap_report_incoming(skb);
hash = ntohs(skb->protocol) & RTPACKET_HASH_KEY_MASK;
rtdm_lock_get_irqsave(&rt_packets_lock, context);
list_for_each_entry(pt_entry, &rt_packets[hash], list_entry)
if (pt_entry->type == skb->protocol) {
pt_entry->refcount++;
rtdm_lock_put_irqrestore(&rt_packets_lock, context);
pt_entry->handler(skb, pt_entry);
rtdm_lock_get_irqsave(&rt_packets_lock, context);
pt_entry->refcount--;
rtdm_lock_put_irqrestore(&rt_packets_lock, context);
goto out;
}
rtdm_lock_put_irqrestore(&rt_packets_lock, context);
/* don't warn if running in promiscuous mode (RTcap...?) */
if ((rtdev->flags & IFF_PROMISC) == 0)
rtdm_printk("RTnet: unknown layer-3 protocol\n");
kfree_rtskb(skb);
out:
rtdev_dereference(rtdev);
return 0;
}
void tdma_worker(void *arg)
{
struct tdma_priv *tdma = (struct tdma_priv *)arg;
struct tdma_job *job;
rtdm_lockctx_t lockctx;
rtdm_event_wait(&tdma->worker_wakeup);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
job = tdma->first_job;
while (!test_bit(TDMA_FLAG_SHUTDOWN, &tdma->flags)) {
job->ref_count++;
switch (job->id) {
case WAIT_ON_SYNC:
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
rtdm_event_wait(&tdma->sync_event);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
break;
case XMIT_REQ_CAL:
job = do_request_cal_job(tdma, REQUEST_CAL_JOB(job), lockctx);
break;
#ifdef CONFIG_RTNET_TDMA_MASTER
case XMIT_SYNC:
do_xmit_sync_job(tdma, lockctx);
break;
case BACKUP_SYNC:
do_backup_sync_job(tdma, lockctx);
break;
case XMIT_RPL_CAL:
job = do_reply_cal_job(tdma, REPLY_CAL_JOB(job), lockctx);
break;
#endif /* CONFIG_RTNET_TDMA_MASTER */
default:
do_slot_job(tdma, SLOT_JOB(job), lockctx);
break;
}
job->ref_count--;
job = tdma->current_job =
list_entry(job->entry.next, struct tdma_job, entry);
}
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
}
static void do_xmit_sync_job(struct tdma_priv *tdma, rtdm_lockctx_t lockctx)
{
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
/* wait for beginning of next cycle, then send sync */
rtdm_task_sleep_abs(tdma->current_cycle_start + tdma->cycle_period,
RTDM_TIMERMODE_REALTIME);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
tdma->current_cycle++;
tdma->current_cycle_start += tdma->cycle_period;
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
tdma_xmit_sync_frame(tdma);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
}
int tims_clock_ioctl(rtdm_user_info_t *user_info, unsigned int request,
void *arg)
{
rtdm_lockctx_t lock_ctx;
nanosecs_rel_t result = 0;
switch(clock_sync_mode) {
case SYNC_RTNET:
sync_dev_ctx->ops->ioctl_rt(sync_dev_ctx, NULL,
RTMAC_RTIOC_TIMEOFFSET, &result);
break;
case SYNC_CAN_SLAVE:
case SYNC_SER_SLAVE:
rtdm_lock_get_irqsave(&sync_lock, lock_ctx);
result = clock_offset;
rtdm_lock_put_irqrestore(&sync_lock, lock_ctx);
break;
}
result += sync_delay;
if (request == TIMS_RTIOC_GETTIME)
result += rtdm_clock_read();
return rtdm_safe_copy_to_user(user_info, arg, &result, sizeof(result));
}
static int32_t cfgChnSet(
struct rtdm_dev_context * ctx,
enum xspiChn chn) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set current channel to %d", chn);
if (!CFG_ARG_IS_VALID(chn, XSPI_CHN_0, XSPI_CHN_3)) {
return (-EINVAL);
}
if (FALSE == portChnIsOnline(ctx->device, chn)) {
return (-EIDRM);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
devCtx->cfg.chn = chn;
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
/***
* 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;
}
static int32_t cfgChnTransferModeSet(
struct rtdm_dev_context * ctx,
enum xspiTransferMode transferMode) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set transfer mode to %d", transferMode);
if (!CFG_ARG_IS_VALID(transferMode, XSPI_TRANSFER_MODE_TX_AND_RX, XSPI_TRANSFER_MODE_TX_ONLY)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->chn[devCtx->cfg.chn].cfg.transferMode = transferMode;
lldChnTransferModeSet(
ctx->device,
devCtx->cfg.chn,
(uint32_t)transferMode);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
static int32_t cfgChnPinLayoutSet(
struct rtdm_dev_context * ctx,
enum xspiPinLayout pinLayout) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set pin layout to %d", pinLayout);
if (!CFG_ARG_IS_VALID(pinLayout, XSPI_PIN_LAYOUT_TX_RX, XSPI_PIN_LAYOUT_RX_TX)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->chn[devCtx->cfg.chn].cfg.pinLayout = pinLayout;
lldChnPinLayoutSet(
ctx->device,
devCtx->cfg.chn,
(uint32_t)pinLayout);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
/***
* rt_udp_close
*/
int rt_udp_close(struct rtdm_dev_context *sockctx,
rtdm_user_info_t *user_info)
{
struct rtsocket *sock = (struct rtsocket *)&sockctx->dev_private;
struct rtskb *del;
int port;
rtdm_lockctx_t context;
rtdm_lock_get_irqsave(&udp_socket_base_lock, context);
sock->prot.inet.state = TCP_CLOSE;
if (sock->prot.inet.reg_index >= 0) {
port = sock->prot.inet.reg_index;
clear_bit(port % 32, &port_bitmap[port / 32]);
free_ports++;
sock->prot.inet.reg_index = -1;
}
rtdm_lock_put_irqrestore(&udp_socket_base_lock, context);
/* cleanup already collected fragments */
rt_ip_frag_invalidate_socket(sock);
/* free packets in incoming queue */
while ((del = rtskb_dequeue(&sock->incoming)) != NULL)
kfree_rtskb(del);
return rt_socket_cleanup(sockctx);
}
static int32_t cfgInitialDelaySet(
struct rtdm_dev_context * ctx,
enum xspiInitialDelay delay) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set initial delay to %d", delay);
if (!CFG_ARG_IS_VALID(delay, XSPI_INITIAL_DELAY_0, XSPI_INITIAL_DELAY_32)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->cfg.delay = delay;
lldInitialDelaySet(
ctx->device,
(uint32_t)delay);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
/***
* rt_ip_route_del_host - deletes specified host route
*/
int rt_ip_route_del_host(u32 addr, struct rtnet_device *rtdev)
{
rtdm_lockctx_t context;
struct host_route *rt;
struct host_route **last_ptr;
unsigned int key;
key = ntohl(addr) & HOST_HASH_KEY_MASK;
last_ptr = &host_hash_tbl[key];
rtdm_lock_get_irqsave(&host_table_lock, context);
rt = host_hash_tbl[key];
while (rt != NULL) {
if ((rt->dest_host.ip == addr) &&
(!rtdev || (rt->dest_host.rtdev->local_ip == rtdev->local_ip))) {
*last_ptr = rt->next;
rt_free_host_route(rt);
rtdm_lock_put_irqrestore(&host_table_lock, context);
return 0;
}
last_ptr = &rt->next;
rt = rt->next;
}
rtdm_lock_put_irqrestore(&host_table_lock, context);
return -ENOENT;
}
static int32_t cfgModeSet(
struct rtdm_dev_context * ctx,
enum xspiMode mode) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set SPI mode to %d", mode);
if (!CFG_ARG_IS_VALID(mode, XSPI_MODE_MASTER, XSPI_MODE_SLAVE)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->cfg.mode = mode;
cfgApply(
ctx);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
struct rtcan_device *rtcan_dev_get_by_index(int ifindex)
{
struct rtcan_device *dev;
#ifdef RTCAN_USE_REFCOUNT
rtdm_lockctx_t context;
#endif
if ((ifindex <= 0) || (ifindex > RTCAN_MAX_DEVICES))
return NULL;
#ifdef RTCAN_USE_REFCOUNT
rtdm_lock_get_irqsave(&rtcan_devices_rt_lock, context);
#endif
dev = __rtcan_dev_get_by_index(ifindex);
#ifdef RTCAN_USE_REFCOUNT
if (dev != NULL)
atomic_inc(&dev->refcount);
rtdm_lock_put_irqrestore(&rtcan_devices_rt_lock, context);
#endif
return dev;
}
static int32_t cfgChnCsPolaritySet(
struct rtdm_dev_context * ctx,
enum xspiCsPolarity csPolarity) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set CS polarity to %d", csPolarity);
if (!CFG_ARG_IS_VALID(csPolarity, XSPI_CS_POLARITY_ACTIVE_HIGH, XSPI_CS_POLAROTY_ACTIVE_LOW)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->chn[devCtx->cfg.chn].cfg.wordLength = csPolarity;
lldChnCsPolaritySet(
ctx->device,
devCtx->cfg.chn,
(uint32_t)csPolarity);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
/***
* rt_ip_route_get_host - check if specified host route is resolved
*/
int rt_ip_route_get_host(u32 addr, char *if_name, unsigned char *dev_addr,
struct rtnet_device *rtdev)
{
rtdm_lockctx_t context;
struct host_route *rt;
unsigned int key;
key = ntohl(addr) & HOST_HASH_KEY_MASK;
rtdm_lock_get_irqsave(&host_table_lock, context);
rt = host_hash_tbl[key];
while (rt != NULL) {
if ((rt->dest_host.ip == addr) &&
(!rtdev || rt->dest_host.rtdev->local_ip == rtdev->local_ip)) {
memcpy(dev_addr, rt->dest_host.dev_addr,
rt->dest_host.rtdev->addr_len);
strncpy(if_name, rt->dest_host.rtdev->name, IFNAMSIZ);
rtdm_lock_put_irqrestore(&host_table_lock, context);
return 0;
}
rt = rt->next;
}
rtdm_lock_put_irqrestore(&host_table_lock, context);
return -ENOENT;
}
void rtcan_socket_init(struct rtdm_dev_context *context)
{
struct rtcan_socket *sock = (struct rtcan_socket *)&context->dev_private;
rtdm_lockctx_t lock_ctx;
rtdm_sem_init(&sock->recv_sem, 0);
sock->recv_head = 0;
sock->recv_tail = 0;
atomic_set(&sock->ifindex, 0);
sock->flistlen = RTCAN_SOCK_UNBOUND;
sock->flist = NULL;
sock->err_mask = 0;
sock->rx_buf_full = 0;
#ifdef CONFIG_XENO_DRIVERS_CAN_LOOPBACK
sock->loopback = 1;
#endif
sock->tx_timeout = RTDM_TIMEOUT_INFINITE;
sock->rx_timeout = RTDM_TIMEOUT_INFINITE;
INIT_LIST_HEAD(&sock->tx_wait_head);
rtdm_lock_get_irqsave(&rtcan_recv_list_lock, lock_ctx);
list_add(&sock->socket_list, &rtcan_socket_list);
rtdm_lock_put_irqrestore(&rtcan_recv_list_lock, lock_ctx);
}
int cpdma_chan_start(struct cpdma_chan *chan)
{
struct cpdma_ctlr *ctlr = chan->ctlr;
struct cpdma_desc_pool *pool = ctlr->pool;
rtdm_lockctx_t context;
rtdm_lock_get_irqsave(&chan->lock, context);
if (chan->state != CPDMA_STATE_IDLE) {
rtdm_lock_put_irqrestore(&chan->lock, context);
return -EBUSY;
}
if (ctlr->state != CPDMA_STATE_ACTIVE) {
rtdm_lock_put_irqrestore(&chan->lock, context);
return -EINVAL;
}
dma_reg_write(ctlr, chan->int_set, chan->mask);
chan->state = CPDMA_STATE_ACTIVE;
if (chan->head) {
chan_write(chan, hdp, desc_phys(pool, chan->head));
if (chan->rxfree)
chan_write(chan, rxfree, chan->count);
}
rtdm_lock_put_irqrestore(&chan->lock, context);
return 0;
}
int cpdma_ctlr_stop(struct cpdma_ctlr *ctlr)
{
rtdm_lockctx_t context;
int i;
rtdm_lock_get_irqsave(&ctlr->lock, context);
if (ctlr->state != CPDMA_STATE_ACTIVE) {
rtdm_lock_put_irqrestore(&ctlr->lock, context);
return -EINVAL;
}
ctlr->state = CPDMA_STATE_TEARDOWN;
for (i = 0; i < ARRAY_SIZE(ctlr->channels); i++) {
if (ctlr->channels[i])
cpdma_chan_stop(ctlr->channels[i]);
}
dma_reg_write(ctlr, CPDMA_RXINTMASKCLEAR, 0xffffffff);
dma_reg_write(ctlr, CPDMA_TXINTMASKCLEAR, 0xffffffff);
dma_reg_write(ctlr, CPDMA_TXCONTROL, 0);
dma_reg_write(ctlr, CPDMA_RXCONTROL, 0);
ctlr->state = CPDMA_STATE_IDLE;
rtdm_lock_put_irqrestore(&ctlr->lock, context);
return 0;
}
/***
* rt_packet_close
*/
int rt_packet_close(struct rtdm_dev_context *sockctx,
rtdm_user_info_t *user_info)
{
struct rtsocket *sock = (struct rtsocket *)&sockctx->dev_private;
struct rtpacket_type *pt = &sock->prot.packet.packet_type;
struct rtskb *del;
int ret = 0;
rtdm_lockctx_t context;
rtdm_lock_get_irqsave(&sock->param_lock, context);
if ((pt->type != 0) && ((ret = rtdev_remove_pack(pt)) == 0))
pt->type = 0;
rtdm_lock_put_irqrestore(&sock->param_lock, context);
/* free packets in incoming queue */
while ((del = rtskb_dequeue(&sock->incoming)) != NULL) {
rtdev_dereference(del->rtdev);
kfree_rtskb(del);
}
if (ret == 0)
ret = rt_socket_cleanup(sockctx);
return ret;
}
static int32_t cfgChnWordLengthSet(
struct rtdm_dev_context * ctx,
uint32_t length) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set word length to %d", length);
if (!CFG_ARG_IS_VALID(length, 4u, 32u)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->chn[devCtx->cfg.chn].cfg.wordLength = length;
lldChnCsDelaySet(
ctx->device,
devCtx->cfg.chn,
(uint32_t)length);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
static struct tdma_job *do_reply_cal_job(struct tdma_priv *tdma,
struct tdma_reply_cal *job,
rtdm_lockctx_t lockctx)
{
struct tdma_job *prev_job;
if (job->reply_cycle > tdma->current_cycle)
return &job->head;
/* remove the job */
__list_del(job->head.entry.prev, job->head.entry.next);
job->head.ref_count--;
prev_job = tdma->current_job =
list_entry(job->head.entry.prev, struct tdma_job, entry);
prev_job->ref_count++;
tdma->job_list_revision++;
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
if (job->reply_cycle == tdma->current_cycle) {
/* send reply in the assigned slot */
rtdm_task_sleep_abs(tdma->current_cycle_start + job->reply_offset,
RTDM_TIMERMODE_REALTIME);
rtmac_xmit(job->reply_rtskb);
} else {
/* cleanup if cycle already passed */
kfree_rtskb(job->reply_rtskb);
}
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
return prev_job;
}
static int32_t cfgChnCsDelaySet(
struct rtdm_dev_context * ctx,
enum xspiCsDelay delay) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set CS delay to %d", delay);
if (!CFG_ARG_IS_VALID(delay, XSPI_CS_DELAY_0_5, XSPI_CS_DELAY_3_5)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->chn[devCtx->cfg.chn].cfg.csDelay = delay;
lldChnCsDelaySet(
ctx->device,
devCtx->cfg.chn,
(uint32_t)delay);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
static int32_t cfgCsModeSet(
struct rtdm_dev_context * ctx,
enum xspiCsMode csMode) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set CS mode to %d", csMode);
if (!CFG_ARG_IS_VALID(csMode, XSPI_CS_MODE_ENABLED, XSPI_CS_MODE_DISABLED)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->cfg.csMode = csMode;
lldCsModeSet(
ctx->device,
(int32_t)csMode);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
static int32_t cfgChnCsStateSet(
struct rtdm_dev_context * ctx,
enum xspiCsState state) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
int32_t ret;
LOG_DBG("CFG: set CS state to %d", state);
if (!CFG_ARG_IS_VALID(state, XSPI_CS_STATE_INACTIVE, XSPI_CS_STATE_ACTIVE)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->chn[devCtx->cfg.chn].cfg.csState = state;
ret = lldChnCsStateSet(
ctx->device,
devCtx->cfg.chn,
(uint32_t)state);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (ret);
}
static int32_t cfgChannelModeSet(
struct rtdm_dev_context * ctx,
enum xspiChannelMode channelMode) {
struct devCtx * devCtx;
rtdm_lockctx_t lockCtx;
LOG_DBG("CFG: set initial delay to %d", channelMode);
if (!CFG_ARG_IS_VALID(channelMode, XSPI_CHANNEL_MODE_MULTI, XSPI_CHANNEL_MODE_SINGLE)) {
return (-EINVAL);
}
devCtx = getDevCtx(
ctx);
rtdm_lock_get_irqsave(&devCtx->lock, lockCtx);
if (XSPI_ACTIVITY_RUNNIG == devCtx->actvCnt) {
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (-EAGAIN);
}
devCtx->cfg.delay = channelMode;
lldChannelModeSet(
ctx->device,
(uint32_t)channelMode);
rtdm_lock_put_irqrestore(&devCtx->lock, lockCtx);
return (0);
}
/***
* rt_udp_connect
*/
int rt_udp_connect(struct rtsocket *sock, const struct sockaddr *serv_addr,
socklen_t addrlen)
{
struct sockaddr_in *usin = (struct sockaddr_in *) serv_addr;
rtdm_lockctx_t context;
int index;
if (usin->sin_family == AF_UNSPEC) {
if ((index = sock->prot.inet.reg_index) < 0)
/* socket is being closed */
return -EBADF;
rtdm_lock_get_irqsave(&udp_socket_base_lock, context);
sock->prot.inet.saddr = INADDR_ANY;
/* Note: The following line differs from standard stacks, and we also
don't remove the socket from the port list. Might get fixed in
the future... */
sock->prot.inet.sport = index + auto_port_start;
sock->prot.inet.daddr = INADDR_ANY;
sock->prot.inet.dport = 0;
sock->prot.inet.state = TCP_CLOSE;
rtdm_lock_put_irqrestore(&udp_socket_base_lock, context);
} else {
if ((addrlen < (int)sizeof(struct sockaddr_in)) ||
(usin->sin_family != AF_INET))
return -EINVAL;
rtdm_lock_get_irqsave(&udp_socket_base_lock, context);
if (sock->prot.inet.state != TCP_CLOSE) {
rtdm_lock_put_irqrestore(&udp_socket_base_lock, context);
return -EINVAL;
}
sock->prot.inet.state = TCP_ESTABLISHED;
sock->prot.inet.daddr = usin->sin_addr.s_addr;
sock->prot.inet.dport = usin->sin_port;
rtdm_lock_put_irqrestore(&udp_socket_base_lock, context);
}
return 0;
}
void rt_icmp_queue_echo_request(struct rt_proc_call *call)
{
rtdm_lockctx_t context;
rtdm_lock_get_irqsave(&echo_calls_lock, context);
list_add_tail(&call->list_entry, &echo_calls);
rtdm_lock_put_irqrestore(&echo_calls_lock, context);
}
void rtskb_pool_queue_tail(struct rtskb_pool *pool, struct rtskb *skb)
{
struct rtskb_queue *queue = &pool->queue;
rtdm_lockctx_t context;
rtdm_lock_get_irqsave(&queue->lock, context);
__rtskb_pool_queue_tail(pool, skb);
rtdm_lock_put_irqrestore(&queue->lock, context);
}
static struct tdma_job *do_request_cal_job(struct tdma_priv *tdma,
struct tdma_request_cal *job,
rtdm_lockctx_t lockctx)
{
struct rt_proc_call *call;
struct tdma_job *prev_job;
int err;
if ((job->period != 1) &&
(tdma->current_cycle % job->period != job->phasing))
return &job->head;
/* remove job until we get a reply */
__list_del(job->head.entry.prev, job->head.entry.next);
job->head.ref_count--;
prev_job = tdma->current_job =
list_entry(job->head.entry.prev, struct tdma_job, entry);
prev_job->ref_count++;
tdma->job_list_revision++;
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
rtdm_task_sleep_abs(tdma->current_cycle_start + job->offset,
RTDM_TIMERMODE_REALTIME);
err = tdma_xmit_request_cal_frame(tdma,
tdma->current_cycle + job->period, job->offset);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
/* terminate call on error */
if (err < 0) {
call = tdma->calibration_call;
tdma->calibration_call = NULL;
if (call) {
rtdm_lock_put_irqrestore(&tdma->lock, lockctx);
rtpc_complete_call(call, err);
rtdm_lock_get_irqsave(&tdma->lock, lockctx);
}
}
return prev_job;
}