nuttx/drivers/timers/rpmsg_rtc.c
Xiang Xiao 3d3c4767a9 rtc/rpmsg: Replace session to client
Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
2022-01-16 11:58:13 +01:00

755 lines
22 KiB
C

/****************************************************************************
* drivers/timers/rpmsg_rtc.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/list.h>
#include <nuttx/clock.h>
#include <nuttx/wqueue.h>
#include <nuttx/kmalloc.h>
#include <nuttx/rptun/openamp.h>
#include <nuttx/semaphore.h>
#include <nuttx/timers/rpmsg_rtc.h>
#include <errno.h>
#include <string.h>
/****************************************************************************
* Pre-processor definitions
****************************************************************************/
#define RPMSG_RTC_EPT_NAME "rpmsg-rtc"
#define RPMSG_RTC_SET 0
#define RPMSG_RTC_GET 1
#define RPMSG_RTC_ALARM_SET 2
#define RPMSG_RTC_ALARM_CANCEL 3
#define RPMSG_RTC_ALARM_FIRE 4
#define RPMSG_RTC_SYNC 5
/****************************************************************************
* Private Types
****************************************************************************/
begin_packed_struct struct rpmsg_rtc_header_s
{
uint32_t command;
int32_t result;
uint64_t cookie;
} end_packed_struct;
begin_packed_struct struct rpmsg_rtc_set_s
{
struct rpmsg_rtc_header_s header;
int64_t sec;
int32_t nsec;
} end_packed_struct;
#define rpmsg_rtc_get_s rpmsg_rtc_set_s
begin_packed_struct struct rpmsg_rtc_alarm_set_s
{
struct rpmsg_rtc_header_s header;
int64_t sec;
int32_t nsec;
int32_t id;
} end_packed_struct;
begin_packed_struct struct rpmsg_rtc_alarm_cancel_s
{
struct rpmsg_rtc_header_s header;
int32_t id;
} end_packed_struct;
#define rpmsg_rtc_alarm_fire_s rpmsg_rtc_alarm_cancel_s
#ifndef CONFIG_RTC_RPMSG_SERVER
struct rpmsg_rtc_cookie_s
{
FAR struct rpmsg_rtc_header_s *msg;
sem_t sem;
};
/* This is the private type for the RTC state. It must be cast compatible
* with struct rtc_lowerhalf_s.
*/
struct rpmsg_rtc_lowerhalf_s
{
/* This is the contained reference to the read-only, lower-half
* operations vtable (which may lie in FLASH or ROM)
*/
FAR const struct rtc_ops_s *ops;
/* Data following is private to this driver and not visible outside of
* this file.
*/
struct rpmsg_endpoint ept;
struct work_s syncwork;
#ifdef CONFIG_RTC_ALARM
struct lower_setalarm_s alarminfo[CONFIG_RTC_NALARMS];
#endif
};
#else
struct rpmsg_rtc_server_s
{
FAR struct rtc_ops_s *ops;
FAR struct rtc_lowerhalf_s *lower;
struct list_node list;
sem_t exclsem;
};
struct rpmsg_rtc_client_s
{
struct list_node node;
struct rpmsg_endpoint ept;
};
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
#ifndef CONFIG_RTC_RPMSG_SERVER
static void rpmsg_rtc_device_created(FAR struct rpmsg_device *rdev,
FAR void *priv);
static void rpmsg_rtc_device_destroy(FAR struct rpmsg_device *rdev,
FAR void *priv);
static void rpmsg_rtc_alarm_fire_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src, FAR void *priv);
static int rpmsg_rtc_ept_cb(FAR struct rpmsg_endpoint *ept, FAR void *data,
size_t len, uint32_t src, FAR void *priv);
static int rpmsg_rtc_send_recv(FAR struct rpmsg_rtc_lowerhalf_s *lower,
uint32_t command, FAR struct rpmsg_rtc_header_s *msg, int len);
static int rpmsg_rtc_rdtime(FAR struct rtc_lowerhalf_s *lower,
FAR struct rtc_time *rtctime);
static int rpmsg_rtc_settime(FAR struct rtc_lowerhalf_s *lower,
FAR const struct rtc_time *rtctime);
static bool rpmsg_rtc_havesettime(FAR struct rtc_lowerhalf_s *lower);
#ifdef CONFIG_RTC_ALARM
static int rpmsg_rtc_setalarm(FAR struct rtc_lowerhalf_s *lower_,
FAR const struct lower_setalarm_s *alarminfo);
static int rpmsg_rtc_setrelative(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setrelative_s *relinfo);
static int rpmsg_rtc_cancelalarm(FAR struct rtc_lowerhalf_s *lower,
int alarmid);
static int rpmsg_rtc_rdalarm(FAR struct rtc_lowerhalf_s *lower_,
FAR struct lower_rdalarm_s *alarminfo);
#endif
#else
static int rpmsg_rtc_server_rdtime(FAR struct rtc_lowerhalf_s *lower,
FAR struct rtc_time *rtctime);
static int rpmsg_rtc_server_settime(FAR struct rtc_lowerhalf_s *lower,
FAR const struct rtc_time *rtctime);
static bool rpmsg_rtc_server_havesettime(FAR struct rtc_lowerhalf_s *lower);
#ifdef CONFIG_RTC_ALARM
static int rpmsg_rtc_server_setalarm(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setalarm_s *alarminfo);
static int rpmsg_rtc_server_setrelative(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setrelative_s *relinfo);
static int rpmsg_rtc_server_cancelalarm(FAR struct rtc_lowerhalf_s *lower,
int alarmid);
static int rpmsg_rtc_server_rdalarm(FAR struct rtc_lowerhalf_s *lower,
FAR struct lower_rdalarm_s *alarminfo);
#endif
#ifdef CONFIG_RTC_PERIODIC
static int rpmsg_rtc_server_setperiodic(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setperiodic_s *alarminfo);
static int rpmsg_rtc_server_cancelperiodic
(FAR struct rtc_lowerhalf_s *lower, int alarmid);
#endif
#endif
/****************************************************************************
* Private Data
****************************************************************************/
#ifndef CONFIG_RTC_RPMSG_SERVER
static const struct rtc_ops_s g_rpmsg_rtc_ops =
{
.rdtime = rpmsg_rtc_rdtime,
.settime = rpmsg_rtc_settime,
.havesettime = rpmsg_rtc_havesettime,
#ifdef CONFIG_RTC_ALARM
.setalarm = rpmsg_rtc_setalarm,
.setrelative = rpmsg_rtc_setrelative,
.cancelalarm = rpmsg_rtc_cancelalarm,
.rdalarm = rpmsg_rtc_rdalarm,
#endif
};
#else
static struct rtc_ops_s g_rpmsg_rtc_server_ops =
{
.rdtime = rpmsg_rtc_server_rdtime,
.settime = rpmsg_rtc_server_settime,
.havesettime = rpmsg_rtc_server_havesettime,
#ifdef CONFIG_RTC_ALARM
.setalarm = rpmsg_rtc_server_setalarm,
.setrelative = rpmsg_rtc_server_setrelative,
.cancelalarm = rpmsg_rtc_server_cancelalarm,
.rdalarm = rpmsg_rtc_server_rdalarm,
#endif
#ifdef CONFIG_RTC_PERIODIC
.setperiodic = rpmsg_rtc_server_setperiodic,
.cancelperiodic = rpmsg_rtc_server_cancelperiodic,
#endif
};
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
#ifndef CONFIG_RTC_RPMSG_SERVER
static void rpmsg_rtc_device_created(FAR struct rpmsg_device *rdev,
FAR void *priv)
{
FAR struct rpmsg_rtc_lowerhalf_s *lower = priv;
if (strcmp(CONFIG_RTC_RPMSG_SERVER_NAME,
rpmsg_get_cpuname(rdev)) == 0)
{
lower->ept.priv = lower;
rpmsg_create_ept(&lower->ept, rdev, RPMSG_RTC_EPT_NAME,
RPMSG_ADDR_ANY, RPMSG_ADDR_ANY,
rpmsg_rtc_ept_cb, NULL);
}
}
static void rpmsg_rtc_device_destroy(FAR struct rpmsg_device *rdev,
FAR void *priv)
{
FAR struct rpmsg_rtc_lowerhalf_s *lower = priv;
if (strcmp(CONFIG_RTC_RPMSG_SERVER_NAME,
rpmsg_get_cpuname(rdev)) == 0)
{
rpmsg_destroy_ept(&lower->ept);
}
}
static void rpmsg_rtc_alarm_fire_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
#ifdef CONFIG_RTC_ALARM
FAR struct rpmsg_rtc_lowerhalf_s *lower = priv;
FAR struct rpmsg_rtc_alarm_fire_s *msg = data;
FAR struct lower_setalarm_s *alarminfo = &lower->alarminfo[msg->id];
alarminfo->cb(alarminfo->priv, alarminfo->id);
#endif
}
static void rpmsg_rtc_syncworker(FAR void *arg)
{
clock_synchronize();
}
static void rpmsg_rtc_sync_handler(FAR void *priv)
{
FAR struct rpmsg_rtc_lowerhalf_s *lower = priv;
work_queue(HPWORK, &lower->syncwork, rpmsg_rtc_syncworker, NULL, 0);
}
static int rpmsg_rtc_ept_cb(FAR struct rpmsg_endpoint *ept, FAR void *data,
size_t len, uint32_t src, FAR void *priv)
{
FAR struct rpmsg_rtc_header_s *header = data;
FAR struct rpmsg_rtc_cookie_s *cookie =
(FAR struct rpmsg_rtc_cookie_s *)(uintptr_t)header->cookie;
switch (header->command)
{
case RPMSG_RTC_ALARM_FIRE:
rpmsg_rtc_alarm_fire_handler(ept, data, len, src, priv);
break;
case RPMSG_RTC_SYNC:
rpmsg_rtc_sync_handler(priv);
break;
default:
if (cookie)
{
memcpy(cookie->msg, data, len);
nxsem_post(&cookie->sem);
}
break;
}
return 0;
}
static int rpmsg_rtc_send_recv(FAR struct rpmsg_rtc_lowerhalf_s *lower,
uint32_t command,
FAR struct rpmsg_rtc_header_s *msg, int len)
{
struct rpmsg_rtc_cookie_s cookie;
int ret;
nxsem_init(&cookie.sem, 0, 0);
nxsem_set_protocol(&cookie.sem, SEM_PRIO_NONE);
cookie.msg = msg;
msg->command = command;
msg->result = -ENXIO;
msg->cookie = (uintptr_t)&cookie;
ret = rpmsg_send(&lower->ept, msg, len);
if (ret < 0)
{
goto fail;
}
ret = nxsem_wait_uninterruptible(&cookie.sem);
if (ret == 0)
{
ret = msg->result;
}
fail:
nxsem_destroy(&cookie.sem);
return ret;
}
static int rpmsg_rtc_rdtime(FAR struct rtc_lowerhalf_s *lower,
FAR struct rtc_time *rtctime)
{
struct rpmsg_rtc_get_s msg;
int ret;
ret = rpmsg_rtc_send_recv((FAR struct rpmsg_rtc_lowerhalf_s *)lower,
RPMSG_RTC_GET, (struct rpmsg_rtc_header_s *)&msg, sizeof(msg));
if (ret >= 0)
{
time_t time = msg.sec;
gmtime_r(&time, (FAR struct tm *)rtctime);
rtctime->tm_nsec = msg.nsec;
}
return ret;
}
static int rpmsg_rtc_settime(FAR struct rtc_lowerhalf_s *lower,
FAR const struct rtc_time *rtctime)
{
struct rpmsg_rtc_set_s msg =
{
.sec = timegm((FAR struct tm *)rtctime),
.nsec = rtctime->tm_nsec,
};
return rpmsg_rtc_send_recv((FAR struct rpmsg_rtc_lowerhalf_s *)lower,
RPMSG_RTC_SET, (struct rpmsg_rtc_header_s *)&msg, sizeof(msg));
}
static bool rpmsg_rtc_havesettime(FAR struct rtc_lowerhalf_s *lower)
{
return true;
}
#ifdef CONFIG_RTC_ALARM
static int rpmsg_rtc_setalarm(FAR struct rtc_lowerhalf_s *lower_,
FAR const struct lower_setalarm_s *alarminfo)
{
FAR struct rpmsg_rtc_lowerhalf_s *lower =
(FAR struct rpmsg_rtc_lowerhalf_s *)lower_;
struct rpmsg_rtc_alarm_set_s msg =
{
.sec = timegm((FAR struct tm *)&alarminfo->time),
.nsec = alarminfo->time.tm_nsec,
.id = alarminfo->id,
};
int ret;
ret = rpmsg_rtc_send_recv(lower, RPMSG_RTC_ALARM_SET,
(struct rpmsg_rtc_header_s *)&msg, sizeof(msg));
if (ret >= 0)
{
lower->alarminfo[alarminfo->id] = *alarminfo;
}
return ret;
}
static int
rpmsg_rtc_setrelative(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setrelative_s *relinfo)
{
struct lower_setalarm_s alarminfo =
{
.id = relinfo->id,
.cb = relinfo->cb,
.priv = relinfo->priv,
};
time_t time;
rpmsg_rtc_rdtime(lower, &alarminfo.time);
time = timegm((FAR struct tm *)&alarminfo.time);
time = time + relinfo->reltime;
gmtime_r(&time, (FAR struct tm *)&alarminfo.time);
return rpmsg_rtc_setalarm(lower, &alarminfo);
}
static int rpmsg_rtc_cancelalarm(FAR struct rtc_lowerhalf_s *lower,
int alarmid)
{
struct rpmsg_rtc_alarm_cancel_s msg =
{
.id = alarmid,
};
return rpmsg_rtc_send_recv((FAR struct rpmsg_rtc_lowerhalf_s *)lower,
RPMSG_RTC_ALARM_CANCEL, (struct rpmsg_rtc_header_s *)&msg,
sizeof(msg));
}
static int rpmsg_rtc_rdalarm(FAR struct rtc_lowerhalf_s *lower_,
FAR struct lower_rdalarm_s *alarminfo)
{
FAR struct rpmsg_rtc_lowerhalf_s *lower =
(FAR struct rpmsg_rtc_lowerhalf_s *)lower_;
*alarminfo->time = lower->alarminfo[alarminfo->id].time;
return 0;
}
#endif
#else
static int rpmsg_rtc_server_rdtime(FAR struct rtc_lowerhalf_s *lower,
FAR struct rtc_time *rtctime)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->rdtime(server->lower, rtctime);
}
static int rpmsg_rtc_server_settime(FAR struct rtc_lowerhalf_s *lower,
FAR const struct rtc_time *rtctime)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
FAR struct rpmsg_rtc_client_s *client;
FAR struct list_node *node;
struct rpmsg_rtc_header_s header;
int ret;
ret = server->lower->ops->settime(server->lower, rtctime);
if (ret >= 0)
{
nxsem_wait_uninterruptible(&server->exclsem);
header.command = RPMSG_RTC_SYNC;
list_for_every(&server->list, node)
{
client = (FAR struct rpmsg_rtc_client_s *)node;
rpmsg_send(&client->ept, &header, sizeof(header));
}
nxsem_post(&server->exclsem);
}
return ret;
}
static bool rpmsg_rtc_server_havesettime(FAR struct rtc_lowerhalf_s *lower)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->havesettime(server->lower);
}
#ifdef CONFIG_RTC_ALARM
static int rpmsg_rtc_server_setalarm(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setalarm_s *alarminfo)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->setalarm(server->lower, alarminfo);
}
static int rpmsg_rtc_server_setrelative(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setrelative_s *relinfo)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->setrelative(server->lower, relinfo);
}
static int rpmsg_rtc_server_cancelalarm(FAR struct rtc_lowerhalf_s *lower,
int alarmid)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->cancelalarm(server->lower, alarmid);
}
static int rpmsg_rtc_server_rdalarm(FAR struct rtc_lowerhalf_s *lower,
FAR struct lower_rdalarm_s *alarminfo)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->rdalarm(server->lower, alarminfo);
}
#endif
#ifdef CONFIG_RTC_PERIODIC
static int rpmsg_rtc_server_setperiodic(FAR struct rtc_lowerhalf_s *lower,
FAR const struct lower_setperiodic_s *alarminfo)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->setperiodic(server->lower, alarminfo);
}
static int rpmsg_rtc_server_cancelperiodic
(FAR struct rtc_lowerhalf_s *lower, int alarmid)
{
FAR struct rpmsg_rtc_server_s *server =
(FAR struct rpmsg_rtc_server_s *)lower;
return server->lower->ops->cancelperiodic(server->lower, alarmid);
}
#endif
static void rpmsg_rtc_server_ns_unbind(FAR struct rpmsg_endpoint *ept)
{
FAR struct rpmsg_rtc_client_s *client = container_of(ept,
struct rpmsg_rtc_client_s, ept);
FAR struct rpmsg_rtc_server_s *server = ept->priv;
nxsem_wait_uninterruptible(&server->exclsem);
list_delete(&client->node);
nxsem_post(&server->exclsem);
rpmsg_destroy_ept(&client->ept);
kmm_free(client);
}
#ifdef CONFIG_RTC_ALARM
static void rpmsg_rtc_server_alarm_cb(FAR void *priv, int alarmid)
{
FAR struct rpmsg_rtc_client_s *client = priv;
struct rpmsg_rtc_alarm_fire_s msg =
{
.header.command = RPMSG_RTC_ALARM_FIRE,
.id = alarmid,
};
rpmsg_send(&client->ept, &msg, sizeof(msg));
}
#endif
static int rpmsg_rtc_server_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv)
{
FAR struct rpmsg_rtc_header_s *header = data;
switch (header->command)
{
case RPMSG_RTC_GET:
{
FAR struct rpmsg_rtc_get_s *msg = data;
struct timespec ts;
header->result = clock_gettime(CLOCK_REALTIME, &ts);
msg->sec = ts.tv_sec;
msg->nsec = ts.tv_nsec;
return rpmsg_send(ept, msg, sizeof(*msg));
}
case RPMSG_RTC_SET:
{
FAR struct rpmsg_rtc_set_s *msg = data;
struct timespec ts;
ts.tv_sec = msg->sec;
ts.tv_nsec = msg->nsec;
header->result = clock_settime(CLOCK_REALTIME, &ts);
return rpmsg_send(ept, msg, sizeof(*msg));
}
#ifdef CONFIG_RTC_ALARM
case RPMSG_RTC_ALARM_SET:
{
FAR struct rpmsg_rtc_client_s *client = container_of(ept,
struct rpmsg_rtc_client_s, ept);
FAR struct rpmsg_rtc_alarm_set_s *msg = data;
FAR struct rpmsg_rtc_server_s *server = priv;
time_t time = msg->sec;
struct lower_setalarm_s alarminfo =
{
.id = msg->id,
.cb = rpmsg_rtc_server_alarm_cb,
.priv = client
};
gmtime_r(&time, (FAR struct tm *)&alarminfo.time);
alarminfo.time.tm_nsec = msg->nsec;
header->result = server->lower->ops->setalarm(server->lower,
&alarminfo);
return rpmsg_send(ept, msg, sizeof(*msg));
}
case RPMSG_RTC_ALARM_CANCEL:
{
FAR struct rpmsg_rtc_alarm_cancel_s *msg = data;
FAR struct rpmsg_rtc_server_s *server = priv;
header->result = server->lower->ops->cancelalarm(server->lower,
msg->id);
return rpmsg_send(ept, msg, sizeof(*msg));
}
#endif
default:
header->result = -ENOSYS;
return rpmsg_send(ept, header, sizeof(*header));
}
}
static void rpmsg_rtc_server_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv,
FAR const char *name,
uint32_t dest)
{
FAR struct rpmsg_rtc_server_s *server = priv;
FAR struct rpmsg_rtc_client_s *client;
if (strcmp(name, RPMSG_RTC_EPT_NAME))
{
return;
}
client = kmm_zalloc(sizeof(*client));
if (client == NULL)
{
return;
}
client->ept.priv = server;
if (rpmsg_create_ept(&client->ept, rdev, RPMSG_RTC_EPT_NAME,
RPMSG_ADDR_ANY, dest,
rpmsg_rtc_server_ept_cb,
rpmsg_rtc_server_ns_unbind) < 0)
{
kmm_free(client);
return;
}
nxsem_wait_uninterruptible(&server->exclsem);
list_add_tail(&server->list, &client->node);
nxsem_post(&server->exclsem);
}
#endif
/****************************************************************************
* Name: rpmsg_rtc_initialize
*
* Description:
*
* Take remote core RTC as external RTC hardware through rpmsg.
*
* Returned Value:
* Return the lower half RTC driver instance on success;
* A NULL pointer on failure.
*
****************************************************************************/
#ifndef CONFIG_RTC_RPMSG_SERVER
FAR struct rtc_lowerhalf_s *rpmsg_rtc_initialize(void)
{
FAR struct rpmsg_rtc_lowerhalf_s *lower;
lower = kmm_zalloc(sizeof(*lower));
if (lower != NULL)
{
lower->ops = &g_rpmsg_rtc_ops;
rpmsg_register_callback(lower,
rpmsg_rtc_device_created,
rpmsg_rtc_device_destroy,
NULL);
}
return (FAR struct rtc_lowerhalf_s *)lower;
}
#else
/****************************************************************************
* Name: rpmsg_rtc_server_initialize
*
* Description:
* Sync RTC info to remote core without external RTC hardware through
* rpmsg.
*
* Returned Value:
* Return the lower half RTC driver instance on success;
* A NULL pointer on failure.
*
****************************************************************************/
FAR struct rtc_lowerhalf_s *rpmsg_rtc_server_initialize(
FAR struct rtc_lowerhalf_s *lower)
{
FAR struct rpmsg_rtc_server_s *server;
server = kmm_zalloc(sizeof(*server));
if (server)
{
server->ops = &g_rpmsg_rtc_server_ops;
server->lower = lower;
list_initialize(&server->list);
nxsem_init(&server->exclsem, 0, 1);
if (rpmsg_register_callback(server, NULL, NULL,
rpmsg_rtc_server_ns_bind) < 0)
{
nxsem_destroy(&server->exclsem);
kmm_free(server);
return NULL;
}
}
return (FAR struct rtc_lowerhalf_s *)server;
}
#endif