嵌入式 关于hi3518c看门狗驱动程序示例

最新推荐文章于 2022-11-03 15:16:22 发布
最新推荐文章于 2022-11-03 15:16:22 发布
阅读量2.4k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skdkjzz/article/details/17097395
版权 
hi3518c 看门狗驱动程序示例：
/*
	function :
本模块支持三个加载参数：default_margin、nodeamon与nowayout。
三者的含义分别为：
 （1）default_margin：指定看门狗产生中断的时间间隔，以second为单位，模块默认的值为60。
    该值必须大于或等于0，设为0则采用默认值。
 （2）nodeamon：指定在加载模块的时候，是否建立一个守护进程来进行喂狗。为0则产生守护进程，非0值则不产生；
    默认的值为0。不管是否建立专门喂狗的守护进程，一旦在由用户创建的程序中打开了看门狗对应的设备文件，
    则在用户程序关闭设备文件之前必须由用户程序完成喂狗动作，否则系统在两次时间间隔中断产生之后会复位。
 （3）nowayout：设置在用户打开看门狗设备文件并在相关程序退出之后，是否允许模块被卸载。
    非0值则不允许卸载，这时一旦在由用户创建的程序中打开了看门狗对应的设备文件之后，
    如果没有用户程序完成喂狗操作，则系统在一定时间之后会进行复位；为0则允许卸载，
    并且这时如果不再有用户程序打开着看门狗的设备文件，则在开启专门喂狗的守护进程的情况下，
    由守护进程完成喂狗的动作。它默认的值为0，可通过调用write向设备文件写入带‘V’的字符串来设为1；
    如果写入的字符串不带有‘V’，则为0。
*/
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/timer.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/fs.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <asm/io.h>
//#include <asm/arch/hardware.h>
#include <linux/kthread.h>
//#include <asm/arch/clock.h>
#include <linux/string.h>
#include <linux/sched.h>

#define OSDRV_MODULE_VERSION_STRING "HISI_WDT-MDC030001 @Hi3518v100"

#define HISILICON_SCTL_BASE 0x20050000
/* define watchdog IO */
#define HIWDT_BASE      0x20040000
#define HIWDT_REG(x)    (HIWDT_BASE + (x))

#define HIWDT_LOAD      0x000
#define HIWDT_VALUE     0x004
#define HIWDT_CTRL      0x008
#define HIWDT_INTCLR    0x00C
#define HIWDT_RIS       0x010
#define HIWDT_MIS       0x014
#define HIWDT_LOCK      0xC00

#define HIWDT_UNLOCK_VAL    0x1ACCE551

void __iomem *reg_ctl_base_va;
void __iomem *reg_wdt_base_va;
#define IO_WDT_ADDRESS(x) (reg_wdt_base_va + ((x)-(HIWDT_BASE)))

#define hiwdt_readl(x)      readl(IO_WDT_ADDRESS(HIWDT_REG(x)))
#define hiwdt_writel(v,x)   writel(v, IO_WDT_ADDRESS(HIWDT_REG(x)))

/* debug */
#define HIDOG_PFX "HiDog: "
#define hidog_dbg(params...) printk(KERN_INFO HIDOG_PFX params)

/* module param */
#define HIDOG_TIMER_MARGIN    60
static int default_margin = HIDOG_TIMER_MARGIN;    /* in seconds */
#define HIDOG_TIMER_DEMULTIPLY  9
module_param(default_margin, int, 0);
MODULE_PARM_DESC(default_margin, "Watchdog default_margin in seconds. (0<default_margin<80, default=" __MODULE_STRING(HIDOG_TIMER_MARGIN) ")");

static int nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, int, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");

static int nodeamon = 0;
module_param(nodeamon, int, 0);
MODULE_PARM_DESC(nodeamon, "By default, a kernel deamon feed watchdog when idle, set 'nodeamon=1' to disable this. (default=0)");

/* watchdog info */
static struct watchdog_info ident = {
    .options =  WDIOF_SETTIMEOUT |
                WDIOF_KEEPALIVEPING |
                WDIOF_MAGICCLOSE,
    .firmware_version = 0,
    .identity = "Hisilicon Watchdog",
};

