libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[rtc] 移除rtc_core.c/.h 将内容转移到rtc.c/.h

This commit is contained in:
Meco Man 2021-07-30 02:42:57 +08:00
parent 9e47b95e61
commit 94a9332915
6 changed files with 156 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
bsp/efm32/drv_rtc.c
View File

@ -128,49 +128,6 @@ void rt_hw_rtc_isr(rt_device_t device)
RTC->IFC = _RTC_IFC_MASK; RTC->IFC = _RTC_IFC_MASK;
} }
/***************************************************************************//**
* @brief
* Register RTC device
*
* @details
*
* @note
*
* @param[in] device
* Pointer to device descriptor
*
* @param[in] name
* Device name
*
* @param[in] flag
* Configuration flags
*
* @return
* Error code
******************************************************************************/
rt_err_t rt_hw_rtc_register(
rt_device_t device,
const char *name,
rt_uint32_t flag)
{
RT_ASSERT(device != RT_NULL);
device->type = RT_Device_Class_RTC;
device->rx_indicate = RT_NULL;
device->tx_complete = RT_NULL;
device->init = RT_NULL;
device->open = rt_rtc_open;
device->close = RT_NULL;
device->read = rt_rtc_read;
device->write = RT_NULL;
device->control = rt_rtc_control;
device->user_data = RT_NULL; /* no private */
/* register a character device */
return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
}
/***************************************************************************//** /***************************************************************************//**
* @brief * @brief
* Initialize all RTC module related hardware and register RTC device to kernel * Initialize all RTC module related hardware and register RTC device to kernel
@ -224,7 +181,18 @@ void rt_hw_rtc_init(void)
} }
/* register rtc device */ /* register rtc device */
rt_hw_rtc_register(&rtc, RT_RTC_NAME, EFM32_NO_DATA); rtc.type = RT_Device_Class_RTC;
rtc.rx_indicate = RT_NULL;
rtc.tx_complete = RT_NULL;
rtc.init = RT_NULL;
rtc.open = rt_rtc_open;
rtc.close = RT_NULL;
rtc.read = rt_rtc_read;
rtc.write = RT_NULL;
rtc.control = rt_rtc_control;
rtc.user_data = RT_NULL; /* no private */
rt_device_register(&rtc, RT_RTC_NAME, RT_DEVICE_FLAG_RDWR | EFM32_NO_DATA);
} }
#endif #endif

33
components/drivers/include/drivers/rtc.h
View File

@ -6,13 +6,42 @@
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-10-10 aozima first version. * 2012-10-10 aozima first version.
* 2021-06-11 iysheng implement RTC v2.0
*/ */
#ifndef __RTC_H__ #ifndef __RTC_H__
#define __RTC_H__ #define __RTC_H__
#include <rtconfig.h> #include <rtdef.h>
#include <drivers/rtc_core.h>
#define RT_DEVICE_CTRL_RTC_GET_TIME 0x10 /**< get second time */
#define RT_DEVICE_CTRL_RTC_SET_TIME 0x11 /**< set second time */
#define RT_DEVICE_CTRL_RTC_GET_TIME_US 0x12 /**< get microsecond time */
#define RT_DEVICE_CTRL_RTC_SET_TIME_US 0x13 /**< set microsecond time */
#define RT_DEVICE_CTRL_RTC_GET_ALARM 0x14 /**< get alarm */
#define RT_DEVICE_CTRL_RTC_SET_ALARM 0x15 /**< set alarm */
struct rt_rtc_ops
{
rt_err_t (*init)(void);
rt_err_t (*get_secs)(void *arg);
rt_err_t (*set_secs)(void *arg);
rt_err_t (*get_alarm)(void *arg);
rt_err_t (*set_alarm)(void *arg);
rt_err_t (*get_usecs)(void *arg);
rt_err_t (*set_usecs)(void *arg);
};
typedef struct rt_rtc_device
{
struct rt_device parent;
const struct rt_rtc_ops *ops;
} rt_rtc_dev_t;
rt_err_t rt_hw_rtc_register(rt_rtc_dev_t *rtc,
const char *name,
rt_uint32_t flag,
void *data);
rt_err_t set_date(rt_uint32_t year, rt_uint32_t month, rt_uint32_t day); rt_err_t set_date(rt_uint32_t year, rt_uint32_t month, rt_uint32_t day);
rt_err_t set_time(rt_uint32_t hour, rt_uint32_t minute, rt_uint32_t second); rt_err_t set_time(rt_uint32_t hour, rt_uint32_t minute, rt_uint32_t second);

