【百度大脑AI计算盒FZ5C】看门狗功能的实现

robe.zhang

【百度大脑AI计算盒FZ5C】看门狗功能的实现

先看看门狗硬件电路：一个 en 使能信号，一个 wdi 输入信号。
他的工作原理是：en 高电平，wdi 信号有效，每过一秒 wdi 来个信号，硬件正常工作，如果 wdi 不来信号了，硬件认为软件死了，就去复位，这个复位动作是硬件完成了

使能信号随便一个 gpio 就可以完成，wdi 输入信号，如果使用 xilinx swdt 的话，需要 MIO 映射，映射的时候并不是每一个 MIO 都可以当作 wdi 的，一定要能映射到的 MIO 才可以。

再看芯片：xilinx 有两个看门狗：

但是计算盒比较有意思，偏偏把可以映射的 mio6，7，10，11 当作 GPIO 用，不可以映射的 38 当作 wdi 用
如果调换一下更好，但是硬件已经这样了，那就软件来补吧。

笔者在 5.4 内核版本中是这样实现的：修改一下设备树，en 使能端拉高，一直有效，系统心跳当作 wdi，如果死机系统心跳会停 wdi 没有信号，硬件自动复位。设备树配置如下：

测试方法和命令：

1. 
   
2. echo none > /sys/class/leds/swd-wdi/trigger                # 直接关闭看门狗，会重启
   
3. 
   
4. echo 0 > /sys/class/leds/swd-en/brightness                # 关闭看门狗功能，需要先失能，再关闭看门狗，不会重启
   
5. echo none > /sys/class/leds/swd-wdi/trigger
   
6. 
   
7. echo heartbeat > /sys/class/leds/swd-wdi/trigger        # 打开看门狗功能，需要先开启看门狗，再使能
   
8. echo 1 > /sys/class/leds/swd-en/brightness
   
9. 
   

复制代码

米尔也有自己实现：

米尔是写了个 gpio-watchdog 驱动实现，驱动中添加个时钟，时钟不停的反转 wdi 输出 pin，模拟 wdi 信号。同时导出类属性

1. static int watchdog_probe(struct platform_device *pdev)
   
2. {
   
3.         int ret = 0;
   
4. 
   
5.         gpdata = kmalloc(sizeof(struct watchdog_data), GFP_KERNEL);
   
6.         if(!gpdata) {
   
7.                 printk(KERN_ERR "No memory!\n");
   
8.                 return -ENOMEM;
   
9.         }
   
10.         memset(gpdata, 0, sizeof(struct watchdog_data));
    
11. 
    
12.         /* Init gpio */        
    
13.         gpdata->gpio = DEFAULT_WDI;
    
14. 
    
15.         ret = gpio_request(DEFAULT_WDI, DEV_NAME);
    
16.         if(ret < 0) {
    
17.                 printk(KERN_ERR "request gpio %d for %s failed!\n", DEFAULT_WDI, DEV_NAME);
    
18.                 goto gpio_request_fail;
    
19.         }
    
20. 
    
21.         /* init wdt feed interval */
    
22.         gpdata->period = RESET_MS; /* Init period */
    
23.         
    
24.         initialize_timer(gpdata);
    
25. 
    
26.         /* Init class */
    
27.         gpdata->class.name = DEV_NAME;
    
28.         gpdata->class.owner = THIS_MODULE;
    
29.         gpdata->class.class_groups = watchdog_class_groups;
    
30.         ret = class_register(&gpdata->class);
    
31.         if(ret) {
    
32.                 printk(KERN_ERR "class_register failed!\n");
    
33.                 goto class_register_fail;
    
34.         }
    
35.         
    
36.         /* Start watchdog timer here */
    
37.         gpio_direction_output(gpdata->gpio, gpdata->gpio_value);
    
38.         mod_timer(&gpdata->timer, jiffies + msecs_to_jiffies(gpdata->period));
    
39.         gpdata->running = 1;
    
40.         
    
41.         printk(KERN_ALERT "%s driver initialized successfully!\n", DEV_NAME);
    
42.         return 0;
    
43. 
    
44. class_register_fail:
    
45.         destroy_timer(gpdata);
    
46.         gpio_free(gpdata->gpio);
    
47.         
    
48. gpio_request_fail:
    
49.         kfree(gpdata);
    
50.         
    
51.         return ret;
    
52. }

复制代码

1. static void initialize_timer(struct watchdog_data * pdata)
   
2. {
   
3.         if(!pdata) {
   
4.                 printk(KERN_ERR "Watchdog device has not been initialized yet.\n");
   
5.                 return;
   
6.         }
   
7. 
   
8.         if (pdata->period <= 0) {
   
9.                 pdata->period = RESET_MS;
   
10.         }
    
11. 
    
12.         timer_setup( &pdata->timer, reset_watchdog, 0 );
    
13. 
    
14. }

复制代码

反转 wdi 信号

