05day02wdt

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>

#include <mach/regs-clock.h> //EXYNOS4_CLKGATE_IP_PERIR
#include <mach/map.h> //EXYNOS4_PA_WATCHDOG
#include <linux/ioport.h> //request_mem_region
#include <linux/io.h> //ioremap
#include <linux/interrupt.h> //request_irq
#include <mach/irqs.h> //EXYNOS4_IRQ_WDT

#include <linux/miscdevice.h>
#include <linux/fs.h>

#include "wdt.h"

//内核里已经有看门狗驱动，为了不冲突，必须关闭内核中的看门狗驱动
//make menuconfig -> Device Drivers -> S3C2410 Watchdog 关闭

#define DEVNAME "ldm"

#define CLKGATE_IP_PERIR (*(volatile u32*)EXYNOS4_CLKGATE_IP_PERIR)

enum {
    PCLK = 100000000, //100MHZ
    PRESCALER = 99, //1级分频为100分频
    DIV_FACTOR = 0b11, //2级分频为128分频
    WDT_HZ = PCLK / (PRESCALER + 1) / (16 << DIV_FACTOR),
};

struct ldm_info {
    struct miscdevice dev;
    struct file_operations ops;
};
static struct ldm_info ldm;

struct wdt_reg {
    u32 con, dat, cnt, clrint;
};
static struct wdt_reg *reg;

static long ldm_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case WDT_ON:
        if (arg) {
            reg->con |= 1 << 5;
        } else {
            reg->con &= ~(1 << 5);
        }
        break;
    case WDT_INTERVAL:
        reg->dat = WDT_HZ * arg / 1000;
        reg->cnt = WDT_HZ * arg / 1000;
        break;
    case WDT_RESET:
        reg->con |= 1;
        break;
    case WDT_INTERRUPT:
        reg->con &= ~1;
        reg->con |= 1 << 2;
        break;
    default:
        break;
    }

    return 0;
}

static irqreturn_t wdt_handler(int irqno, void *data)
{
    printk("%s:%s, %d
", __FILE__, __FUNCTION__, __LINE__);

    //清除中断标志
    reg->clrint = 0x1234;
    return IRQ_HANDLED;
}

static int test_init(void)
{
    int ret = 0;

    printk("%s:%s, %d
", __FILE__, __FUNCTION__, __LINE__);

    ldm.dev.minor = MISC_DYNAMIC_MINOR; //次设备号
    ldm.dev.name = DEVNAME;
    ldm.dev.fops = &ldm.ops;
    ldm.ops.unlocked_ioctl = ldm_ioctl;

    ret = misc_register(&ldm.dev);
    if (ret < 0) {
        printk(KERN_ERR "misc_register failed
");
        goto err_misc_register;
    }

    //根据4412手册P446表格，可知，wdt位于PERI_R总线，时钟源是100MHZ

    //打开wdt所在总线的时钟使能开关,4412手册P487
    CLKGATE_IP_PERIR |= 1 << 14;

    //申请寄存器的访问范围,通过/proc/iomem
    if (!request_mem_region(EXYNOS4_PA_WATCHDOG, sizeof(struct wdt_reg), DEVNAME)) {
        ret = -EBUSY;
        printk(KERN_ERR "request_mem_region failed
");
        goto err_request_mem_region;
    }

    //映射寄存器，得到虚拟地址
    reg = ioremap(EXYNOS4_PA_WATCHDOG, sizeof(struct wdt_reg));

    //申请中断
    ret = request_irq(EXYNOS4_IRQ_WDT, wdt_handler, 0, DEVNAME, NULL);
    if (ret < 0) {
        printk(KERN_ERR "request_irq failed
");
        goto err_request_irq;
    }

    reg->dat = WDT_HZ / 2;
    reg->cnt = WDT_HZ / 2;
    reg->con = PRESCALER << 8 | DIV_FACTOR << 3 | 1 << 2;

    return 0;

err_request_irq:
    iounmap(reg);
    release_mem_region(EXYNOS4_PA_WATCHDOG, sizeof(struct wdt_reg));
err_request_mem_region:
    CLKGATE_IP_PERIR &= ~(1 << 14);
    misc_deregister(&ldm.dev);
err_misc_register:
    return ret;
}

static void test_exit(void)
{
    printk("%s:%s, %d
", __FILE__, __FUNCTION__, __LINE__);

    reg->con &= ~(1 << 5);

    free_irq(EXYNOS4_IRQ_WDT, NULL);
    iounmap(reg);
    release_mem_region(EXYNOS4_PA_WATCHDOG, sizeof(struct wdt_reg));

    //关闭wdt所在总线的时钟使能开关
    CLKGATE_IP_PERIR &= ~(1 << 14);

    misc_deregister(&ldm.dev);
}

module_init(test_init);
module_exit(test_exit);

MODULE_LICENSE("GPL");

.h

#pragma once

#include <linux/ioctl.h> //实际头文件是linux/asm-generic/ioctl.h

//参考内核文档documentation/ioctl/ioctl-number.txt和ioctl-decoding.txt

#define WDT_ON _IOW('l', 1, int)
#define WDT_INTERVAL _IOW('l', 2, unsigned int)
#define WDT_RESET _IO('l', 3)
#define WDT_INTERRUPT _IO('l', 4)

.app

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include "wdt.h"

int main(int argc, char **argv)
{
    if ((argc != 3) && (argc != 4)) {
        fprintf(stderr, "Usage: cmd <device file> <request> [interval second]
request: on off reset interrupt interval
");
        return -1;
    }

    int fd = open(argv[1], O_RDWR);
    if (fd < 0) {
        perror("open device");
        goto err_open;
    }

    if (!strcmp(argv[2], "on")) {
        ioctl(fd, WDT_ON, 1);
    } else if (!strcmp(argv[2], "off")) {
        ioctl(fd, WDT_ON, 0);
    } else if (!strcmp(argv[2], "reset")) {
        ioctl(fd, WDT_RESET);
    } else if (!strcmp(argv[2], "interrupt")) {
        ioctl(fd, WDT_INTERRUPT);
    } else if (!strcmp(argv[2], "interval")) {
        ioctl(fd, WDT_INTERVAL, atoi(argv[3]));
    } else {
        fprintf(stderr, "unknown request %s
", argv[2]);
    }

    close(fd);

    return 0;

err_open:
    return -1;
}