linux设备驱动归纳总结（十一）：写个简单的看门狗驱动

墨蓝 2022-03-19 03:58 313阅读 0赞

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

设备驱动的归纳已经差不多了，趁着知识点还没有遗忘，写点代码巩固一下，来个简单的看门狗驱动——静态平台类的杂设备看门狗驱动，有定时和重启两个基本功能。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、S3C2440中的看门狗——具体请看s3c2440文档

看门狗应该可以算是S3C2440中最简单的一个设备的，仅仅只有三个寄存器需要配置。S3C2440中的看门狗有两种功能（只能二选一）：

1、复位功能，在指定时间内，如果没有执行喂狗操作。指定时间到达后会执行系统重启操作。

2、定时功能，每隔指定的时间，看门狗就会往处理器发送中断，执行中断处理函数。

接下来就要看看控制看门狗的三个寄存器：

1、控制寄存器——WTCON：

[![25014876_1297182150ok5L.png][]][25014876_1297182150ok5L.png]

首先要看看分频系数Prescaler value\[15:8\]和时钟分频Clock select\[4:3\]。看门狗的时钟频率就是通过这两个值分频得出的：

t\_watchdog = 1/\[ PCLK / (Prescaler value + 1) / Division\_factor \]

每个(1/t\_watchdog)秒，看门狗计数器减一。

Watchdog timer\[5\]是看门狗的是能控制位，初始化时必须将此为置一，不然看门狗无法操作。

Interrupt generation\[2\]是控制中断的产生，如果你使用看门狗来执行定时功能，置一代表使能看门狗产生中断，反之不产生中断。

Reset enable/disable\[0\]用控制看门狗是否复位，如果置一，代表当时间到达后系统重启。

2、数据寄存器WTDAT和计数寄存器WTCNT

这两个都是用于存放16位数据的寄存器。

1、如果是复位模式，从WTCON\[5\]置一开始，每隔(1/t\_watchdog)秒，WTCNT中的值减一，直到WTCNT为0，系统就会复位。在WTCNT还没有为0前，可以重新往WTCNT中赋值，这样WTCNT就会从新的数值开始减一，这就是所谓的喂狗操作，重复地在WTCNT变0前喂狗，就可以让系统不复位。

2、如果是定时模式， 从WTCON\[5\]置一开始，每隔(1/t\_watchdog)秒，WTCNT中的值减一，直到WTCNT为0，看门狗往处理器发送中断信号，并自动将WTDAT赋值给WTCNT，让WTCNT重新开始减一。这样的重复操作就实现了看门狗的定时。

注意：不管是哪一种模式，一开始时看门狗都不会将WTDAT的值赋给WTCNT，都是直接以WTCNT的值开始计数。所以，在是能看门狗之前，必须先设备WTCNT的值，指定时间长短。

接下来的程序我需要的时间间隔是1秒，所以，Prescaler value\[15:8\]我赋值为99，Clock select\[4:3\]我赋值为128。S3C2440中的PCLK定义为50000000，通过公式可以计算出：

t\_watchdog = 1/\[ PCLK / (Prescaler value + 1) / Division\_factor \] = 3906.25

所以，看门狗的计数间隔是(1/3906.25)秒，1秒需要计数大约3906次。

看门狗介绍完毕，接着就开始写驱动了，在写驱动前贴张之前我介绍过的图，我写驱动的步骤：

[![25014876_12971821719PD5.png][]][25014876_12971821719PD5.png]

接在来我就会按这个顺序来写个简单的看门狗驱动，实现看门狗的两种功能，定时和复位。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、第一个看门狗程序，代码路径11th\_wdt/1st。

写驱动前先要写一些基本的操作代码，检验一下该设备是否能正常工作。

第一个看门狗程序做了三步，简单实现了看门狗的复位操作：

1、定义了一个维护看门狗数据的结构体：

9 struct \_wdt\_t \{

10      unsigned long phys, virt; //存放物理地址和对应的虚拟地址

11     unsigned long wtcon, wtdat, wtcnt; //存放寄存器

12     unsigned long reg;

14     void (\*init\_reset)(struct \_wdt\_t \*); //操作看门狗的函数指针

15 \};

2、实现了看门狗的复位操作：

19 static void s3c\_wdt\_init\_reset(struct \_wdt\_t \*wdt)

20 \{

21     iowrite32((int)(WDT\_1S \* 10), wdt->wtdat); //其实这个不设置也可以

22     iowrite32((int)(WDT\_1S \* 10), wdt->wtcnt); //设置10秒后系统复位

23     iowrite32(0x6339, wdt->wtcon); //设置wtcon寄存器为0x6339，使能了看门狗和复位功能

24 \}

