如何对实时时钟RTC芯片进行调试呢

　　我这里主要是rtc：am1805 rtc1800
　　驱动运行起来就默认。轮播而重启喂狗的有喂狗和用户狗的实现方式：
　　1、喂狗：
　　在用户地定时去，让rtc芯片的空间操作方式到来之前，不触发系统重新启动而重新启动：
　　2、狗内核驱动：
　　循环运行一个系统运行_看门狗执行供给的任务，只要内核一直运行dog_feeddog-设置看门狗定时器
　　* *输入：* period - 超时周期，以 ms 为单位（65 到 124，000）* pin - 产生看门狗信号的引脚* 0 =》 禁用 WDT
　　* 1 =》 在 FOUT/nIRQ 上产生中断
　　* 2 =》 在 PSW/nIRQ2 上产生中断
　　* 3 =》 在 nRST 上产生复位（仅限 AM18xx）
　　*
　　*/
　　am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_PIN_RST）;//设置 feeddog，并使能复位 pin，发送 feeddog 信号
　　am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_DISABLE）; //设置disabled feeddog
　　rtc_am1805看门狗
　　设置，首先确认有以下两个节点：
　　sys/class/rtc_am1805/feeddog //feddog 操作
　　sys/class/rtc_am1805/timer //disabled feeddog 之后重新使能内核feeddog在time之后系统重启
　　feeddog节点代码实现：
　　static ssize_t am1805_show_feeddog（struct class *class，
　　struct class_attribute *attr， char *buf）
　　{
　　int ret;
　　if （rtc_info-》watchdog_enable==TYPE_DISABLE）
　　{
　　ret = sprintf（buf， “0 -- disablen”）;
　　}
　　else if（rtc_info-》watchdog_enable==TYPE_KERNLE）
　　{
　　ret = sprintf（buf， “1 -- kernel feedn”）;
　　}
　　else{
　　ret = sprintf（buf， “2 -- 用户提要n”）;
　　}
　　返回 ret;
　　}
　　static ssize_t am1805_store_feeddog（struct class *class，
　　struct class_attribute *attr， const char *buf， size_t count）
　　{
　　int type;
　　RTC_DBG（RTC_DBG_VAL， “%s ，run n”，__func__）;
　　sscanf（缓冲区，”
　　if（type==0）{
　　rtc_info-》watchdog_enable = TYPE_DISABLE;
　　am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_DISABLE）;
　　}
　　else if（type==1）{
　　rtc_info-》watchdog_enable = TYPE_KERNLE;
　　am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_PIN_RST）;
　　}
　　else{
　　rtc_info-》watchdog_enable = TYPE_USER;
　　am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_PIN_RST）;
　　}
　　返回计数；
　　}
　　静态结构类属性 rtc_class_attrs［］ = {
　　__ATTR（show_all_reg， S_IRUGO | S_IWUSR， show_all_reg， NULL），
　　__ATTR（时间， S_IRUGO | S_IWUSR， show_time， store_time），
　　`
　　_
　　_
　　_ ），
　　__ATTR（setalarm， S_IRUGO | S_IWUSR， am1805_set_alarm，NULL），
　　__ATTR_NULL
　　};
　　静态结构类 rtc_am1805_class = {
　　.name = “rtc_am1805”，
　　.class_attrs = rtc_class_attrs，
　　};
　　probe函数中调用以下接口创建类节点［这里只节选部分代码］：
　　static int rtc_am1805_probe（struct platform_device *pdev）
　　{
　　。..
　　ret = class_register（&rtc_am1805_class）;
　　如果（返回）{
　　pr_info（“类注册 rtc_class 失败！n”）;
　　返回-1；
　　}
　　。..
　　}
　　设置和状态起来查看门狗（WDT）的状态：
　　root@stvs912:/ # cat sys/class/rtc_am1805/feeddog
　　1 -- kernel feed //驱动默认就是kernel feeddogroot
　　@stvs912:/ # echo 时间5/class/rtc_am18/class/rtc_am18//class/rtc_am18////关闭门rootstvs9///
　　#echo/rtc_am18////kernel feeddog，kernel@0/sys/feeddog//kernel feeddog，kernel@0/sys/feeddog，kernel@0/sys/feeddog，每次设置一定功能（ feeddog time）kernel会自动feeddog，这里时间是2s
　　root@stvs912:/#echo 2 》 sys/class/rtc_am1805/feeddog //用户feeddog，需要用户一定时间feeddog一次（shell-env下执行echo 2》 sys/class/rtc_am1805/feeddog），否则会重复自动重启系统
　　代码如下：
　　static ssize_t am1805_show_feeddog（struct class *class，
　　struct class_attribute *attr， char *buf）
　　{
　　int ret;
　　if （rtc_info-》watchdog_enable==TYPE_DISABLE）
　　{
　　ret = sprintf（buf， “0 -- disablen”）;
　　}
　　else if（rtc_info-》watchdog_enable==TYPE_KERNLE）
　　{
　　ret = sprintf（buf， “1 -- kernel feedn”）;
　　}
　　else{
　　ret = sprintf（buf， “2 -- 用户提要n”）;
　　}
　　返回 ret;
　　}
　　通过以下节点可以设置feeddog时间，验证看门狗功能：
　　rk3399_all:/#ls -l sys/class/rtc_am1805/timer
　　-rw-r--r-- 1 root root 4096 2019-11-13 09:19系统/类/rtc_am1805/定时器
　　例如feeddog设置disabled feeddog之后，然后重新使能内核feeddog在time（10s）之后系统重启可以这样验证：
　　rk3399_all:/ # echo 0 》 sys/class/rtc_am1805/feeddog //disabled feeddog
　　rk3399_all:/ # echo 1 》 sys/class/rtc_am1805/feeddog //启用内核feeddog
　　rk3399_all:/ # echo 10000 》 sys/class/rtc_am1805/timer //feeddog = 10s，也就是设置喂狗的时间（或者为10s，10s之前要喂狗） kernel喂狗或者user
　　喂狗：/#cat sys/class/rtc_am1805/timer
　　10000
　　rk399_all:/#echo 2 》 sys/class/rtc_am1805/feeddog//设置用户喂狗，并且每次间隔10s之前要喂狗一次
　　代码实现如下［节选部分］：
　　static ssize_t aml1805_show_timer（struct class* class，
　　struct class_attribute *att， char* buf）
　　{
　　RTC_DBG（RTC_DBG_VAL， “%s ，run n”，__func__）;
　　返回 sprintf（buf， “%dn”， rtc_info-》watchdog_timer）;
　　}
　　static ssize_t am1805_store_timer（struct class* class，
　　struct class_attribute* att， const char* buf， size_t count）
　　{
　　int value;
　　RTC_DBG（RTC_DBG_VAL， “%s ，run n”，__func__）;
　　sscanf（buf，“%i”，&value）;
　　RTC_DBG（RTC_DBG_VAL， “值 = %d n”， 值）;
　　rtc_info-》watchdog_timer = 值；
　　am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_PIN_RST）;
　　返回计数；
　　}真正原因
　　是因为这块板子在进入休眠之后
　　分析：
　　当前的情况下，我们的子子都是做会的假冒的不自动feeddog系统开始启动，需要在挂起的情况下关闭feeddog，在重启系统的时候重新打开，下面是feeddog的函数。
　　解决方法：当机器进入休眠的时候，禁用唤醒唤醒的处理功能，在唤醒之后的watchdog，启用watchdog功能
　　struct device *dev）
　　+{
　　+ pr_info（“%s，line（%d）： 进入挂起n”， __func__， __LINE__）;
　　+ //rtc_info-》watchdog_enable = TYPE_DISABLE;
　　+ am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_DISABLE）;
　　+
　　+ 返回 0;
　　+}
　　+
　　+static int rtc_am1805_resume（struct device *dev）
　　+{
　　+
　　+ pr_info（“%s，line（%d）： enter resumen”， __func__， __LINE__）;
　　+ if（rtc_info-》watchdog_enable ！= TYPE_DISABLE）
　　+ am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_PIN_RST）;
　　+ 返回 0；
　　+}
　　+
　　静态无效 rtc_am1805_shutdown（struct i2c_client * client）
　　{
　　unsigned char val=0;
　　@@ -1374，6 +1392，9 @@ static void rtc_am1805_shutdown（struct i2c_client * client）
　　rtc_am1805_i2c_write（&val， WDT_REG， 0x01）;
　　}
　　+静态 SIMPLE_DEV_PM_OPS（rtc_am1805_pm_ops， rtc_am1805_suspend，
　　+ rtc_am1805_resume）;
　　+
　　static const struct i2c_device_id am1805_id［］ = {
　　{ “rtc_am1805”， 0 }，
　　{ }
　　@@ -1389，6 +1410，7 @@ struct i2c_driver rtc_am1805_driver = {
　　.name = “rtc_am1805”，
　　.owner = THIS_MODULE，
　　.of_match_table = am1805_rtc_dt_match，
　　+ .pm = &rtc_am1805_pm_ops，
　　}，
　　.probe = rtc_am1805_probe，
　　.remove = （rtc_am1805_remove），
　　feeddog 间隔时间 echo xxxx 》 sys/class/rtc_am1805/timer ，设置到时间之后就自动重启了
　　static ssize_t am18055 （struct class* class，
　　struct class_attribute* att， const char* buf， size_t count）
　　{
　　int value;
　　RTC_DBG（RTC_DBG_VAL， “%s ，run n”，__func__）;
　　sscanf（buf，“%i”，&value）;
　　RTC_DBG（RTC_DBG_VAL， “值 = %d n”， 值）;
　　rtc_info-》watchdog_timer = 值；
　　// am1805_watchdog_feeddog（rtc_info-》watchdog_timer，WATCHDOG_INT_PIN_RST）;
　　返回计数；
　　}