/* local var */
static DEFINE_SPINLOCK(hidog_lock);
static int cur_margin = HIDOG_TIMER_MARGIN;
//static pid_t pid_hidog_deamon = -1;
struct task_struct *task_hidog_deamon = NULL;


#define HIDOG_EXIT    0
#define HIDOG_SELFCLR    1
#define HIDOG_EXTCLR    2
volatile static unsigned int hidog_state = 0;

static unsigned long driver_open = 0, orphan_timer = 0;
static int options = WDIOS_ENABLECARD;

#ifndef MHZ
#define MHZ (1000*1000)
#endif

static unsigned long rate = 3*MHZ;

static inline void hidog_set_timeout(unsigned int nr)
{
    unsigned long cnt = (~0x0)/rate;        /* max cnt */
    unsigned long flags; 

    spin_lock_irqsave(&hidog_lock, flags); 

    if( nr==0 || nr>cnt)
        cnt=~0x0; 
    else
        cnt = nr*rate;
    /* unlock watchdog registers */ 
    hiwdt_writel(HIWDT_UNLOCK_VAL, HIWDT_LOCK); 
    hiwdt_writel(cnt, HIWDT_LOAD); 
    hiwdt_writel(cnt, HIWDT_VALUE); 
    /* lock watchdog registers */ 
    hiwdt_writel(0, HIWDT_LOCK); 
    spin_unlock_irqrestore(&hidog_lock, flags); 
};

static inline void hidog_feed(void)
{
    unsigned long flags; 

    spin_lock_irqsave(&hidog_lock, flags); 
    /* unlock watchdog registers */ 
    hiwdt_writel(HIWDT_UNLOCK_VAL, HIWDT_LOCK); 
    /* clear watchdog */ 
    hiwdt_writel(0x00, HIWDT_INTCLR); 
    /* lock watchdog registers */ 
    hiwdt_writel(0, HIWDT_LOCK); 
    spin_unlock_irqrestore(&hidog_lock, flags); 
};

static int hidog_set_heartbeat(int t)
{
    int ret = 0;
    unsigned int cnt = (~0x0)/rate; 

    if( t==0 ) {
        printk(KERN_ERR HIDOG_PFX "set heartbeat to 0, heartbeat will not be changed.\n");
        t = cur_margin;
        ret = 1;
    } else if( t>cnt ) {
        printk(KERN_ERR HIDOG_PFX "set heartbeat range error, t = %d\n", t);
        printk(KERN_ERR HIDOG_PFX "force heartbeat to %d\n", cnt);
        t = cnt;
        ret = -1;
    }

    cur_margin = t;

    hidog_set_timeout(t);
    hidog_feed();

    if(NULL != task_hidog_deamon)
        wake_up_process(task_hidog_deamon);    

    return ret;
}

static int hidog_keepalive(void)
{
    hidog_feed();
    return 0;
}

static inline void hidog_start(void)
{
    unsigned long flags;
    unsigned long t;
    
    spin_lock_irqsave(&hidog_lock, flags);
    /* unlock watchdog registers */
    hiwdt_writel(HIWDT_UNLOCK_VAL, HIWDT_LOCK);
    hiwdt_writel(0x00, HIWDT_CTRL);
    hiwdt_writel(0x00, HIWDT_INTCLR);
    hiwdt_writel(0x03, HIWDT_CTRL);
    /* lock watchdog registers */
    hiwdt_writel(0, HIWDT_LOCK);
    /* enable watchdog clock --- set the frequency to 3MHz */
    t = readl(reg_ctl_base_va);
    writel(t & ~0x00800000, reg_ctl_base_va);
    spin_unlock_irqrestore(&hidog_lock, flags);
    
    options = WDIOS_ENABLECARD;
}

static inline void hidog_stop(void)
{
    unsigned long flags;

    spin_lock_irqsave(&hidog_lock, flags);

    /* unlock watchdog registers */
    hiwdt_writel(HIWDT_UNLOCK_VAL, HIWDT_LOCK);

    /* stop watchdog timer */
    hiwdt_writel(0x00, HIWDT_CTRL);
    hiwdt_writel(0x00, HIWDT_INTCLR);

    /* lock watchdog registers */
    hiwdt_writel(0, HIWDT_LOCK);

    spin_unlock_irqrestore(&hidog_lock, flags);

    hidog_set_timeout(0);

    options = WDIOS_DISABLECARD;
}