1. static void reset_watchdog(struct timer_list *t)
   
2. {
   
3.         struct watchdog_data * pdata = from_timer(pdata, t, timer);
   
4.         
   
5.         pdata->gpio_value ^= 0x1;
   
6.         gpio_direction_output(pdata->gpio, pdata->gpio_value);
   
7.         mod_timer(&pdata->timer, jiffies + msecs_to_jiffies(pdata->period));
   
8. //        printk(KERN_ALERT "- reset wd.\n");
   
9. }

复制代码

类属性导出：

1. /* class attribute show function. */
   
2. static ssize_t watchdog_show(struct class *cls, struct class_attribute *attr, char *buf)
   
3. {
   
4.         struct watchdog_data *pdata = (struct watchdog_data *)container_of(cls, struct watchdog_data, class);
   
5.         return sprintf(buf, "%d\n", pdata->running?pdata->period:0);
   
6. }
   
7. 
   
8. /* class attribute store function. */
   
9. static ssize_t watchdog_store(struct class *cls, struct class_attribute *attr, const char *buf, size_t count)
   
10. {
    
11.         struct watchdog_data *pdata = (struct watchdog_data *)container_of(cls, struct watchdog_data, class);
    
12.         int tmp;
    
13.         
    
14.         if(!buf || sscanf(buf, "%d", &tmp) <= 0) {
    
15.                 return -EINVAL;
    
16.         }
    
17.         
    
18.         if(tmp == 0 && pdata->running) { /* Stop the watchdog timer */
    
19.                 del_timer(&pdata->timer);
    
20.                 pdata->running = 0;
    
21.                
    
22.                 /* Set gpio to input(High-Z state) to disable external watchdog timer */
    
23.                 gpio_direction_input(pdata->gpio);
    
24.                
    
25.                 printk("Cancel watchdog timer!\n");
    
26.         } else if(tmp > 0) {
    
27.                 printk(KERN_ALERT "Set period to %d ms .\n", tmp);
    
28.                 pdata->period = tmp;
    
29.                 if(!pdata->running) {
    
30.                         printk(KERN_ALERT "Start WD timer.\n");
    
31.                         mod_timer(&pdata->timer, jiffies + msecs_to_jiffies(pdata->period));
    
32.                         pdata->running = 1;
    
33.                 }
    
34.         } else {
    
35.                 return -EINVAL;
    
36.         }
    
37.         
    
38.         return count;
    
39. }
    
40. struct class_attribute class_attr_watchdog = __ATTR(wd_period_ms, S_IRUGO | S_IWUSR , watchdog_show, watchdog_store);
    
41. 
    
42. static ssize_t feed_show(struct class *cls, struct class_attribute *attr, char *buf)
    
43. {
    
44.         return sprintf(buf, "write '1' to enable manual-mode and disable auto-mode.\n");
    
45. }
    
46. 
    
47. static ssize_t feed_store(struct class *cls, struct class_attribute *attr, const char *buf, size_t count)
    
48. {
    
49.         struct watchdog_data *pdata = (struct watchdog_data *)container_of(cls, struct watchdog_data, class);
    
50.         int tmp;
    
51.         if(!buf || sscanf(buf, "%d", &tmp) <= 0) {
    
52.                 return -EINVAL;
    
53.         }
    
54.         
    
55.         if(tmp == 0) {
    
56.                 if(pdata->running == 0) {
    
57.                         printk(KERN_ALERT "Cancel watchdog.\n");
    
58.                         /* Set gpio to input(High-Z state) to disable external watchdog timer */
    
59.                         gpio_direction_input(pdata->gpio);
    
60.                 } else {
    
61.                         printk(KERN_ALERT "Can not cancel watchdog by writing 'wd_feed' while running in auto-mode.\n");
    
62.                 }
    
63.         } else if(tmp > 0) {
    
64.                 if(pdata->running) {
    
65.                         printk(KERN_ALERT "Disable auto-mode and switch to manual-mode.\n");
    
66.                         del_timer(&pdata->timer);
    
67.                         pdata->running = 0;
    
68.                 }
    
69.                 pdata->gpio_value ^= 0x1;
    
70.                 gpio_direction_output(pdata->gpio, pdata->gpio_value);
    
71.         } else {
    
72.                 return -EINVAL;
    
73.         }
    
74.         return count;
    
75. }
    
76. struct class_attribute class_attr_feed = __ATTR(wd_feed, S_IRUGO | S_IWUSR , feed_show, feed_store);
    
77. 
    
78. /* Attributes declaration: Here I have declared only one attribute attr1 */
    
79. static struct attribute *watchdog_class_attrs[] = {
    
80.         &class_attr_watchdog.attr,
    
81.         &class_attr_feed.attr,
    
82.         NULL,
    
83. };
    
84. ATTRIBUTE_GROUPS(watchdog_class);

复制代码

驱动自己会编译进内核，一开机看门狗就工作了，通过类属性文件调整开关看门狗功能，等