ok6410 开门狗 程序

#include<linux/module.h>
#include<linux/init.h>
#include<linux/kernel.h>
#include<linux/errno.h>
#include<linux/types.h>
#include<linux/fs.h>
#include<linux/version.h>
#include<linux/vmalloc.h>
#include<linux/pagemap.h>
#include<linux/delay.h>
#include<linux/ctype.h>
#include<linux/fcntl.h>
#include<linux/cdev.h>
#include<linux/slab.h>


#include<asm/io.h>
#include<asm/irq.h>
#include<asm/signal.h>
#include<asm/uaccess.h>


#define simple_MAJOR 224
#define simple_MINOR 0


#define WDIOC_KEEPALIVE 1
#define WDIOC_SETTIMEOUT 2


#define S3C64XX_PA_WDC (0x7E004000)
#define S3C64XX_WDCON 0
#define S3C64XX_WDDAT 4
#define S3C64XX_WDCNT 8
#define S3C64XX_WDLRINT 12


#define WDC_RESET_ENABLE (1<<0)
#define WDC_INTERRUPT_ENABLE (1<<2)
#define WDC_TIMER_ENABLE (1<<5)




struct simple_dev
{
struct cdev cdev;
};


static void __iomem *s3c_wdc_base;//指针是指向一个I/O的内存空间
struct simple_dev *simple_devices;
static unsigned char simple_inc = 0;
static int wdctimeout = 0;


int simple_open(struct inode *inode , struct file *filp)
{
int tmp;
struct simple_dev *dev;
if(simple_inc > 0)
{
return -ERESTARTSYS;
}
simple_inc++;


dev = container_of(inode->i_cdev , struct simple_dev , cdev);
filp->private_data = dev;


tmp = ((0x67<<8)|(0x1<<4))|WDC_RESET_ENABLE|WDC_TIMER_ENABLE;//?????????
wdctimeout = 0xffff;//????????
writel(wdctimeout , s3c_wdc_base + S3C64XX_WDCNT);
writel(tmp , s3c_wdc_base + S3C64XX_WDCON);
printk("S3C64XX_WDCON 0X%x\n" , readl(s3c_wdc_base + S3C64XX_WDCON));

return 0;
}


int simple_release(struct inode *inode , struct file *filp)
{
simple_inc--;

return 0;
}


long simple_ioctl(struct file *filp , unsigned int cmd , unsigned long arg)
{
void __user *argp = (void __user*)arg;
int __user *p = argp;


if(cmd == WDIOC_KEEPALIVE)
{
printk("S3C64XX_WDDAT 0x%x\n" , readl(s3c_wdc_base + S3C64XX_WDDAT));
printk("S3C64XX_WDCON 0x%x\n" , readl(s3c_wdc_base + S3C64XX_WDCON));
writel(wdctimeout , s3c_wdc_base + S3C64XX_WDCNT);
printk("S3C64XX_WDCNT 0x%x\n" , S3C64XX_WDCNT);
}
if(cmd == WDIOC_SETTIMEOUT)
{
wdctimeout = (*p)*100000;
printk("wdctimeout %d\n" , wdctimeout);
writel(wdctimeout , s3c_wdc_base + S3C64XX_WDCNT);
}
return -EFAULT;
}


struct file_operations simple_fops = {
.owner = THIS_MODULE,
.open = simple_open,
.release = simple_release,
.unlocked_ioctl = simple_ioctl,
};


void simple_cleanup_module(void)
{
dev_t devno = MKDEV(simple_MAJOR , simple_MINOR);
if(simple_devices)
{
cdev_del(&simple_devices->cdev);
kfree(simple_devices);
}
unregister_chrdev_region(devno , 1);
}


int simple_init_module(void)
{
int result;
dev_t dev = MKDEV(simple_MAJOR , simple_MINOR);
result = register_chrdev_region(dev , 1 , "DEMO");
if(result < 0)
{
printk(KERN_WARNING"simple:can't get major %d\n",simple_MAJOR);
return result;
}
simple_devices = kmalloc(sizeof(struct simple_dev) , GFP_KERNEL);
if(!simple_devices)
{
result = -ENOMEM;
goto fail;
}
memset(simple_devices , 0 ,sizeof(struct simple_dev));
cdev_init(&simple_devices->cdev , &simple_fops);
simple_devices->cdev.owner = THIS_MODULE;
simple_devices->cdev.ops = &simple_fops;
result = cdev_add(&simple_devices->cdev , dev , 1);
if(result)
{
printk(KERN_WARNING"Error %d adding error\n",result);
goto fail;
}
s3c_wdc_base = ioremap(S3C64XX_PA_WDC , 0xff); //???????????????
if(s3c_wdc_base == NULL)
{
printk(KERN_NOTICE"ioremap error\n");
result = -EINVAL;
goto fail;
}
printk("simple_init_module\n");


return 0;
fail:
simple_cleanup_module();
return result;
}


module_init(simple_init_module);
module_exit(simple_cleanup_module);

MODULE_LICENSE("Dual BSD/GPL");

应用程序：

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<linux/watchdog.h>


#define KEEPALIVE 1
#define SETTIMEOUT 2




int main(void)
{
int fd;
fd = open("/dev/wnb",O_WRONLY);
if(fd == -1)
{
perror("error open\n");
exit(1);
}
int timeout = 4;
ioctl(fd , SETTIMEOUT , &timeout);

while(1)
{
ioctl(fd , KEEPALIVE , 0);
sleep(1);
}
close(fd);
return 0;
}