static int hidog_open(struct inode *inode, struct file *file)
{
    int ret = 0;

    if (test_and_set_bit(0, &driver_open))
        return -EBUSY;
    if (!test_and_clear_bit(0, &orphan_timer))
        __module_get(THIS_MODULE);
    /*
     *    Activate timer
     */
    hidog_keepalive();
    ret = nonseekable_open(inode, file);
    if(ret == 0)
        hidog_state = HIDOG_EXTCLR;

    return ret;
}

static int hidog_release(struct inode *inode, struct file *file)
{
    /*
     *    Shut off the timer.
     *     Lock it in if it's a module and we set nowayout
     */
    if (nowayout == 0) {
        //cur_margin = default_margin;
        hidog_state = HIDOG_SELFCLR;
        hidog_set_heartbeat(cur_margin);
        module_put(THIS_MODULE);
    } else {
        printk(KERN_CRIT HIDOG_PFX "Unexpected close, not stopping watchdog!\n");
        set_bit(0, &orphan_timer);
        hidog_keepalive();
    }
    clear_bit(0, &driver_open);

    if(options == WDIOS_DISABLECARD)
        printk(KERN_INFO HIDOG_PFX "Watchdog is disabled!\n");

    return 0;
}

static ssize_t hidog_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
{
    /*
     *      *    Refresh the timer.
     *           */
    if(len) {        
        size_t i;

        nowayout = 0;

        for (i = 0; i != len; i++) {
            char c;

            if (get_user(c, data + i))
                return -EFAULT;
            if (c == 'V')           
                nowayout = 1;
        }
        hidog_keepalive();
    }

    return len;
}

//static int hidog_ioctl(struct inode *inode, struct file *file,
//    unsigned int cmd, unsigned long arg)
static int hidog_ioctl(struct file *file,
    unsigned int cmd, unsigned long arg)
{
    void __user *argp = (void __user *)arg;
    int __user *p = argp;
    int new_margin;
    int new_options;

    switch (cmd) {
        case WDIOC_GETSUPPORT:
            return copy_to_user(argp, &ident,
                sizeof(ident)) ? -EFAULT : 0;
        case WDIOC_GETSTATUS:
        case WDIOC_GETBOOTSTATUS:
            return put_user(options, p);

        case WDIOC_KEEPALIVE:
            hidog_keepalive();
            return 0;

        case WDIOC_SETTIMEOUT:
            if (get_user(new_margin, p))
                return -EFAULT;
            if (hidog_set_heartbeat(new_margin))
                return -EINVAL;
            hidog_keepalive();
            return 0;

        case WDIOC_GETTIMEOUT:
            return put_user(cur_margin, p);

        case WDIOC_SETOPTIONS:
            if(nowayout)
                return -WDIOS_UNKNOWN;

            if (get_user(new_options, p))
                return -EFAULT;
            if(new_options & WDIOS_ENABLECARD) {
                hidog_start();
                hidog_set_heartbeat(cur_margin);
                return 0;
            } else if (new_options & WDIOS_DISABLECARD) {
                hidog_stop();
                return 0;
            } else
                return -WDIOS_UNKNOWN;

        default:
            return -ENOIOCTLCMD;
    }

}

/*
 *    Notifier for system down
 */

static int hidog_notifier_sys(struct notifier_block *this, unsigned long code,
    void *unused)
{
    if(code==SYS_DOWN || code==SYS_HALT) {
        /* Turn the WDT off */
        hidog_stop();
    }
    return NOTIFY_DONE;
}

/*
 *    Kernel Interfaces
 */

static struct file_operations hidog_fops = {
    .owner        = THIS_MODULE,
    .llseek        = no_llseek,
    .write        = hidog_write,
//    .ioctl        = hidog_ioctl,
    .unlocked_ioctl = hidog_ioctl,
    .open        = hidog_open,
    .release    = hidog_release,
};