3、封装了设备的初始化和注销函数：

26 int init\_wdt\_device(struct \_wdt\_t \*wdt)

27 \{

28     int ret = 0;

29     //ioremap

30     wdt->phys = 0x53000000;

31     wdt->virt = (unsigned long)ioremap(wdt->phys, 0x0c);

32      wdt->wtcon = wdt->virt + 0x0;

33      wdt->wtdat = wdt->virt + 0x4;

34      wdt->wtcnt = wdt->virt + 0x8;

36     //function

37      wdt->init\_reset = s3c\_wdt\_init\_reset;

38     return ret;

39 \}

41 void destroy\_wdt\_device(struct \_wdt\_t \*wdt)

42 \{

43     iounmap((void \*)wdt->virt);

44 \}

写完后编译，效果就是加载模块后十秒系统重启，看门狗的复位功能验证成功。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、第二个看门狗程序，代码路径11th\_wdt/2nd。

第一个看门狗程序实现了复位操作，接下来我就要在原来代码的基础上加上看门狗的定时功能。很简单，只贴上就三个函数，其他细节请看源代码：

1、初始化看门狗，设置为定时功能，每隔一秒产生一次中断：

29 static void s3c\_wdt\_init\_interrupt(struct \_wdt\_t \*wdt)

30 \{

31     iowrite32((int)(WDT\_1S), wdt->wtdat);

32     iowrite32((int)(WDT\_1S), wdt->wtcnt);

33     iowrite32(0x6338, wdt->wtcon);

34 \}

2、初始话后还不能产生中断，还需要实现开启和关闭中断操作，其实就是设置寄存器的一位：

36 static void s3c\_wdt\_start(struct \_wdt\_t \*wdt)

37 \{

38      wdt->reg = ioread32(wdt->wtcon);

39      wdt->reg |= (1 << 2);

40     iowrite32(wdt->reg, wdt->wtcon);

41 \}

43 static void s3c\_wdt\_stop(struct \_wdt\_t \*wdt)

44 \{

45     wdt->reg = ioread32(wdt->wtcon);

46     wdt->reg &= (1 << 2);

47     iowrite32(wdt->reg, wdt->wtcon);

48 \}

既然是产生了中断，就要注册中断和实现中断处理函数，中断的注册操作应该放在设备初始化函数中：

50 irqreturn\_t wdt\_irq\_handler(int irqno, void \*dev\_id)

51 \{

52     printk("wang wang wang ...\\n");

53     return IRQ\_HANDLED;

54 \}

56 int init\_wdt\_device(struct \_wdt\_t \*wdt)

57 \{

58     int ret = 0;

59     //ioremap

60     wdt->phys = 0x53000000;

61     wdt->virt = (unsigned long)ioremap(wdt->phys, 0x0c);

62     wdt->wtcon = wdt->virt + 0x0;

63     wdt->wtdat = wdt->virt + 0x4;

64     wdt->wtcnt = wdt->virt + 0x8;

66     //irq

67     ret = request\_irq(IRQ\_S3C2440\_WDT, wdt\_irq\_handler, IRQF\_TRIGGER\_NONE,

68                                         "s3c2440\_wdt-irq", NULL);

69     if(ret)\{

70         printk("request wdt-irq failed!\\n");

71         goto err;

72     \}

74     //function

75     wdt->init\_reset = s3c\_wdt\_init\_reset;

76     wdt->init\_interrupt = s3c\_wdt\_init\_interrupt;

77     wdt->start = s3c\_wdt\_start;

78     wdt->stop = s3c\_wdt\_stop;

80     return ret;

82 err:

83     iounmap((void \*)wdt->virt);

84     return ret;

85 \}

87 void destroy\_wdt\_device(struct \_wdt\_t \*wdt)

88 \{

89     free\_irq(IRQ\_S3C2440\_WDT, NULL);

90     iounmap((void \*)wdt->virt);

91 \}

写完后编译，效果就是加载模块后每隔一秒打印出一句话，看门狗的定时功能验证成功。

注意：一般是不能加载成功的，运行命令”cat /proc/interrupt”就知道，系统中本身就注册了一个看门狗中断，为了能够执行成功，方法有两个：（之前介绍过的两男共享一妞）

1、干掉系统中的看门狗中断：

方法：配置内核时不要选上看门狗设备。

2、修改内核源代码，添加共享标记。

我这里使用的是第一种解决方法。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、第三个看门狗程序，代码路径11th\_wdt/3rd。

上面已经实现了图上的三步：定义面向对象结构体，实现基本的硬件操作函数、定义设备的初始化和注销函数。

