hsist
/
freifunkist-firmware
6
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

added improved watchdog driver for amazon

Browse Source 
SVN-Revision: 8346
master
John Crispin 17 years ago
parent b829716e6d
commit 9474a045bf
3 changed files with 256 additions and 261 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 261
      target/linux/amazon-2.6/files/drivers/char/amazon_wdt.c
  2. 246
      target/linux/amazon-2.6/files/drivers/char/watchdog/amazon_wdt.c
  3. 10
      target/linux/amazon-2.6/patches/017-wdt-driver.patch

261
target/linux/amazon-2.6/files/drivers/char/amazon_wdt.c
Unescape View File

@ -1,261 +0,0 @@
/*
* Infineon AP DC COM Amazon WDT driver
* Copyright 2004 Wu Qi Ming <gokimi@msn.com>
* All rights reserved
*/
#if defined(MODVERSIONS)
#include <linux/modversions.h>
#endif
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/tty.h>
#include <linux/selection.h>
#include <linux/kmod.h>
#include <linux/vmalloc.h>
#include <linux/kdev_t.h>
#include <linux/ioctl.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/amazon/amazon.h>
#include <asm/amazon/amazon_wdt.h>
#define AMAZON_WDT_EMSG(fmt, args...) printk( "%s: " fmt, __FUNCTION__ , ##args)
extern unsigned int amazon_get_fpi_hz(void);
/* forward declarations for _fops */
static ssize_t wdt_read(struct file *file, char *buf, size_t count, loff_t *offset);
static ssize_t wdt_write(struct file *file, const char *buf, size_t count, loff_t *offset);
static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
static int wdt_open(struct inode *inode, struct file *file);
static int wdt_release(struct inode *inode, struct file *file);
static int wdt_proc_read(char *buf, char **start, off_t offset,int count, int *eof, void *data);
static struct file_operations wdt_fops = {
read:wdt_read,
write:wdt_write,
ioctl:wdt_ioctl,
open:wdt_open,
release:wdt_release,
};
/* data */
static struct wdt_dev *amazon_wdt_dev;
static struct proc_dir_entry* amazon_wdt_dir;
static int occupied=0;
/* Brief: enable WDT
* Parameter:
timeout: time interval for WDT
* Return:
0 OK
EINVAL
* Describes:
1. Password Access
2. Modify Access (change ENDINIT => 0)
3. Change WDT_CON1 (enable WDT)
4. Password Access again
5. Modify Access (change ENDINIT => 1)
*/
int wdt_enable(int timeout)
{
u32 hard_psw,ffpi;
int reload_value, divider=0;
ffpi = amazon_get_fpi_hz();
divider = 1;
if((reload_value=65536-timeout*ffpi/256)<0){
divider = 0;
reload_value=65536-timeout*ffpi/16384;
}
if (reload_value < 0){
AMAZON_WDT_EMSG("timeout too large %d\n", timeout);
return -EINVAL;
}
AMAZON_WDT_EMSG("timeout:%d reload_value: %8x\n", timeout, reload_value);
hard_psw=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff01)+(AMAZON_WDT_REG32(AMAZON_WDT_CON1)&0xc)+ 0xf0;
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=hard_psw;
wmb();
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=(hard_psw&0xff00)+(reload_value<<16)+0xf2;
wmb();
AMAZON_WDT_REG32(AMAZON_WDT_CON1)=divider<<2;
wmb();
hard_psw=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff01)+(AMAZON_WDT_REG32(AMAZON_WDT_CON1)&0xc)+ 0xf0;
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=hard_psw;
wmb();
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff00)+0xf3;
wmb();
return 0;
}
/* Brief: Disable/stop WDT
*/
void wdt_disable(void)
{
u32 hard_psw=0;
hard_psw=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff01)+(AMAZON_WDT_REG32(AMAZON_WDT_CON1)&0xc)+ 0xf0;
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=hard_psw;
wmb();
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff00)+0xf2;
wmb();
AMAZON_WDT_REG32(AMAZON_WDT_CON1)|=8;
wmb();
hard_psw=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff01)+(AMAZON_WDT_REG32(AMAZON_WDT_CON1)&0xc)+ 0xf0;
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=hard_psw;
wmb();
AMAZON_WDT_REG32(AMAZON_WDT_CON0)=(AMAZON_WDT_REG32(AMAZON_WDT_CON0)&0xffffff00)+0xf3;
wmb();
return;
}
static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
int result=0;
static int timeout=-1;
switch(cmd){
case AMAZON_WDT_IOC_START:
AMAZON_WDT_DMSG("enable watch dog timer!\n");
if ( copy_from_user((void*)&timeout, (void*)arg, sizeof (int)) ){
AMAZON_WDT_EMSG("invalid argument\n");
result=-EINVAL;
}else{
if ((result = wdt_enable(timeout)) < 0){
timeout = -1;
}
}
break;
case AMAZON_WDT_IOC_STOP:
AMAZON_WDT_DMSG("disable watch dog timer\n");
timeout = -1;
wdt_disable();
break;
case AMAZON_WDT_IOC_PING:
if (timeout <0 ){
result = -EIO;
}else{
result = wdt_enable(timeout);
}
}
return result;
}
static ssize_t wdt_read(struct file *file, char *buf, size_t count, loff_t *offset)
{
return 0;
}
static ssize_t wdt_write(struct file *file, const char *buf, size_t count, loff_t *offset)
{
return count;
}
static int wdt_open(struct inode *inode, struct file *file)
{
AMAZON_WDT_DMSG("wdt_open\n");
if (occupied == 1) return -EBUSY;
occupied = 1;
return 0;
}
static int wdt_release(struct inode *inode, struct file *file)
{
AMAZON_WDT_DMSG("wdt_release\n");
occupied = 0;
return 0;
}
int wdt_register_proc_read(char *buf, char **start, off_t offset,
int count, int *eof, void *data)
{
int len=0;
printk("wdt_registers:\n");
len+=sprintf(buf+len,"NMISR: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_NMISR));
len+=sprintf(buf+len,"RST_REQ: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_RST_REQ));
len+=sprintf(buf+len,"RST_SR: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_RST_SR));
len+=sprintf(buf+len,"WDT_CON0: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_CON0));
len+=sprintf(buf+len,"WDT_CON1: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_CON1));
len+=sprintf(buf+len,"WDT_SR: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_SR));
*eof = 1;
return len;
}
int __init amazon_wdt_init_module(void)
{
int result=0;
amazon_wdt_dev = (wdt_dev*)kmalloc(sizeof(wdt_dev),GFP_KERNEL);
if (amazon_wdt_dev == NULL){
return -ENOMEM;
}
memset(amazon_wdt_dev,0,sizeof(wdt_dev));
amazon_wdt_dev->major=result;
strcpy(amazon_wdt_dev->name,"wdt");
result = register_chrdev(0,amazon_wdt_dev->name,&wdt_fops);
if (result < 0) {
AMAZON_WDT_EMSG("cannot register device\n");
kfree(amazon_wdt_dev);
return result;
}
amazon_wdt_dir=proc_mkdir("amazon_wdt",NULL);
create_proc_read_entry("wdt_register",
0,
amazon_wdt_dir,
wdt_register_proc_read,
NULL);
occupied=0;
return 0;
}
void amazon_wdt_cleanup_module(void)
{
unregister_chrdev(amazon_wdt_dev->major,amazon_wdt_dev->name);
kfree(amazon_wdt_dev);
remove_proc_entry("wdt_register",amazon_wdt_dir);
remove_proc_entry("amazon_wdt",NULL);
AMAZON_WDT_DMSG("unloaded\n");
return;
}
MODULE_LICENSE ("GPL");
MODULE_AUTHOR("Infineon IFAP DC COM");
MODULE_DESCRIPTION("AMAZON WDT driver");
module_init(amazon_wdt_init_module);
module_exit(amazon_wdt_cleanup_module);

246
target/linux/amazon-2.6/files/drivers/char/watchdog/amazon_wdt.c
Unescape View File

@ -0,0 +1,246 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright 2004 Wu Qi Ming <gokimi@msn.com>
* Copyright (C) 2007 John Crispin <blogic@openwrt.org>
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/tty.h>
#include <linux/selection.h>
#include <linux/kmod.h>
#include <linux/vmalloc.h>
#include <linux/kdev_t.h>
#include <linux/ioctl.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/amazon/amazon.h>
#include <asm/amazon/amazon_wdt.h>
#define DRV_NAME "AMAZON WDT:"
#undef AMAZON_WDT_DEBUG
extern unsigned int amazon_get_fpi_hz(void);
static int amazon_wdt_isopen = 0;
#ifdef AMAZON_WDT_DEBUG
static struct proc_dir_entry* amazon_wdt_dir;
#endif
int wdt_enable(int timeout)
{
u32 hard_psw, ffpi;
int reload_value, divider = 1;
ffpi = amazon_get_fpi_hz();
reload_value = 65536 - timeout * ffpi / 256;
if (reload_value < 0) {
divider = 0;
reload_value = 65536 - timeout * ffpi / 16384;
}
if (reload_value < 0){
printk(KERN_INFO DRV_NAME "timeout too large %d\n", timeout);
return -EINVAL;
}
printk(KERN_INFO DRV_NAME "timeout:%d reload_value: %8x\n", timeout, reload_value);
hard_psw = (amazon_readl(AMAZON_WDT_CON0) & 0xffffff01) +
(amazon_readl(AMAZON_WDT_CON1) & 0xc) + 0xf0;
amazon_writel(hard_psw, AMAZON_WDT_CON0);
wmb();
amazon_writel((hard_psw & 0xff00) + (reload_value << 16) + 0xf2, AMAZON_WDT_CON0);
wmb();
amazon_writel(divider << 2, AMAZON_WDT_CON1);
wmb();
hard_psw = (amazon_readl(AMAZON_WDT_CON0) & 0xffffff01) +
(amazon_readl(AMAZON_WDT_CON1) & 0xc) + 0xf0;
amazon_writel(hard_psw, AMAZON_WDT_CON0);
wmb();
amazon_writel_masked(AMAZON_WDT_CON0, 0xff, 0xf3);
wmb();
return 0;
}
void wdt_disable(void)
{
u32 hard_psw = 0;
hard_psw = (amazon_readl(AMAZON_WDT_CON0) & 0xffffff01) +
(amazon_readl(AMAZON_WDT_CON1) & 0xc) + 0xf0;
amazon_writel(hard_psw, AMAZON_WDT_CON0);
wmb();
amazon_writel_masked(AMAZON_WDT_CON0, 0xff, 0xf2);
wmb();
amazon_writel_masked(AMAZON_WDT_CON1, 0x8, 0x8);
wmb();
hard_psw=(amazon_readl(AMAZON_WDT_CON0) & 0xffffff01) +
(amazon_readl(AMAZON_WDT_CON1) & 0xc) + 0xf0;
amazon_writel(hard_psw, AMAZON_WDT_CON0);
wmb();
amazon_writel_masked(AMAZON_WDT_CON0, 0xff, 0xf3);
wmb();
return;
}
static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
int result=0;
static int timeout=-1;
switch(cmd){
case AMAZON_WDT_IOC_START:
printk(KERN_INFO DRV_NAME "enable watch dog timer!\n");
if (copy_from_user((void*)&timeout, (void*)arg, sizeof (int))) {
printk(KERN_INFO DRV_NAME "invalid argument\n");
result=-EINVAL;
} else if ((result = wdt_enable(timeout)) < 0) {
timeout = -1;
}
break;
case AMAZON_WDT_IOC_STOP:
printk(KERN_INFO DRV_NAME "disable watch dog timer\n");
timeout = -1;
wdt_disable();
break;
case AMAZON_WDT_IOC_PING:
if (timeout < 0) {
result = -EIO;
} else {
result = wdt_enable(timeout);
}
break;
default:
result=-EINVAL;
break;
}
return result;
}
static ssize_t wdt_read(struct file *file, char *buf, size_t count, loff_t *offset)
{
return 0;
}
static ssize_t wdt_write(struct file *file, const char *buf, size_t count, loff_t *offset)
{
return count;
}
static int wdt_open(struct inode *inode, struct file *file)
{
if (amazon_wdt_isopen == 1)
return -EBUSY;
amazon_wdt_isopen = 1;
printk(KERN_INFO DRV_NAME "opened\n");
return 0;
}
static int wdt_release(struct inode *inode, struct file *file)
{
amazon_wdt_isopen = 0;
printk(KERN_INFO DRV_NAME "closed\n");
return 0;
}
#ifdef AMAZON_WDT_DEBUG
int wdt_register_proc_read(char *buf, char **start, off_t offset,
int count, int *eof, void *data)
{
int len=0;
len+=sprintf(buf+len,"NMISR: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_NMISR));
len+=sprintf(buf+len,"RST_REQ: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_RST_REQ));
len+=sprintf(buf+len,"RST_SR: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_RST_SR));
len+=sprintf(buf+len,"WDT_CON0: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_CON0));
len+=sprintf(buf+len,"WDT_CON1: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_CON1));
len+=sprintf(buf+len,"WDT_SR: 0x%08x\n",AMAZON_WDT_REG32(AMAZON_WDT_SR));
*eof = 1;
return len;
}
#endif
static struct file_operations wdt_fops = {
read: wdt_read,
write: wdt_write,
ioctl: wdt_ioctl,
open: wdt_open,
release: wdt_release,
};
int __init amazon_wdt_init_module(void)
{
int result = result = register_chrdev(0, "watchdog", &wdt_fops);
if (result < 0) {
printk(KERN_INFO DRV_NAME "cannot register device\n");
return result;
}
#ifdef AMAZON_WDT_DEBUG
amazon_wdt_dir=proc_mkdir("amazon_wdt",NULL);
create_proc_read_entry("wdt_register", 0, amazon_wdt_dir,
wdt_register_proc_read, NULL);
#endif
amazon_wdt_isopen=0;
printk(KERN_INFO DRV_NAME "driver loaded but inactive");
return 0;
}
void amazon_wdt_cleanup_module(void)
{
unregister_chrdev(0, "watchdog");
#ifdef AMAZON_WDT_DEBUG
remove_proc_entry("wdt_register", amazon_wdt_dir);
remove_proc_entry("amazon_wdt", NULL);
#endif
printk(KERN_INFO DRV_NAME "unregistered");
return;
}
MODULE_LICENSE ("GPL");
MODULE_AUTHOR("Infineon / John Crispin <blogic@openwrt.org>");
MODULE_DESCRIPTION("AMAZON WDT driver");
module_init(amazon_wdt_init_module);
module_exit(amazon_wdt_cleanup_module);

10
target/linux/amazon-2.6/patches/017-wdt-driver.patch
Unescape View File

@ -0,0 +1,10 @@
--- linux-2.6.21.5/drivers/char/watchdog/Makefile.orig 2007-08-05 11:13:29.177013987 +0200
+++ linux-2.6.21.5/drivers/char/watchdog/Makefile 2007-08-05 11:13:52.190325445 +0200
@@ -74,6 +74,7 @@
# MIPS Architecture
obj-$(CONFIG_INDYDOG) += indydog.o
obj-$(CONFIG_WDT_RM9K_GPI) += rm9k_wdt.o
+obj-$(CONFIG_AMAZON_WDT) += amazon_wdt.o
# S390 Architecture
Write Preview
Loading…
Cancel
Save