static struct miscdevice hidog_miscdev = {
    .minor        = WATCHDOG_MINOR,
    .name        = "watchdog",
    .fops        = &hidog_fops,
};

static struct notifier_block hidog_notifier = {
    .notifier_call    = hidog_notifier_sys,
};

static char banner[] __initdata = KERN_INFO "Hisilicon Watchdog Timer: 0.01 initialized. default_margin=%d sec (nowayout= %d, nodeamon= %d)\n";

static int hidog_deamon(void *data)
{
    struct sched_param param = { .sched_priority = 99 };

    sched_setscheduler(current, SCHED_FIFO, ¶m);
    current->flags |= PF_NOFREEZE;

    set_current_state(TASK_INTERRUPTIBLE);

    while(hidog_state != HIDOG_EXIT)
    {
        switch(hidog_state) {
        case HIDOG_SELFCLR:
            if(options & WDIOS_ENABLECARD)
                hidog_feed();
            break;
        case HIDOG_EXTCLR:
            break;
        default:
            break;
        }
        /* sleep */
        /* when self feed dog, only use the default margin */
        schedule_timeout_interruptible(msecs_to_jiffies(default_margin*1000/2)+1);
    }

    set_current_state(TASK_RUNNING);

    return 0;
}

static int __init hidog_init(void)
{
    hidog_start();

    hidog_state = HIDOG_SELFCLR;
    if(!nodeamon) {
        #if 0
        struct task_struct *p_dog;
        p_dog = kthread_create(hidog_deamon, NULL, "hidog");
        if(IS_ERR(p_dog) <0) {
            printk(KERN_ERR HIDOG_PFX "create hidog_deamon failed!\n");
            return -1;        
        pid_hidog_deamon = p_dog->pid;        
        #endif

        struct task_struct *p_dog;
  p_dog = kthread_create(hidog_deamon, NULL, "hidog");
  if(IS_ERR(p_dog) <0) {
   printk(KERN_ERR HIDOG_PFX "create hidog_deamon failed!\n");
   return -1;
  }
  wake_up_process(p_dog);
  task_hidog_deamon = p_dog;
    }
    //printk(KERN_INFO OSDRV_MODULE_VERSION_STRING);
    return 0;
}

static int __init watchdog_init(void)
{
    int ret = 0;

    reg_wdt_base_va = ioremap_nocache((unsigned long)HIWDT_BASE, (unsigned long)0x10000);
    if (NULL == reg_wdt_base_va)
    {
        printk(KERN_ERR HIDOG_PFX "function %s line %u failed\n", 
            __FUNCTION__, __LINE__);
        return -1;
    }
    reg_ctl_base_va = ioremap_nocache((unsigned long)HISILICON_SCTL_BASE, 4);
    if (NULL == reg_ctl_base_va)
    {
        printk(KERN_ERR HIDOG_PFX "function %s line %u failed\n", 
            __FUNCTION__, __LINE__);
        iounmap(reg_wdt_base_va);
        return -1;
    }
    
    cur_margin = default_margin;

    /* Check that the default_margin value is within it's range ; if not reset to the default */
    if(hidog_set_heartbeat(default_margin)) {
        default_margin = HIDOG_TIMER_MARGIN;
        hidog_set_heartbeat(HIDOG_TIMER_MARGIN);
        printk(KERN_WARNING HIDOG_PFX "default_margin value must be 0<default_margin<%lu, using %d\n",
            ~0x0/rate, HIDOG_TIMER_MARGIN);
    }

    ret = register_reboot_notifier(&hidog_notifier);
    if(ret) {
        printk(KERN_ERR HIDOG_PFX "cannot register reboot notifier (err=%d)\n", ret);
        goto watchdog_init_errA;
    }

    ret = misc_register(&hidog_miscdev);
    if(ret) {
        printk (KERN_ERR HIDOG_PFX "cannot register miscdev on minor=%d (err=%d)\n",
            WATCHDOG_MINOR, ret);
        goto watchdog_init_errB;
    }

    printk(banner, default_margin, nowayout, nodeamon);

    ret = hidog_init();
    if(ret) {
        goto watchdog_init_errC;
    }
    //printk(KERN_INFO OSDRV_MODULE_VERSION_STRING "\n");
    return ret;

watchdog_init_errC:
    misc_deregister(&hidog_miscdev);
watchdog_init_errB:
    unregister_reboot_notifier(&hidog_notifier);
watchdog_init_errA:
    return ret;
}

static void __exit hidog_exit(void)
{
    hidog_set_timeout(0);
    hidog_stop();
#if 0
    for(hidog_state=HIDOG_EXIT; !nodeamon; ) {
        #if 0
  struct task_struct *p_dog = find_task_by_vpid(pid_hidog_deamon);    
        if(p_dog == NULL)
            break;
        #endif
        
        struct task_struct *p_dog = task_hidog_deamon;
  if(p_dog == NULL)
   break;
  wake_up_process(p_dog);
  yield();
    }
#endif
    hidog_state=HIDOG_EXIT;
    if(!nodeamon) {
        struct task_struct *p_dog = task_hidog_deamon;
        if(p_dog == NULL)
            return;
        wake_up_process(p_dog);
        kthread_stop(p_dog);
        yield();
    }
    
    task_hidog_deamon = NULL;
}

static void __exit watchdog_exit(void)
{    
    misc_deregister(&hidog_miscdev);
    unregister_reboot_notifier(&hidog_notifier);

    hidog_exit();
    iounmap(reg_ctl_base_va);
    iounmap(reg_wdt_base_va);
}

module_init(watchdog_init);
module_exit(watchdog_exit);

MODULE_AUTHOR("Liu Jiandong");
MODULE_DESCRIPTION("Hisilicon Watchdog Device Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
MODULE_VERSION("HI_VERSION=" OSDRV_MODULE_VERSION_STRING);


 

ToPDCA
关注
hisi-wdt.rar_3520_hi3515_wdt.c_hisi_海思_海思3515芯片
09-24
海思DVR芯片(hi3512/3515/3520等)的wdt驱动
基于S3C2440的嵌入式Linux驱动——看门狗（watchdog）驱动解读
嵌入式Linux
01-01 5100
本文将介绍看门狗驱动的实现。 目标平台：TQ2440 CPU：s3c2440 内核版本：2.6.30 1. 看门狗概述    看门狗其实就是一个定时器，当该定时器溢出前必须对看门狗进行"喂狗“，如果不这样做，定时器溢出后则将复位CPU。    因此，看门狗通常用于对处于异常状态的CPU进行复位。    具体的概念请自行百度。 2. S3C2440看门狗    s
mini2440看门狗驱动
ap105638的专栏
10-03 1137
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #inc
海思外部看门狗驱动
六月初曲的博客
05-19 2859
海思外部看门狗驱动 设计概要     本章主要使用海思HI3518C平台芯片，芯片内置看门狗，这里我们没用到内部狗，我们使用的是外部看门口，为的是预防硬件板导致MCU主芯片程序跑偏，所以需要在外部加一个看门狗芯片，定时喂狗。     看门狗芯片是在机器上电就开始工作，属于逻辑芯片，我们需要在机器上电就进行喂狗，所以这里需要在uboot和kernel中实现喂狗程序，等进入文件系统时再移交给
(uvm验证学习1) apb watchdog 标准阅读和测试点记录
fenggang2333的博客
11-03 1791
apb watchdog本身是基于一个递减的计数器，计数器的初始值是从WDOGLOAD寄存器读取的。在一些条件满足时，当计数器的值递减到0，输出接口的WDOGINT会拉高。图中只记录了WDOGINT和WDOGRES被拉高的两次计数器递减到０的过程，需要注意的是这两个信号能够被拉高的前提是对应的enable位被设置。当wdog发现interrupt信号已经拉高后，若是内置的计数器又一次递减到0，会拉高WDOGRES信号，随后。
PIC单片机C语言教程
06-01
描述中提到的“Hitech-PICC编译器的挂接和程序举例”说明本文将介绍如何在PIC单片机项目中集成Hitech公司的PICC编译器，并通过实际代码示例讲解C语言编程的应用。Hitech-PICC是Hitech公司为PIC单片机开发的一套C...
XMEGA-D_Manual.pdf
12-19
7. **看门狗定时器 (WDT)**：用于监控系统运行状态，在检测到异常时可以自动复位微控制器。 8. **中断与可编程多级中断控制器**：支持多层次中断处理机制，提高了系统的实时性和响应速度。 9. **I/O端口 (PORT)**：...
【海思篇】【Hi3516DV300】十五、看门狗（watchdog）
cocoron的博客
05-05 3019
从寄存器、驱动、应用全方面介绍（海思）看门狗
【笔记】hi3518e_liteOS_看门狗
棒棒糖半糖的博客
03-26 438
我的博客：https://blog.csdn.net/qq_37388044 我的知乎：https://www.zhihu.com/people/bbtganmin 联系方式：知乎私信 转载或者引用本文内容请注明来源及原作者！ 目录前言一、原理二、代码头文件c文件 前言    一、原理 WatchDog 的运行基于 1 个 32bit 减法计数器，计数初值由寄存器 WDG_LOAD 载入。 在 WatchDog 时钟使能情况下，计数值在每个计数时钟的上升沿减 1。当计数值递减到 0，WatchDo.
NUC970系列资料之WDT问题及解决办法
物联网小匠的博客
01-03 3055
NUC970系列资料之WDT问题及解决办法 1 WDT问题介绍 NUC970的必须要通过硬件Power on setting来开启，且开启后无法通过软件来关闭和打开。这样使用起来很不方便。很多客户希望可以在linux下通过软件来控制wdt。 WDT的硬件开关是由PWRON[3]位来控制的，它对应的GPIO是PA.3. 如果要关闭WDT，则需在系统上电...
海思Hi3520DV400 uboot看门狗喂狗
Biao
01-07 2444
看门狗的功能这里不再介绍，自行百度谷歌搜索。这里记录一下Hi3520DV400看门狗的喂狗设置。首先查 include/watchdog.h中的代码，可以发现，如果需要启用硬看门狗，需要定义宏：CONFIG_HW_WATCHDOG /* * Hardware watchdog */ #ifdef CONFIG_HW_WATCHDOG #if defined(__ASSEMBLY_...............
转： Linux spinlock_t
weixin_30877181的博客
08-12 570
我的经验：如果出现死锁的情况，检查：1. lock 和 unlock是否成对出现了，检查所有的程序分支。2.是否有同时需要2个和2个以上的锁的情况，避免掉这种情况。3.如果在timer等软中断中出现死锁，可能是没有使用spin_lock_bh这一类的锁。reference: http://www.chinaitpower.com/2005September/2005-09-13/200...
内核标准wdt统一driver层分析
leo的博客
02-16 2005
标签（空格分隔）： linux子系统 wdt http://blog.chinaunix.net/uid-14753126-id-2984303.html path : /driver/watchdog_dev.c wdt的驱动挺特别的，linux内核中也对它做了一个封装并归纳处理总结出了一个框架，分为以下三层： 统一driver层（watchdog_dev）,核心层（watchdog...
青风和大家一起学Stellaris系列ARM——五.看门狗的使用
Amao_come_on 的专栏
09-25 1023
在实际的MCU应用系统中，由于常常会受到来自外界的某些干扰，有可能（对规范的设计概率极小）造成程序的跑飞而陷入死循环，从而导致整个系统的陷入停滞状态并且不会自动恢复到可控的工作状态。所以出于对MCU运行的安全考虑，便引入了一种专门的复位监控电路，俗称看门狗（WatchDog）。看门狗电路所起的作用是一旦MCU运行出现故障，就强制对MCU进行硬件复位，使整个系统重新处于可控状态（要想精确恢复到故障之
嵌入式 hi3518c默认看门狗没有开启，uboot汇编start.s解析
skdkjxy的专栏
04-20 2338
/*====================================Hi3518c start.S Begin 2014-04-20=============================================*/ /*  *  armboot - Startup Code for ARM926EJS CPU-core  *  *  Copyright (c) 2003
Linux嵌入式：S3C2440看门狗驱动详解
"本文介绍了Linux嵌入式系统中看门狗驱动的开发，主要关注S3C2440芯片上的看门狗功能及其工作原理。看门狗的主要作用是通过定时器实现系统的自动复位，当程序运行正常时，定时器会被定期重置，而程序异常时则可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值