45
components/drivers/include/drivers/rtc_core.h
View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2021-06-11 iysheng first version.
*/
#ifndef __RTC_CORE_H__
#define __RTC_CORE_H__
#include <rtthread.h>
#define RT_DEVICE_CTRL_RTC_GET_TIME 0x10 /**< get second time */
#define RT_DEVICE_CTRL_RTC_SET_TIME 0x11 /**< set second time */
#define RT_DEVICE_CTRL_RTC_GET_TIME_US 0x12 /**< get microsecond time */
#define RT_DEVICE_CTRL_RTC_SET_TIME_US 0x13 /**< set microsecond time */
#define RT_DEVICE_CTRL_RTC_GET_ALARM 0x14 /**< get alarm */
#define RT_DEVICE_CTRL_RTC_SET_ALARM 0x15 /**< set alarm */
struct rt_rtc_ops
{
rt_err_t (*init)(void);
rt_err_t (*get_secs)(void *arg);
rt_err_t (*set_secs)(void *arg);
rt_err_t (*get_alarm)(void *arg);
rt_err_t (*set_alarm)(void *arg);
rt_err_t (*get_usecs)(void *arg);
rt_err_t (*set_usecs)(void *arg);
};
typedef struct rt_rtc_device
{
struct rt_device parent;
const struct rt_rtc_ops *ops;
} rt_rtc_dev_t;
rt_err_t rt_hw_rtc_register(rt_rtc_dev_t *rtc,
const char *name,
rt_uint32_t flag,
void *data);
#endif /* __RTC_CORE_H__ */

2
components/drivers/rtc/SConscript
View File

@ -7,7 +7,7 @@ CPPPATH = [cwd + '/../include']
group = [] group = []
if GetDepend(['RT_USING_RTC']): if GetDepend(['RT_USING_RTC']):
src = src + ['rtc.c', 'rtc_core.c'] src = src + ['rtc.c']
if GetDepend(['RT_USING_ALARM']): if GetDepend(['RT_USING_ALARM']):
src = src + ['alarm.c'] src = src + ['alarm.c']
if GetDepend(['RT_USING_SOFT_RTC']): if GetDepend(['RT_USING_SOFT_RTC']):

112
components/drivers/rtc/rtc.c
View File