接下来就将它修改成静态平台类驱动。方法很简单，将之前放在wdt\_init的操作放在probe函数中，配对成功后自动调用，将之前放在wdt\_exit的操作放在remove函数中。

贴上部分代码：

97 static int s3c\_wdt\_probe(struct platform\_device \*pdev)

98 \{

99       printk("\[%s\]\\n", \_\_FUNCTION\_\_);

100     my\_wdt.phys = pdev->resource\[0\].start;

101     my\_wdt.irqno = pdev->resource\[1\].start;

102     init\_wdt\_device(&my\_wdt);

103     my\_wdt.init\_interrupt(&my\_wdt);

104     my\_wdt.start(&my\_wdt);

105     return 0;

106 \}

107

108 static int s3c\_wdt\_remove(struct platform\_device \*pdev)

109 \{

110     printk("\[%s\]\\n", \_\_FUNCTION\_\_);

111     my\_wdt.stop(&my\_wdt);

112     destroy\_wdt\_device(&my\_wdt);

113     return 0;

114 \}

115

116 static struct platform\_driver wdt\_pdrv = \{

117     .probe = s3c\_wdt\_probe,

118     .remove = s3c\_wdt\_remove,

119     .driver = \{

120         .name = "s3c\_wdt\_xb",

121     \},

122 \};

123

124 static int \_\_init wdt\_init(void)

125 \{

126     platform\_driver\_register(&wdt\_pdrv);

127     printk("hello wdt!\\n");

128     return 0;

129 \}

130

131 static void \_\_exit wdt\_exit(void)

132 \{

133     platform\_driver\_unregister(&wdt\_pdrv);

134     printk("bye wdt!\\n");

135 \}

136

137 module\_init(wdt\_init);

138 module\_exit(wdt\_exit);

既然说是静态平台类驱动，那就是需要修改内核代码，方法在[linux][][设备驱动归纳总结（九）：1.platform][linux][设备驱动][linux]有介绍，在三处文件添加代码：

1、arch/arm/mach-s3c2440/mach-mini2440.c

250 static struct platform\_device \*mini2440\_devices\[\] \_\_initdata = \{

251     &s3c\_device\_usb,

252     &s3c\_device\_rtc,

253     &s3c\_device\_lcd,

254     &s3c\_device\_wdt,

255     &s3c\_device\_led,

256     &s3c\_device\_wdt\_xb, //这是我新加的

257     &s3c\_device\_i2c0,

258     &s3c\_device\_iis,

259     &s3c\_device\_dm9k,

260     &net\_device\_cs8900,

261     &s3c24xx\_uda134x,

262 \};

2、arch/arm/plat-s3c24xx/devs.c

379 /\* Watchdog xiaobai\*/

380

381 static struct resource s3c\_wdt\_xb\_resource\[\] = \{

382     \[0\] = \{

383         .start = 0x53000000,

384         .end = 0x530000ff,

385         .flags = IORESOURCE\_MEM,

386     \},

387     \[1\] = \{

388         .start = IRQ\_S3C2440\_WDT,

389         .end = IRQ\_S3C2440\_WDT,

390         .flags = IORESOURCE\_IRQ,

391     \}

392 \};

393

394 struct platform\_device s3c\_device\_wdt\_xb = \{

395     .name = "s3c\_wdt\_xb",

396     .id = -1,

397     .num\_resources = ARRAY\_SIZE(s3c\_wdt\_xb\_resource),

398     .resource = s3c\_wdt\_xb\_resource,

399 \};

400

401 EXPORT\_SYMBOL(s3c\_device\_wdt\_xb);

3、arch/arm/plat-s3c/include/plat/devs.h

27 extern struct platform\_device s3c\_device\_dm9k;

28 extern struct platform\_device net\_device\_cs8900;

29 extern struct platform\_device s3c\_device\_fb;

30 extern struct platform\_device s3c\_device\_usb;

31 extern struct platform\_device s3c\_device\_lcd;

32 extern struct platform\_device s3c\_device\_wdt;

33 extern struct platform\_device s3c\_device\_led;

34 extern struct platform\_device s3c\_device\_wdt\_xb; //这是我添加的

35 extern struct platform\_device s3c\_device\_i2c0;

36 extern struct platform\_device s3c\_device\_i2c1;

37 extern struct platform\_device s3c\_device\_iis;

修改后重新编译内核，加载模块后，内核会自动调用probe函数，具体效果就是每隔一秒打印一句话。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五、第四个看门狗程序，代码路径11th\_wdt/4th。

接下来就要注册杂设备类驱动，并且提供ioctl命令给用户空间控制看门狗。

先要在头文件中实现几个命令：

/\*11th\_wdt/4th/ioctl\_wdt.h\*/

1 \#ifndef \_WDT\_H

2 \#define \_WDT\_H

4 \#define MAGIC 'x'

5 \#define WDT\_RESET \_IO(MAGIC, 0) //产生一个数字

6 \#define WDT\_INTERRUPT \_IO(MAGIC, 1)

7 \#define WDT\_START \_IO(MAGIC, 2)

8 \#define WDT\_STOP \_IO(MAGIC, 3)

10 \#endif /\* \_WDT\_H \*/

再看看ioctl的实现，很简单，四个命令对应四个不同的操作：

112 int s3c\_wdt\_ioctl (struct inode \*node, struct file \*filp,

113 unsigned int cmd, unsigned long args)

114 \{

115     switch(cmd)\{

116         case WDT\_RESET:

117             my\_wdt.init\_reset(&my\_wdt);

118             break;

119         case WDT\_INTERRUPT:

120             my\_wdt.init\_interrupt(&my\_wdt);

121             break;

122         case WDT\_START:

123             my\_wdt.start(&my\_wdt);

124             break;

125         case WDT\_STOP:

126             my\_wdt.stop(&my\_wdt);

127             break;

128         default:

129             printk("unknow ioctl cmd!\\n");

130             return - EINVAL;

131     \}

132     return 0;

133 \}

134

135 static struct file\_operations wdt\_fops = \{

136     .ioctl = s3c\_wdt\_ioctl,

137 \};

接着是实现杂设备类驱动：

139 /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

140 \* misc class \*

141 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

142

143 static struct miscdevice wdt\_misc = \{

144     .name = "s3c\_wdt",

145     .fops = &wdt\_fops,

146 \};

147

148 /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

149 \* platform总线操作\*

150 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

151 static int s3c\_wdt\_probe(struct platform\_device \*pdev)

152 \{

153     printk("\[%s\]\\n", \_\_FUNCTION\_\_);

154     my\_wdt.phys = pdev->resource\[0\].start;

155     my\_wdt.irqno = pdev->resource\[1\].start;

156

157     init\_wdt\_device(&my\_wdt);

158     misc\_register(&wdt\_misc);

159     return 0;

160 \}

161

162 static int s3c\_wdt\_remove(struct platform\_device \*pdev)

163 \{

164     printk("\[%s\]\\n", \_\_FUNCTION\_\_);

165     misc\_deregister(&wdt\_misc);

166     destroy\_wdt\_device(&my\_wdt);

167     return 0;

168 \}

最后就可以写个应用程序验证一下了：

/\*11th\_wdt/4th/app.c \*/

8 \#include "ioctl\_wdt.h"

10 int main(int argc, char \*argv\[\])

11 \{

12     int fd;

14     fd = open("/dev/s3c\_wdt", O\_RDWR);

15     if(fd < 0)

16         perror("open");

18     printf("./app \[func\]\\n");

19     printf("func : reset interrupt start stop\\n");

20     printf("\[%s\]\\n", argv\[1\]);

22     if(!strncasecmp("reset", argv\[1\], 5))

23         ioctl(fd, WDT\_RESET);

24     if(!strncasecmp("interrupt", argv\[1\], 9))

25         ioctl(fd, WDT\_INTERRUPT);

26     if(!strncasecmp("start", argv\[1\], 5))

27         ioctl(fd, WDT\_START);

28     if(!strncasecmp("stop", argv\[1\], 4))

29         ioctl(fd, WDT\_STOP);

31     return 0;

32 \}

编译后验证一下，可以使用./app reset启动复位功能，也可以./app interrupt & ./app start启动定时功能。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

六、第五个看门狗程序，代码路径11th\_wdt/5th。

看门狗的驱动就基本完成了，最后还有个功能要补充，喂狗，直接上代码：

65 static void s3c\_wdt\_feed(struct \_wdt\_t \*wdt)

66 \{

67     iowrite32((int)(WDT\_1S \* 10), wdt->wtcnt);

68 \}

然后稍稍修改一下其他代码就可以了。

编译后运行，执行./app reset后，只要在10秒内执行./app feed，系统就不会重启。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

七、总结

简单的看门狗驱动基本上就完成了，当然还有很多需要完善的地方，如设定定时的时间等。具体包含了以下知识点：

1、字符设备的方法；

2、io内存——ioremap；

3、中断注册；

4、platform设备驱动；

5、杂设备驱动；

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

[25014876_1297182150ok5L.png]: http://blog168.chinaunix.net/attachment/201102/8/25014876_1297182150ok5L.png
[25014876_12971821719PD5.png]: http://blog168.chinaunix.net/attachment/201102/8/25014876_12971821719PD5.png
[linux]: http://blog168.chinaunix.net/space.php?uid=25014876&do=blog&id=111745