@ -10,6 +10,7 @@
* 2012-04-16 aozima add scheduler lock for set_date and set_time. * 2012-04-16 aozima add scheduler lock for set_date and set_time.
* 2018-02-16 armink add auto sync time by NTP * 2018-02-16 armink add auto sync time by NTP
* 2021-05-09 Meco Man remove NTP * 2021-05-09 Meco Man remove NTP
* 2021-06-11 iysheng implement RTC v2.0
*/ */
#include <time.h> #include <time.h>
@ -20,6 +21,117 @@
#ifdef RT_USING_RTC #ifdef RT_USING_RTC
#define TRY_DO_RTC_FUNC(rt_rtc_dev, func_name, args) \
rt_rtc_dev->ops->func_name ? rt_rtc_dev->ops->func_name(args) : -RT_EINVAL;
/*
* This function initializes rtc_core
*/
static rt_err_t rt_rtc_core_init(struct rt_device *dev)
{
rt_rtc_dev_t *rtc_core;
RT_ASSERT(dev != RT_NULL);
rtc_core = (rt_rtc_dev_t *)dev;
if (rtc_core->ops->init)
{
return (rtc_core->ops->init());
}
return (-RT_ENOSYS);
}
static rt_err_t rt_rtc_core_open(struct rt_device *dev, rt_uint16_t oflag)
{
return (RT_EOK);
}
static rt_err_t rt_rtc_core_close(struct rt_device *dev)
{
/* Add close member function in rt_rtc_ops when need,
* then call that function here.
* */
return (RT_EOK);
}
static rt_err_t rt_rtc_core_control(struct rt_device *dev,
int cmd,
void *args)
{
rt_rtc_dev_t *rtc_core;
rt_err_t ret = -RT_EINVAL;
RT_ASSERT(dev != RT_NULL);
rtc_core = (rt_rtc_dev_t *)dev;
switch (cmd)
{
case RT_DEVICE_CTRL_RTC_GET_TIME:
ret = TRY_DO_RTC_FUNC(rtc_core, get_secs, args);
break;
case RT_DEVICE_CTRL_RTC_SET_TIME:
ret = TRY_DO_RTC_FUNC(rtc_core, set_secs, args);
break;
case RT_DEVICE_CTRL_RTC_GET_TIME_US:
ret = TRY_DO_RTC_FUNC(rtc_core, get_usecs, args);
break;
case RT_DEVICE_CTRL_RTC_SET_TIME_US:
ret = TRY_DO_RTC_FUNC(rtc_core, set_usecs, args);
break;
case RT_DEVICE_CTRL_RTC_GET_ALARM:
ret = TRY_DO_RTC_FUNC(rtc_core, get_alarm, args);
break;
case RT_DEVICE_CTRL_RTC_SET_ALARM:
ret = TRY_DO_RTC_FUNC(rtc_core, set_alarm, args);
break;
default:
break;
}
return ret;
}
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops rtc_core_ops =
{
rt_rtc_core_init,
rt_rtc_core_open,
rt_rtc_core_close,
RT_NULL,
RT_NULL,
rt_rtc_core_control,
};
#endif
rt_err_t rt_hw_rtc_register(rt_rtc_dev_t *rtc,
const char *name,
rt_uint32_t flag,
void *data)
{
struct rt_device *device;
RT_ASSERT(rtc != RT_NULL);
device = &(rtc->parent);
device->type = RT_Device_Class_RTC;
device->rx_indicate = RT_NULL;
device->tx_complete = RT_NULL;
#ifdef RT_USING_DEVICE_OPS
device->ops = &rtc_core_ops;
#else
device->init = rt_rtc_core_init;
device->open = rt_rtc_core_open;
device->close = rt_rtc_core_close;
device->read = RT_NULL;
device->write = RT_NULL;
device->control = rt_rtc_core_control;
#endif
device->user_data = data;
/* register a character device */
return rt_device_register(device, name, flag);
}
/** /**
* Set system date(time not modify, local timezone). * Set system date(time not modify, local timezone).
* *

123
components/drivers/rtc/rtc_core.c
View File

@ -1,123 +0,0 @@
/*
* COPYRIGHT (C) 2011-2021, Real-Thread Information Technology Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2021-06-11 iysheng first version.
*/
#include <drivers/rtc_core.h>
#define TRY_DO_RTC_FUNC(rt_rtc_dev, func_name, args) \
rt_rtc_dev->ops->func_name ? rt_rtc_dev->ops->func_name(args) : -RT_EINVAL;
/*
* This function initializes rtc_core
*/
static rt_err_t rt_rtc_core_init(struct rt_device *dev)
{
rt_rtc_dev_t *rtc_core;
RT_ASSERT(dev != RT_NULL);
rtc_core = (rt_rtc_dev_t *)dev;
if (rtc_core->ops->init)
{
return (rtc_core->ops->init());
}
return (-RT_ENOSYS);
}
static rt_err_t rt_rtc_core_open(struct rt_device *dev, rt_uint16_t oflag)
{
return (RT_EOK);
}
static rt_err_t rt_rtc_core_close(struct rt_device *dev)
{
/* Add close member function in rt_rtc_ops when need,
* then call that function here.
* */
return (RT_EOK);
}
static rt_err_t rt_rtc_core_control(struct rt_device *dev,
int cmd,
void *args)
{
rt_rtc_dev_t *rtc_core;
rt_err_t ret = -RT_EINVAL;
RT_ASSERT(dev != RT_NULL);
rtc_core = (rt_rtc_dev_t *)dev;
switch (cmd)
{
case RT_DEVICE_CTRL_RTC_GET_TIME:
ret = TRY_DO_RTC_FUNC(rtc_core, get_secs, args);
break;
case RT_DEVICE_CTRL_RTC_SET_TIME:
ret = TRY_DO_RTC_FUNC(rtc_core, set_secs, args);
break;
case RT_DEVICE_CTRL_RTC_GET_TIME_US:
ret = TRY_DO_RTC_FUNC(rtc_core, get_usecs, args);
break;
case RT_DEVICE_CTRL_RTC_SET_TIME_US:
ret = TRY_DO_RTC_FUNC(rtc_core, set_usecs, args);
break;
case RT_DEVICE_CTRL_RTC_GET_ALARM:
ret = TRY_DO_RTC_FUNC(rtc_core, get_alarm, args);
break;
case RT_DEVICE_CTRL_RTC_SET_ALARM:
ret = TRY_DO_RTC_FUNC(rtc_core, set_alarm, args);
break;
default:
break;
}
return ret;
}
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops rtc_core_ops =
{
rt_rtc_core_init,
rt_rtc_core_open,
rt_rtc_core_close,
RT_NULL,
RT_NULL,
rt_rtc_core_control,
};
#endif
rt_err_t rt_hw_rtc_register(rt_rtc_dev_t *rtc,
const char *name,
rt_uint32_t flag,
void *data)
{
struct rt_device *device;
RT_ASSERT(rtc != RT_NULL);
device = &(rtc->parent);
device->type = RT_Device_Class_RTC;
device->rx_indicate = RT_NULL;
device->tx_complete = RT_NULL;
#ifdef RT_USING_DEVICE_OPS
device->ops = &rtc_core_ops;
#else
device->init = rt_rtc_core_init;
device->open = rt_rtc_core_open;
device->close = rt_rtc_core_close;
device->read = RT_NULL;
device->write = RT_NULL;
device->control = rt_rtc_core_control;
#endif
device->user_data = data;
/* register a character device */
return rt_device_register(device, name, flag);
}