w83793 watchdog support.
Subsystems (2)
PATCH 1/1 w83793 watchdog support.
Hello!
I implemented watchdog support for the Winbond 83793 chipset. I'll attached the patch.
Any comments welcome!
Regards
Sven Anders
Signature · 9 lines
Sven Anders <[email protected]> () Ascii Ribbon Campaign /\ Support plain text e-mail ANDURAS service solutions AG Innstrasse 71 - 94036 Passau - Germany Web: www.anduras.de - Tel: +49 (0)851-4 90 50-0 - Fax: +49 (0)851-4 90 50-55 Those who would give up essential Liberty, to purchase a little temporary Safety, deserve neither Liberty nor Safety. - Benjamin Franklin
This patch add watchdog functionality to the Winbond 83793 chipset driver.
drivers/hwmon/w83793.c +481 -3
@@ -3,6 +3,10 @@ Copyright (C) 2006 Winbond Electronics Corp. Yuan Mu Rudolf Marek <[email protected]> + Copyright (C) 2009 Sven Anders <[email protected]>, ANDURAS AG. + Watchdog driver part + (Based partially on fschmd driver, + Copyright 2007-2008 by Hans de Goede) 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
@@ -35,10 +39,20 @@#include <linux/hwmon-sysfs.h> #include <linux/err.h> #include <linux/mutex.h> +#include <linux/fs.h> +#include <linux/watchdog.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/kref.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +/* Default values */ +#define WATCHDOG_TIMEOUT 1/* 1 minute default timeout */ /* Addresses to scan */ static const unsigned short normal_i2c[] = {0x2c ,0x2d ,0x2e ,0x2f , -I2C_CLIENT_END }; +I2C_CLIENT_END };/* Insmod parameters */ I2C_CLIENT_INSMOD_1 (w83793);
@@ -52,6 +66,18 @@ static int reset;module_param (reset, bool,0 );MODULE_PARM_DESC (reset,"Set to 1 to reset chip, not recommended" ); +static int timeout =WATCHDOG_TIMEOUT ;/* in minutes */ +module_param (timeout, int,0 ); +MODULE_PARM_DESC (timeout, + "Watchdog timeout in minutes. 1<= timeout <=255 (default=" + __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); + +static int nowayout =WATCHDOG_NOWAYOUT ; +module_param (nowayout, int,0 ); +MODULE_PARM_DESC (nowayout, + "Watchdog cannot be stopped once started (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); +/* Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved as ID, Bank Select registers
@@ -73,6 +99,11 @@ MODULE_PARM_DESC(reset, "Set to 1 to res#define W83793_REG_VID_LATCHB 0x08#define W83793_REG_VID_CTRL 0x59 +#define W83793_REG_WDT_LOCK 0x01 +#define W83793_REG_WDT_ENABLE 0x02 +#define W83793_REG_WDT_STATUS 0x03 +#define W83793_REG_WDT_TIMEOUT 0x04 +static u16 W83793_REG_TEMP_MODE [2 ] = {0x5e ,0x5f };#define TEMP_READ 0
@@ -224,8 +255,36 @@ struct w83793_data {u8 tolerance[3 ];/* Temp tolerance(Smart Fan I/II) */ u8 sf2_pwm[6 ][7 ];/* Smart FanII: Fan duty cycle */ u8 sf2_temp[6 ][7 ];/* Smart FanII: Temp level point */ + +/* watchdog */ +struct i2c_client *client; +struct mutex watchdog_lock; +struct list_head list;/* member of the watchdog_data_list */ +struct kref kref; +struct miscdevice watchdog_miscdev; +unsigned long watchdog_is_open; +char watchdog_expect_close; +char watchdog_name[10 ];/* must be unique to avoid sysfs conflict */ +unsigned int watchdog_caused_reboot; }; +/* Somewhat ugly :( global data pointer list with all devices, so that +we can find our device data as when using misc_register. There is no +other method to get to one's device data from the open file-op and +for usage in the reboot notifier callback. */ +static LIST_HEAD (watchdog_data_list); + +/* Note this lock not only protect list access, but also data.kref access */ +static DEFINE_MUTEX (watchdog_data_mutex); + +/* Release our data struct when we're detached from the i2c client *and* all +references to our watchdog device are released */ +static void w83793_release_resources (struct kref *ref) +{ + struct w83793_data *data = container_of(ref, struct w83793_data, kref); +kfree (data); +} +static u8 w83793_read_value (struct i2c_client *client,u16 reg);static int w83793_write_value (struct i2c_client *client,u16 reg,u8 value); static int w83793_probe(struct i2c_client *client,
@@ -1064,14 +1123,348 @@ static void w83793_init_client(struct i2/* Start monitoring */ w83793_write_value (client,W83793_REG_CONFIG ,w83793_read_value (client,W83793_REG_CONFIG ) |0x01 ); +} + +/* +* Watchdog routines +*/ + +static int watchdog_set_timeout (struct w83793_data *data,int timeout) +{ +int ret, stimeout; + +if (timeout >255 ) +return -EINVAL ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +printk (KERN_ERR "Set Timeout to %u seconds\n" , timeout); + + stimeout =DIV_ROUND_UP (timeout,60 ); + +/* Set Timeout value (in Minutes) */ +printk (KERN_ERR "Set Timeout to %u minutes\n" , stimeout); +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , stimeout); + + ret = stimeout; + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_get_timeout (struct w83793_data *data) +{ +int gtimeout; + +mutex_lock (&data->watchdog_lock); +if (!data->client) +return -ENODEV ; + +/* Get Timeout value (in Minutes) */ + gtimeout =w83793_read_value (data->client,W83793_REG_WDT_TIMEOUT ) *60 ; +printk (KERN_ERR "Get Timeout: %u seconds\n" , gtimeout); + +mutex_unlock (&data->watchdog_lock); + +return gtimeout; +} + +static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +printk (KERN_ERR "Reset Timeout to %u seconds\n" , timeout*60 ); + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_enable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set initial timeout */ +printk (KERN_ERR "Set timeout: %u\n" , timeout); +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +/* Enable Soft Watchdog */ +printk (KERN_ERR "ENABLE Watchdog: 0x55\n" ); +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0x55 ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_disable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Disable Soft Watchdog */ +printk (KERN_ERR "DISABLE Watchdog: 0xAA\n" ); +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0xAA ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_open (struct inode *inode,struct file *filp) +{ +struct w83793_data *pos, *data =NULL ; + +/* We get called from drivers/char/misc.c with misc_mtx hold, and we +call misc_register() from fschmd_probe() with watchdog_data_mutex +hold, as misc_register() takes the misc_mtx lock, this is a possible +deadlock, so we use mutex_trylock here. */ +if (!mutex_trylock (&watchdog_data_mutex)) +return -ERESTARTSYS ; +list_for_each_entry (pos, &watchdog_data_list, list) { +if (pos->watchdog_miscdev.minor ==iminor (inode)) { + data = pos; +break ; + } + } + +/* Note we can never not have found data, so we don't check for this */ +kref_get (&data->kref); +mutex_unlock (&watchdog_data_mutex); + +if (test_and_set_bit (0 , &data->watchdog_is_open)) +return -EBUSY ; + +/* Enable Soft Watchdog */ +watchdog_enable (data); + +/* Store pointer to data into filp's private data */ + filp->private_data = data; +return nonseekable_open (inode, filp); } +static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 , &data->watchdog_is_open); + +return 0 ; +} + +static ssize_t watchdog_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offset) +{ +size_t ret; +struct w83793_data *data = filp->private_data; + +if (count) { +if (!nowayout) { +size_t i; + +/* Clear it in case it was set with a previous write */ + data->watchdog_expect_close =0 ; + +for (i =0 ; i != count; i++) { +char c; +if (get_user (c, buf + i)) +return -EFAULT ; +if (c =='V' ) + data->watchdog_expect_close =1 ; + } + } + ret =watchdog_trigger (data); +if (ret <0 ) +return ret; + } +return count; +} + +static int watchdog_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +static struct watchdog_info ident = { + .options =WDIOF_KEEPALIVEPING | +WDIOF_SETTIMEOUT | +WDIOF_CARDRESET , + .identity ="w83793 watchdog" + }; + +int val, ret =0 ; +struct w83793_data *data = filp->private_data; + +switch (cmd) { +case WDIOC_GETSUPPORT : +if (!nowayout) + ident.options |=WDIOF_MAGICCLOSE ; +if (copy_to_user ((void __user *)arg, &ident,sizeof (ident))) + ret = -EFAULT ; +break ; + +case WDIOC_GETSTATUS : + val = data->watchdog_caused_reboot ?WDIOF_CARDRESET :0 ; + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_GETBOOTSTATUS : + ret =put_user (0 , (int __user *)arg); +break ; + +case WDIOC_KEEPALIVE : + ret =watchdog_trigger (data); +break ; + +case WDIOC_GETTIMEOUT : + val =watchdog_get_timeout (data); + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_SETTIMEOUT : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + ret =watchdog_set_timeout (data, val); +if (ret >0 ) + ret =put_user (ret, (int __user *)arg); +break ; + +case WDIOC_SETOPTIONS : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + +if (val &WDIOS_DISABLECARD ) + ret =watchdog_disable (data); +else if (val &WDIOS_ENABLECARD ) + ret =watchdog_enable (data); +else + ret = -EINVAL ; + +break ; +default : + ret = -ENOTTY ; + } + +return ret; +} + +static const struct file_operations watchdog_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .open = watchdog_open, + .release = watchdog_close, + .write = watchdog_write, + .ioctl = watchdog_ioctl, +}; + +/* +* Notifier for system down +*/ + +static int watchdog_notify_sys (struct notifier_block *this,unsigned long code, +void *unused) +{ +struct w83793_data *data =NULL ; + +if (code ==SYS_DOWN || code ==SYS_HALT ) { + +/* Disable each registered watchdog */ +mutex_lock (&watchdog_data_mutex); +list_for_each_entry (data, &watchdog_data_list, list) { +if (data->watchdog_miscdev.minor) +watchdog_disable (data); + } +mutex_unlock (&watchdog_data_mutex); + } + +return NOTIFY_DONE ; +} + +/* +* The WDT needs to learn about soft shutdowns in order to +* turn the timebomb registers off. +*/ + +static struct notifier_block watchdog_notifier = { + .notifier_call = watchdog_notify_sys, +}; + +/* +* Init / remove routines +*/ +static int w83793_remove (struct i2c_client *client) {struct w83793_data *data =i2c_get_clientdata (client);struct device *dev = &client->dev; -int i; +int i, tmp; + +printk (KERN_ERR "** in w83793_remove()\n" ); + +/* Unregister the watchdog (if registered) */ +if (data->watchdog_miscdev.minor) { +misc_deregister (&data->watchdog_miscdev); + +if (data->watchdog_is_open) { +dev_warn (&client->dev, +"i2c client detached with watchdog open! " +"Stopping watchdog.\n" ); +watchdog_disable (data); + } + +mutex_lock (&watchdog_data_mutex); +list_del (&data->list); +mutex_unlock (&watchdog_data_mutex); + +/* Tell the watchdog code the client is gone */ +mutex_lock (&data->watchdog_lock); + data->client =NULL ; +mutex_unlock (&data->watchdog_lock); + } + +/* Reset Configuration Register to Disable Watch Dog Registers */ +printk (KERN_ERR "Disable WATCHDOG config registers\n" ); + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp & ~0x04 ); + +unregister_reboot_notifier (&watchdog_notifier);hwmon_device_unregister (data->hwmon_dev);
@@ -1102,6 +1495,10 @@ static int w83793_remove(struct i2c_cliekfree (data); +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex); +return 0 ; }
@@ -1168,6 +1565,8 @@ static int w83793_detect(struct i2c_cliestruct i2c_adapter *adapter = client->adapter;unsigned short address = client->addr; +printk (KERN_ERR "** in w83793_detect()\n" ); +if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA )) {return -ENODEV ; }
@@ -1221,12 +1620,15 @@ static int w83793_probe(struct i2c_clien const struct i2c_device_id *id) {struct device *dev = &client->dev; +const int watchdog_minors[] = {WATCHDOG_MINOR ,212 ,213 ,214 ,215 };struct w83793_data *data;int i, tmp, val, err;int files_fan =ARRAY_SIZE (w83793_left_fan) /7 ;int files_pwm =ARRAY_SIZE (w83793_left_pwm) /5 ;int files_temp =ARRAY_SIZE (w83793_temp) /6 ; +printk (KERN_ERR "** in w83793_probe()\n" ); + data =kzalloc (sizeof (struct w83793_data ),GFP_KERNEL );if (!data) { err = -ENOMEM ;
@@ -1236,6 +1638,14 @@ static int w83793_probe(struct i2c_clieni2c_set_clientdata (client, data); data->bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );mutex_init (&data->update_lock); +mutex_init (&data->watchdog_lock); +INIT_LIST_HEAD (&data->list); +kref_init (&data->kref); + +/* Store client pointer in our data struct for watchdog usage +(where the client is found through a data ptr instead of the +otherway around) */ + data->client = client; err =w83793_detect_subclients (client);if (err)
@@ -1398,8 +1808,76 @@ static int w83793_probe(struct i2c_clien goto exit_remove; } +/* Watchdog initialization */ + +/* Register boot notifier */ + err =register_reboot_notifier (&watchdog_notifier); +if (err !=0 ) { +dev_err (&client->dev, +"cannot register reboot notifier (err=%d)\n" , err); + goto exit_devunreg; + } + +/* Enable Watchdog registers. +Set Configuration Register to Enable Watch Dog Registers +(Bit 2) = XXXX, X1XX. */ +printk (KERN_ERR "ENABLE WatchDog registers\n" ); + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp |0x04 ); + +/* Check, if last reboot was caused by watchdog */ + data->watchdog_caused_reboot = +w83793_read_value (data->client,W83793_REG_WDT_STATUS ) &0x01 ; +printk (KERN_ERR "WatchDog status: %u\n" , data->watchdog_caused_reboot); + +/* Disable Soft Watchdog during initialiation */ +watchdog_disable (data); + +/* We take the data_mutex lock early so that watchdog_open() cannot +run when misc_register() has completed, but we've not yet added +our data to the watchdog_data_list (and set the default timeout) */ +mutex_lock (&watchdog_data_mutex); +for (i =0 ; i <ARRAY_SIZE (watchdog_minors); i++) { +/* Register our watchdog part */ +snprintf (data->watchdog_name,sizeof (data->watchdog_name), +"watchdog%c" , (i ==0 ) ?'\0' : ('0' + i)); + data->watchdog_miscdev.name = data->watchdog_name; + data->watchdog_miscdev.fops = &watchdog_fops; + data->watchdog_miscdev.minor = watchdog_minors[i]; + + err =misc_register (&data->watchdog_miscdev); +if (err == -EBUSY ) +continue ; +if (err) { + data->watchdog_miscdev.minor =0 ; +dev_err (&client->dev, +"Registering watchdog chardev: %d\n" , err); +break ; + } + +list_add (&data->list, &watchdog_data_list); + +dev_info (&client->dev, +"Registered watchdog chardev major 10, minor: %d\n" , + watchdog_minors[i]); +break ; + } +if (i ==ARRAY_SIZE (watchdog_minors)) { + data->watchdog_miscdev.minor =0 ; +dev_warn (&client->dev,"Couldn't register watchdog chardev " +"(due to no free minor)\n" ); + } + +mutex_unlock (&watchdog_data_mutex); +return 0 ; +/* Unregister hwmon device */ + +exit_devunreg: + +hwmon_device_unregister (data->hwmon_dev); +/* Unregister sysfs hooks */ exit_remove:
@@ -1646,7 +2124,7 @@ static void __exit sensors_w83793_exit(vi2c_del_driver (&w83793_driver); } -MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Rudolf Marek, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" );
drivers/hwmon/Kconfig +2 -1
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VID help If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
begin:vcard
fn:Sven Anders
n:Anders;Sven
org:ANDURAS AG;Research and Development adr;quoted-printable:;;Innstra=C3=9Fe 71;Passau;Bavaria;94036;Germany email;internet:[email protected]
title:Dipl. Inf.
tel;work:++49 (0)851 / 490 50 -0
tel;fax:++49 (0)851 / 590 50 - 55
x-mozilla-html:FALSE
url:http://www.anduras.de
version:2.1
end:vcard
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Quoted 6 lines · Sven Anders
Hello!
I implemented watchdog support for the Winbond 83793 chipset. I'll attached the patch.
Any comments welcome!
Ok, sorry.
I forgot to remove the debug output from the first version. Here is the correct one.
Regards
Sven Anders
Signature · 9 lines
Sven Anders <[email protected]> () Ascii Ribbon Campaign /\ Support plain text e-mail ANDURAS service solutions AG Innstrasse 71 - 94036 Passau - Germany Web: www.anduras.de - Tel: +49 (0)851-4 90 50-0 - Fax: +49 (0)851-4 90 50-55 Those who would give up essential Liberty, to purchase a little temporary Safety, deserve neither Liberty nor Safety. - Benjamin Franklin
This patch add watchdog functionality to the Winbond 83793 chipset driver.
drivers/hwmon/w83793.c +463 -3
@@ -3,6 +3,10 @@ Copyright (C) 2006 Winbond Electronics Corp. Yuan Mu Rudolf Marek <[email protected]> + Copyright (C) 2009 Sven Anders <[email protected]>, ANDURAS AG. + Watchdog driver part + (Based partially on fschmd driver, + Copyright 2007-2008 by Hans de Goede) 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
@@ -35,10 +39,20 @@#include <linux/hwmon-sysfs.h> #include <linux/err.h> #include <linux/mutex.h> +#include <linux/fs.h> +#include <linux/watchdog.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/kref.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +/* Default values */ +#define WATCHDOG_TIMEOUT 1/* 1 minute default timeout */ /* Addresses to scan */ static const unsigned short normal_i2c[] = {0x2c ,0x2d ,0x2e ,0x2f , -I2C_CLIENT_END }; +I2C_CLIENT_END };/* Insmod parameters */ I2C_CLIENT_INSMOD_1 (w83793);
@@ -52,6 +66,18 @@ static int reset;module_param (reset, bool,0 );MODULE_PARM_DESC (reset,"Set to 1 to reset chip, not recommended" ); +static int timeout =WATCHDOG_TIMEOUT ;/* in minutes */ +module_param (timeout, int,0 ); +MODULE_PARM_DESC (timeout, + "Watchdog timeout in minutes. 1<= timeout <=255 (default=" + __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); + +static int nowayout =WATCHDOG_NOWAYOUT ; +module_param (nowayout, int,0 ); +MODULE_PARM_DESC (nowayout, + "Watchdog cannot be stopped once started (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); +/* Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved as ID, Bank Select registers
@@ -73,6 +99,11 @@ MODULE_PARM_DESC(reset, "Set to 1 to res#define W83793_REG_VID_LATCHB 0x08#define W83793_REG_VID_CTRL 0x59 +#define W83793_REG_WDT_LOCK 0x01 +#define W83793_REG_WDT_ENABLE 0x02 +#define W83793_REG_WDT_STATUS 0x03 +#define W83793_REG_WDT_TIMEOUT 0x04 +static u16 W83793_REG_TEMP_MODE [2 ] = {0x5e ,0x5f };#define TEMP_READ 0
@@ -224,8 +255,36 @@ struct w83793_data {u8 tolerance[3 ];/* Temp tolerance(Smart Fan I/II) */ u8 sf2_pwm[6 ][7 ];/* Smart FanII: Fan duty cycle */ u8 sf2_temp[6 ][7 ];/* Smart FanII: Temp level point */ + +/* watchdog */ +struct i2c_client *client; +struct mutex watchdog_lock; +struct list_head list;/* member of the watchdog_data_list */ +struct kref kref; +struct miscdevice watchdog_miscdev; +unsigned long watchdog_is_open; +char watchdog_expect_close; +char watchdog_name[10 ];/* must be unique to avoid sysfs conflict */ +unsigned int watchdog_caused_reboot; }; +/* Somewhat ugly :( global data pointer list with all devices, so that +we can find our device data as when using misc_register. There is no +other method to get to one's device data from the open file-op and +for usage in the reboot notifier callback. */ +static LIST_HEAD (watchdog_data_list); + +/* Note this lock not only protect list access, but also data.kref access */ +static DEFINE_MUTEX (watchdog_data_mutex); + +/* Release our data struct when we're detached from the i2c client *and* all +references to our watchdog device are released */ +static void w83793_release_resources (struct kref *ref) +{ + struct w83793_data *data = container_of(ref, struct w83793_data, kref); +kfree (data); +} +static u8 w83793_read_value (struct i2c_client *client,u16 reg);static int w83793_write_value (struct i2c_client *client,u16 reg,u8 value); static int w83793_probe(struct i2c_client *client,
@@ -1064,14 +1123,336 @@ static void w83793_init_client(struct i2/* Start monitoring */ w83793_write_value (client,W83793_REG_CONFIG ,w83793_read_value (client,W83793_REG_CONFIG ) |0x01 ); +} + +/* +* Watchdog routines +*/ + +static int watchdog_set_timeout (struct w83793_data *data,int timeout) +{ +int ret, stimeout; + +if (timeout >255 ) +return -EINVAL ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + + stimeout =DIV_ROUND_UP (timeout,60 ); + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , stimeout); + + ret = stimeout; + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_get_timeout (struct w83793_data *data) +{ +int gtimeout; + +mutex_lock (&data->watchdog_lock); +if (!data->client) +return -ENODEV ; + +/* Get Timeout value (in Minutes) */ + gtimeout =w83793_read_value (data->client,W83793_REG_WDT_TIMEOUT ) *60 ; + +mutex_unlock (&data->watchdog_lock); + +return gtimeout; +} + +static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_enable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set initial timeout */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +/* Enable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0x55 ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_disable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Disable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0xAA ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_open (struct inode *inode,struct file *filp) +{ +struct w83793_data *pos, *data =NULL ; + +/* We get called from drivers/char/misc.c with misc_mtx hold, and we +call misc_register() from fschmd_probe() with watchdog_data_mutex +hold, as misc_register() takes the misc_mtx lock, this is a possible +deadlock, so we use mutex_trylock here. */ +if (!mutex_trylock (&watchdog_data_mutex)) +return -ERESTARTSYS ; +list_for_each_entry (pos, &watchdog_data_list, list) { +if (pos->watchdog_miscdev.minor ==iminor (inode)) { + data = pos; +break ; + } + } + +/* Note we can never not have found data, so we don't check for this */ +kref_get (&data->kref); +mutex_unlock (&watchdog_data_mutex); + +if (test_and_set_bit (0 , &data->watchdog_is_open)) +return -EBUSY ; + +/* Enable Soft Watchdog */ +watchdog_enable (data); + +/* Store pointer to data into filp's private data */ + filp->private_data = data; +return nonseekable_open (inode, filp); } +static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 , &data->watchdog_is_open); + +return 0 ; +} + +static ssize_t watchdog_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offset) +{ +size_t ret; +struct w83793_data *data = filp->private_data; + +if (count) { +if (!nowayout) { +size_t i; + +/* Clear it in case it was set with a previous write */ + data->watchdog_expect_close =0 ; + +for (i =0 ; i != count; i++) { +char c; +if (get_user (c, buf + i)) +return -EFAULT ; +if (c =='V' ) + data->watchdog_expect_close =1 ; + } + } + ret =watchdog_trigger (data); +if (ret <0 ) +return ret; + } +return count; +} + +static int watchdog_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +static struct watchdog_info ident = { + .options =WDIOF_KEEPALIVEPING | +WDIOF_SETTIMEOUT | +WDIOF_CARDRESET , + .identity ="w83793 watchdog" + }; + +int val, ret =0 ; +struct w83793_data *data = filp->private_data; + +switch (cmd) { +case WDIOC_GETSUPPORT : +if (!nowayout) + ident.options |=WDIOF_MAGICCLOSE ; +if (copy_to_user ((void __user *)arg, &ident,sizeof (ident))) + ret = -EFAULT ; +break ; + +case WDIOC_GETSTATUS : + val = data->watchdog_caused_reboot ?WDIOF_CARDRESET :0 ; + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_GETBOOTSTATUS : + ret =put_user (0 , (int __user *)arg); +break ; + +case WDIOC_KEEPALIVE : + ret =watchdog_trigger (data); +break ; + +case WDIOC_GETTIMEOUT : + val =watchdog_get_timeout (data); + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_SETTIMEOUT : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + ret =watchdog_set_timeout (data, val); +if (ret >0 ) + ret =put_user (ret, (int __user *)arg); +break ; + +case WDIOC_SETOPTIONS : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + +if (val &WDIOS_DISABLECARD ) + ret =watchdog_disable (data); +else if (val &WDIOS_ENABLECARD ) + ret =watchdog_enable (data); +else + ret = -EINVAL ; + +break ; +default : + ret = -ENOTTY ; + } + +return ret; +} + +static const struct file_operations watchdog_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .open = watchdog_open, + .release = watchdog_close, + .write = watchdog_write, + .ioctl = watchdog_ioctl, +}; + +/* +* Notifier for system down +*/ + +static int watchdog_notify_sys (struct notifier_block *this,unsigned long code, +void *unused) +{ +struct w83793_data *data =NULL ; + +if (code ==SYS_DOWN || code ==SYS_HALT ) { + +/* Disable each registered watchdog */ +mutex_lock (&watchdog_data_mutex); +list_for_each_entry (data, &watchdog_data_list, list) { +if (data->watchdog_miscdev.minor) +watchdog_disable (data); + } +mutex_unlock (&watchdog_data_mutex); + } + +return NOTIFY_DONE ; +} + +/* +* The WDT needs to learn about soft shutdowns in order to +* turn the timebomb registers off. +*/ + +static struct notifier_block watchdog_notifier = { + .notifier_call = watchdog_notify_sys, +}; + +/* +* Init / remove routines +*/ +static int w83793_remove (struct i2c_client *client) {struct w83793_data *data =i2c_get_clientdata (client);struct device *dev = &client->dev; -int i; +int i, tmp; + +/* Unregister the watchdog (if registered) */ +if (data->watchdog_miscdev.minor) { +misc_deregister (&data->watchdog_miscdev); + +if (data->watchdog_is_open) { +dev_warn (&client->dev, +"i2c client detached with watchdog open! " +"Stopping watchdog.\n" ); +watchdog_disable (data); + } + +mutex_lock (&watchdog_data_mutex); +list_del (&data->list); +mutex_unlock (&watchdog_data_mutex); + +/* Tell the watchdog code the client is gone */ +mutex_lock (&data->watchdog_lock); + data->client =NULL ; +mutex_unlock (&data->watchdog_lock); + } + +/* Reset Configuration Register to Disable Watch Dog Registers */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp & ~0x04 ); + +unregister_reboot_notifier (&watchdog_notifier);hwmon_device_unregister (data->hwmon_dev);
@@ -1102,6 +1495,10 @@ static int w83793_remove(struct i2c_cliekfree (data); +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex); +return 0 ; }
@@ -1221,6 +1620,7 @@ static int w83793_probe(struct i2c_clien const struct i2c_device_id *id) {struct device *dev = &client->dev; +const int watchdog_minors[] = {WATCHDOG_MINOR ,212 ,213 ,214 ,215 };struct w83793_data *data;int i, tmp, val, err;int files_fan =ARRAY_SIZE (w83793_left_fan) /7 ;
@@ -1236,6 +1638,14 @@ static int w83793_probe(struct i2c_clieni2c_set_clientdata (client, data); data->bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );mutex_init (&data->update_lock); +mutex_init (&data->watchdog_lock); +INIT_LIST_HEAD (&data->list); +kref_init (&data->kref); + +/* Store client pointer in our data struct for watchdog usage +(where the client is found through a data ptr instead of the +otherway around) */ + data->client = client; err =w83793_detect_subclients (client);if (err)
@@ -1398,8 +1808,74 @@ static int w83793_probe(struct i2c_clien goto exit_remove; } +/* Watchdog initialization */ + +/* Register boot notifier */ + err =register_reboot_notifier (&watchdog_notifier); +if (err !=0 ) { +dev_err (&client->dev, +"cannot register reboot notifier (err=%d)\n" , err); + goto exit_devunreg; + } + +/* Enable Watchdog registers. +Set Configuration Register to Enable Watch Dog Registers +(Bit 2) = XXXX, X1XX. */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp |0x04 ); + +/* Check, if last reboot was caused by watchdog */ + data->watchdog_caused_reboot = +w83793_read_value (data->client,W83793_REG_WDT_STATUS ) &0x01 ; + +/* Disable Soft Watchdog during initialiation */ +watchdog_disable (data); + +/* We take the data_mutex lock early so that watchdog_open() cannot +run when misc_register() has completed, but we've not yet added +our data to the watchdog_data_list (and set the default timeout) */ +mutex_lock (&watchdog_data_mutex); +for (i =0 ; i <ARRAY_SIZE (watchdog_minors); i++) { +/* Register our watchdog part */ +snprintf (data->watchdog_name,sizeof (data->watchdog_name), +"watchdog%c" , (i ==0 ) ?'\0' : ('0' + i)); + data->watchdog_miscdev.name = data->watchdog_name; + data->watchdog_miscdev.fops = &watchdog_fops; + data->watchdog_miscdev.minor = watchdog_minors[i]; + + err =misc_register (&data->watchdog_miscdev); +if (err == -EBUSY ) +continue ; +if (err) { + data->watchdog_miscdev.minor =0 ; +dev_err (&client->dev, +"Registering watchdog chardev: %d\n" , err); +break ; + } + +list_add (&data->list, &watchdog_data_list); + +dev_info (&client->dev, +"Registered watchdog chardev major 10, minor: %d\n" , + watchdog_minors[i]); +break ; + } +if (i ==ARRAY_SIZE (watchdog_minors)) { + data->watchdog_miscdev.minor =0 ; +dev_warn (&client->dev,"Couldn't register watchdog chardev " +"(due to no free minor)\n" ); + } + +mutex_unlock (&watchdog_data_mutex); +return 0 ; +/* Unregister hwmon device */ + +exit_devunreg: + +hwmon_device_unregister (data->hwmon_dev); +/* Unregister sysfs hooks */ exit_remove:
@@ -1646,7 +2124,7 @@ static void __exit sensors_w83793_exit(vi2c_del_driver (&w83793_driver); } -MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Rudolf Marek, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" );
drivers/hwmon/Kconfig +2 -1
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VID help If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
begin:vcard
fn:Sven Anders
n:Anders;Sven
org:ANDURAS AG;Research and Development adr;quoted-printable:;;Innstra=C3=9Fe 71;Passau;Bavaria;94036;Germany email;internet:[email protected]
title:Dipl. Inf.
tel;work:++49 (0)851 / 490 50 -0
tel;fax:++49 (0)851 / 590 50 - 55
x-mozilla-html:FALSE
url:http://www.anduras.de
version:2.1
end:vcard
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Quoted 11 lines · Sven Anders
Quoted 6 lines · Sven Anders
Hello!
I implemented watchdog support for the Winbond 83793 chipset. I'll attached the patch.
Any comments welcome!
Ok, sorry.
I forgot to remove the debug output from the first version. Here is the correct one.
Hello!
This is the final version. I did further testing and discovered, that a timeout of 1 minute did not work. The chip did not restart the counter, if I rewrite a value of 1 after 20 seconds elapsed.
I tried to disable and re-enable the watchdog again, but it did not help.
So, I set the default timeout value up to 2 minutes.
Anybody else found time to test/review it? Any comments on the driver? Can you merge it to the current kernel tree? I think the merge window is still open?!
Regards
Sven
Signature · 9 lines
Sven Anders <[email protected]> () Ascii Ribbon Campaign /\ Support plain text e-mail ANDURAS service solutions AG Innstraße 71 - 94036 Passau - Germany Web: www.anduras.de - Tel: +49 (0)851-4 90 50-0 - Fax: +49 (0)851-4 90 50-55 Rechtsform: Aktiengesellschaft - Sitz: Passau - Amtsgericht Passau HRB 6032 Mitglieder des Vorstands: Sven Anders, Marcus Junker Vorsitzender des Aufsichtsrats: Mark Peters
This patch add watchdog functionality to the Winbond 83793 chipset driver.
drivers/hwmon/w83793.c +463 -3
@@ -3,6 +3,10 @@ Copyright (C) 2006 Winbond Electronics Corp. Yuan Mu Rudolf Marek <[email protected]> + Copyright (C) 2009 Sven Anders <[email protected]>, ANDURAS AG. + Watchdog driver part + (Based partially on fschmd driver, + Copyright 2007-2008 by Hans de Goede) 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
@@ -35,10 +39,20 @@#include <linux/hwmon-sysfs.h> #include <linux/err.h> #include <linux/mutex.h> +#include <linux/fs.h> +#include <linux/watchdog.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/kref.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +/* Default values */ +#define WATCHDOG_TIMEOUT 2/* 2 minute default timeout */ /* Addresses to scan */ static const unsigned short normal_i2c[] = {0x2c ,0x2d ,0x2e ,0x2f , -I2C_CLIENT_END }; +I2C_CLIENT_END };/* Insmod parameters */ I2C_CLIENT_INSMOD_1 (w83793);
@@ -52,6 +66,18 @@ static int reset;module_param (reset, bool,0 );MODULE_PARM_DESC (reset,"Set to 1 to reset chip, not recommended" ); +static int timeout =WATCHDOG_TIMEOUT ;/* in minutes */ +module_param (timeout, int,0 ); +MODULE_PARM_DESC (timeout, + "Watchdog timeout in minutes. 2<= timeout <=255 (default=" + __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); + +static int nowayout =WATCHDOG_NOWAYOUT ; +module_param (nowayout, int,0 ); +MODULE_PARM_DESC (nowayout, + "Watchdog cannot be stopped once started (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); +/* Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved as ID, Bank Select registers
@@ -73,6 +99,11 @@ MODULE_PARM_DESC(reset, "Set to 1 to res#define W83793_REG_VID_LATCHB 0x08#define W83793_REG_VID_CTRL 0x59 +#define W83793_REG_WDT_LOCK 0x01 +#define W83793_REG_WDT_ENABLE 0x02 +#define W83793_REG_WDT_STATUS 0x03 +#define W83793_REG_WDT_TIMEOUT 0x04 +static u16 W83793_REG_TEMP_MODE [2 ] = {0x5e ,0x5f };#define TEMP_READ 0
@@ -224,8 +255,36 @@ struct w83793_data {u8 tolerance[3 ];/* Temp tolerance(Smart Fan I/II) */ u8 sf2_pwm[6 ][7 ];/* Smart FanII: Fan duty cycle */ u8 sf2_temp[6 ][7 ];/* Smart FanII: Temp level point */ + +/* watchdog */ +struct i2c_client *client; +struct mutex watchdog_lock; +struct list_head list;/* member of the watchdog_data_list */ +struct kref kref; +struct miscdevice watchdog_miscdev; +unsigned long watchdog_is_open; +char watchdog_expect_close; +char watchdog_name[10 ];/* must be unique to avoid sysfs conflict */ +unsigned int watchdog_caused_reboot; }; +/* Somewhat ugly :( global data pointer list with all devices, so that +we can find our device data as when using misc_register. There is no +other method to get to one's device data from the open file-op and +for usage in the reboot notifier callback. */ +static LIST_HEAD (watchdog_data_list); + +/* Note this lock not only protect list access, but also data.kref access */ +static DEFINE_MUTEX (watchdog_data_mutex); + +/* Release our data struct when we're detached from the i2c client *and* all +references to our watchdog device are released */ +static void w83793_release_resources (struct kref *ref) +{ + struct w83793_data *data = container_of(ref, struct w83793_data, kref); +kfree (data); +} +static u8 w83793_read_value (struct i2c_client *client,u16 reg);static int w83793_write_value (struct i2c_client *client,u16 reg,u8 value); static int w83793_probe(struct i2c_client *client,
@@ -1064,14 +1123,336 @@ static void w83793_init_client(struct i2/* Start monitoring */ w83793_write_value (client,W83793_REG_CONFIG ,w83793_read_value (client,W83793_REG_CONFIG ) |0x01 ); +} + +/* +* Watchdog routines +*/ + +static int watchdog_set_timeout (struct w83793_data *data,int timeout) +{ +int ret, stimeout; + +if (timeout >255 ) +return -EINVAL ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + + stimeout =DIV_ROUND_UP (timeout,60 ); + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , stimeout); + + ret = stimeout; + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_get_timeout (struct w83793_data *data) +{ +int gtimeout; + +mutex_lock (&data->watchdog_lock); +if (!data->client) +return -ENODEV ; + +/* Get Timeout value (in Minutes) */ + gtimeout =w83793_read_value (data->client,W83793_REG_WDT_TIMEOUT ) *60 ; + +mutex_unlock (&data->watchdog_lock); + +return gtimeout; +} + +static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_enable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set initial timeout */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +/* Enable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0x55 ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_disable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Disable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0xAA ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_open (struct inode *inode,struct file *filp) +{ +struct w83793_data *pos, *data =NULL ; + +/* We get called from drivers/char/misc.c with misc_mtx hold, and we +call misc_register() from fschmd_probe() with watchdog_data_mutex +hold, as misc_register() takes the misc_mtx lock, this is a possible +deadlock, so we use mutex_trylock here. */ +if (!mutex_trylock (&watchdog_data_mutex)) +return -ERESTARTSYS ; +list_for_each_entry (pos, &watchdog_data_list, list) { +if (pos->watchdog_miscdev.minor ==iminor (inode)) { + data = pos; +break ; + } + } + +/* Note we can never not have found data, so we don't check for this */ +kref_get (&data->kref); +mutex_unlock (&watchdog_data_mutex); + +if (test_and_set_bit (0 , &data->watchdog_is_open)) +return -EBUSY ; + +/* Enable Soft Watchdog */ +watchdog_enable (data); + +/* Store pointer to data into filp's private data */ + filp->private_data = data; +return nonseekable_open (inode, filp); } +static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 , &data->watchdog_is_open); + +return 0 ; +} + +static ssize_t watchdog_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offset) +{ +size_t ret; +struct w83793_data *data = filp->private_data; + +if (count) { +if (!nowayout) { +size_t i; + +/* Clear it in case it was set with a previous write */ + data->watchdog_expect_close =0 ; + +for (i =0 ; i != count; i++) { +char c; +if (get_user (c, buf + i)) +return -EFAULT ; +if (c =='V' ) + data->watchdog_expect_close =1 ; + } + } + ret =watchdog_trigger (data); +if (ret <0 ) +return ret; + } +return count; +} + +static int watchdog_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +static struct watchdog_info ident = { + .options =WDIOF_KEEPALIVEPING | +WDIOF_SETTIMEOUT | +WDIOF_CARDRESET , + .identity ="w83793 watchdog" + }; + +int val, ret =0 ; +struct w83793_data *data = filp->private_data; + +switch (cmd) { +case WDIOC_GETSUPPORT : +if (!nowayout) + ident.options |=WDIOF_MAGICCLOSE ; +if (copy_to_user ((void __user *)arg, &ident,sizeof (ident))) + ret = -EFAULT ; +break ; + +case WDIOC_GETSTATUS : + val = data->watchdog_caused_reboot ?WDIOF_CARDRESET :0 ; + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_GETBOOTSTATUS : + ret =put_user (0 , (int __user *)arg); +break ; + +case WDIOC_KEEPALIVE : + ret =watchdog_trigger (data); +break ; + +case WDIOC_GETTIMEOUT : + val =watchdog_get_timeout (data); + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_SETTIMEOUT : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + ret =watchdog_set_timeout (data, val); +if (ret >0 ) + ret =put_user (ret, (int __user *)arg); +break ; + +case WDIOC_SETOPTIONS : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + +if (val &WDIOS_DISABLECARD ) + ret =watchdog_disable (data); +else if (val &WDIOS_ENABLECARD ) + ret =watchdog_enable (data); +else + ret = -EINVAL ; + +break ; +default : + ret = -ENOTTY ; + } + +return ret; +} + +static const struct file_operations watchdog_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .open = watchdog_open, + .release = watchdog_close, + .write = watchdog_write, + .ioctl = watchdog_ioctl, +}; + +/* +* Notifier for system down +*/ + +static int watchdog_notify_sys (struct notifier_block *this,unsigned long code, +void *unused) +{ +struct w83793_data *data =NULL ; + +if (code ==SYS_DOWN || code ==SYS_HALT ) { + +/* Disable each registered watchdog */ +mutex_lock (&watchdog_data_mutex); +list_for_each_entry (data, &watchdog_data_list, list) { +if (data->watchdog_miscdev.minor) +watchdog_disable (data); + } +mutex_unlock (&watchdog_data_mutex); + } + +return NOTIFY_DONE ; +} + +/* +* The WDT needs to learn about soft shutdowns in order to +* turn the timebomb registers off. +*/ + +static struct notifier_block watchdog_notifier = { + .notifier_call = watchdog_notify_sys, +}; + +/* +* Init / remove routines +*/ +static int w83793_remove (struct i2c_client *client) {struct w83793_data *data =i2c_get_clientdata (client);struct device *dev = &client->dev; -int i; +int i, tmp; + +/* Unregister the watchdog (if registered) */ +if (data->watchdog_miscdev.minor) { +misc_deregister (&data->watchdog_miscdev); + +if (data->watchdog_is_open) { +dev_warn (&client->dev, +"i2c client detached with watchdog open! " +"Stopping watchdog.\n" ); +watchdog_disable (data); + } + +mutex_lock (&watchdog_data_mutex); +list_del (&data->list); +mutex_unlock (&watchdog_data_mutex); + +/* Tell the watchdog code the client is gone */ +mutex_lock (&data->watchdog_lock); + data->client =NULL ; +mutex_unlock (&data->watchdog_lock); + } + +/* Reset Configuration Register to Disable Watch Dog Registers */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp & ~0x04 ); + +unregister_reboot_notifier (&watchdog_notifier);hwmon_device_unregister (data->hwmon_dev);
@@ -1102,6 +1495,10 @@ static int w83793_remove(struct i2c_cliekfree (data); +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex); +return 0 ; }
@@ -1221,6 +1620,7 @@ static int w83793_probe(struct i2c_clien const struct i2c_device_id *id) {struct device *dev = &client->dev; +const int watchdog_minors[] = {WATCHDOG_MINOR ,212 ,213 ,214 ,215 };struct w83793_data *data;int i, tmp, val, err;int files_fan =ARRAY_SIZE (w83793_left_fan) /7 ;
@@ -1236,6 +1638,14 @@ static int w83793_probe(struct i2c_clieni2c_set_clientdata (client, data); data->bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );mutex_init (&data->update_lock); +mutex_init (&data->watchdog_lock); +INIT_LIST_HEAD (&data->list); +kref_init (&data->kref); + +/* Store client pointer in our data struct for watchdog usage +(where the client is found through a data ptr instead of the +otherway around) */ + data->client = client; err =w83793_detect_subclients (client);if (err)
@@ -1398,8 +1808,74 @@ static int w83793_probe(struct i2c_clien goto exit_remove; } +/* Watchdog initialization */ + +/* Register boot notifier */ + err =register_reboot_notifier (&watchdog_notifier); +if (err !=0 ) { +dev_err (&client->dev, +"cannot register reboot notifier (err=%d)\n" , err); + goto exit_devunreg; + } + +/* Enable Watchdog registers. +Set Configuration Register to Enable Watch Dog Registers +(Bit 2) = XXXX, X1XX. */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp |0x04 ); + +/* Check, if last reboot was caused by watchdog */ + data->watchdog_caused_reboot = +w83793_read_value (data->client,W83793_REG_WDT_STATUS ) &0x01 ; + +/* Disable Soft Watchdog during initialiation */ +watchdog_disable (data); + +/* We take the data_mutex lock early so that watchdog_open() cannot +run when misc_register() has completed, but we've not yet added +our data to the watchdog_data_list (and set the default timeout) */ +mutex_lock (&watchdog_data_mutex); +for (i =0 ; i <ARRAY_SIZE (watchdog_minors); i++) { +/* Register our watchdog part */ +snprintf (data->watchdog_name,sizeof (data->watchdog_name), +"watchdog%c" , (i ==0 ) ?'\0' : ('0' + i)); + data->watchdog_miscdev.name = data->watchdog_name; + data->watchdog_miscdev.fops = &watchdog_fops; + data->watchdog_miscdev.minor = watchdog_minors[i]; + + err =misc_register (&data->watchdog_miscdev); +if (err == -EBUSY ) +continue ; +if (err) { + data->watchdog_miscdev.minor =0 ; +dev_err (&client->dev, +"Registering watchdog chardev: %d\n" , err); +break ; + } + +list_add (&data->list, &watchdog_data_list); + +dev_info (&client->dev, +"Registered watchdog chardev major 10, minor: %d\n" , + watchdog_minors[i]); +break ; + } +if (i ==ARRAY_SIZE (watchdog_minors)) { + data->watchdog_miscdev.minor =0 ; +dev_warn (&client->dev,"Couldn't register watchdog chardev " +"(due to no free minor)\n" ); + } + +mutex_unlock (&watchdog_data_mutex); +return 0 ; +/* Unregister hwmon device */ + +exit_devunreg: + +hwmon_device_unregister (data->hwmon_dev); +/* Unregister sysfs hooks */ exit_remove:
@@ -1646,7 +2124,7 @@ static void __exit sensors_w83793_exit(vi2c_del_driver (&w83793_driver); } -MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Rudolf Marek, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" );
drivers/hwmon/Kconfig +2 -1
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VID help If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
begin:vcard
fn:Sven Anders
n:Anders;Sven
org:ANDURAS AG;Research and Development adr;quoted-printable:;;Innstra=C3=9Fe 71;Passau;Bavaria;94036;Germany email;internet:[email protected]
title:Dipl. Inf.
tel;work:++49 (0)851 / 490 50 -0
tel;fax:++49 (0)851 / 590 50 - 55
x-mozilla-html:FALSE
url:http://www.anduras.de
version:2.1
end:vcard
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Hi,
Comments inline.
--- linux-2.6.29.6/drivers/hwmon/w83793.c 2009-07-03 01:41:20.000000000 +0200
+++ linux-2.6.29.6.watchdog/drivers/hwmon/w83793.c 2009-12-04 12:10:55.000000000 +0100
<snip>
@@ -1064,14 +1123,336 @@ static void w83793_init_client(struct i2
/* Start monitoring */
w83793_write_value(client, W83793_REG_CONFIG,
w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
+}
+
+/*
+ * Watchdog routines
+ */
+
+static int watchdog_set_timeout(struct w83793_data *data, int timeout) +{
+ int ret, stimeout;
+
+ if (timeout > 255)
+ return -EINVAL;
+
timeout is in seconds here, you should do the DIV_ROUND_UP before taking the lock, and do this check on stimeout.
+ mutex_lock(&data->watchdog_lock);
+ if (!data->client) {
+ ret = -ENODEV;
+ goto leave;
+ }
+
+ stimeout = DIV_ROUND_UP(timeout, 60);
+
+ /* Set Timeout value (in Minutes) */
+ w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT, stimeout);
+
+ ret = stimeout;
+
That should be "stimeout * 60".
+leave:
+ mutex_unlock(&data->watchdog_lock);
+ return ret;
+}
+
+static int watchdog_get_timeout(struct w83793_data *data) +{
+ int gtimeout;
+
+ mutex_lock(&data->watchdog_lock);
+ if (!data->client)
+ return -ENODEV;
+
+ /* Get Timeout value (in Minutes) */
+ gtimeout = w83793_read_value(data->client, W83793_REG_WDT_TIMEOUT) * 60;
+
+ mutex_unlock(&data->watchdog_lock);
+
+ return gtimeout;
+}
+
+static int watchdog_trigger(struct w83793_data *data) +{
+ int ret = 0;
+
+ mutex_lock(&data->watchdog_lock);
+ if (!data->client) {
+ ret = -ENODEV;
+ goto leave;
+ }
+
+ /* Set Timeout value (in Minutes) */
+ w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT, timeout);
+
Hmm, and here things get a bit funky, you write the TIMEOUT configuration register, are you sure this is the right way to do a trigger ?
If so you should remember the configured timeout (the one configured through the ioctl) in data and write that each trigger.
+leave:
+ mutex_unlock(&data->watchdog_lock);
+ return ret;
+}
+
+static int watchdog_enable(struct w83793_data *data) +{
+ int ret = 0;
+
+ mutex_lock(&data->watchdog_lock);
+ if (!data->client) {
+ ret = -ENODEV;
+ goto leave;
+ }
+
+ /* Set initial timeout */
+ w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT, timeout);
+
+ /* Enable Soft Watchdog */
+ w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0x55);
+
+leave:
+ mutex_unlock(&data->watchdog_lock);
+ return ret;
+}
+
+static int watchdog_disable(struct w83793_data *data) +{
+ int ret = 0;
+
+ mutex_lock(&data->watchdog_lock);
+ if (!data->client) {
+ ret = -ENODEV;
+ goto leave;
+ }
+
+ /* Disable Soft Watchdog */
+ w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0xAA);
+
+leave:
+ mutex_unlock(&data->watchdog_lock);
+ return ret;
+}
+
+static int watchdog_open(struct inode *inode, struct file *filp) +{
+ struct w83793_data *pos, *data = NULL;
+
+ /* We get called from drivers/char/misc.c with misc_mtx hold, and we
+ call misc_register() from fschmd_probe() with watchdog_data_mutex + hold, as misc_register() takes the misc_mtx lock, this is a possible + deadlock, so we use mutex_trylock here. */
That fschmd_probe should be w83793_probe I think :)
+ if (!mutex_trylock(&watchdog_data_mutex))
+ return -ERESTARTSYS;
+ list_for_each_entry(pos, &watchdog_data_list, list) {
+ if (pos->watchdog_miscdev.minor = iminor(inode)) {
+ data = pos;
+ break;
+ }
+ }
+
+ /* Note we can never not have found data, so we don't check for this */
+ kref_get(&data->kref);
+ mutex_unlock(&watchdog_data_mutex);
+
+ if (test_and_set_bit(0, &data->watchdog_is_open))
+ return -EBUSY;
+
+ /* Enable Soft Watchdog */
+ watchdog_enable(data);
+
+ /* Store pointer to data into filp's private data */
+ filp->private_data = data;
+ return nonseekable_open(inode, filp);
}
+static int watchdog_close(struct inode *inode, struct file *filp) +{
+ struct w83793_data *data = filp->private_data;
+
+ if (data->watchdog_expect_close) {
+ watchdog_disable(data);
+ data->watchdog_expect_close = 0;
+ } else {
+ watchdog_trigger(data);
+ dev_crit(&data->client->dev,
+ "unexpected close, not stopping watchdog!\n");
+ }
+
+ clear_bit(0, &data->watchdog_is_open);
+
You are missing:
mutex_lock(&watchdog_data_mutex);
kref_put(&data->kref, w83793_release_resources);
mutex_unlock(&watchdog_data_mutex);Here !!
+ return 0;
+}
+
+static ssize_t watchdog_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *offset)
+{
+ size_t ret;
+ struct w83793_data *data = filp->private_data;
+
+ if (count) {
+ if (!nowayout) {
+ size_t i;
+
+ /* Clear it in case it was set with a previous write */
+ data->watchdog_expect_close = 0;
+
+ for (i = 0; i != count; i++) {
+ char c;
+ if (get_user(c, buf + i))
+ return -EFAULT;
+ if (c = 'V')
+ data->watchdog_expect_close = 1;
+ }
+ }
+ ret = watchdog_trigger(data);
+ if (ret < 0)
+ return ret;
+ }
+ return count;
+}
+
+static int watchdog_ioctl(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ static struct watchdog_info ident = {
+ .options = WDIOF_KEEPALIVEPING |
+ WDIOF_SETTIMEOUT |
+ WDIOF_CARDRESET,
+ .identity = "w83793 watchdog"
+ };
+
+ int val, ret = 0;
+ struct w83793_data *data = filp->private_data;
+
+ switch (cmd) {
+ case WDIOC_GETSUPPORT:
+ if (!nowayout)
+ ident.options |= WDIOF_MAGICCLOSE;
+ if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
+ ret = -EFAULT;
+ break;
+
+ case WDIOC_GETSTATUS:
+ val = data->watchdog_caused_reboot ? WDIOF_CARDRESET : 0;
+ ret = put_user(val, (int __user *)arg);
+ break;
+
+ case WDIOC_GETBOOTSTATUS:
+ ret = put_user(0, (int __user *)arg);
+ break;
+
+ case WDIOC_KEEPALIVE:
+ ret = watchdog_trigger(data);
+ break;
+
+ case WDIOC_GETTIMEOUT:
+ val = watchdog_get_timeout(data);
+ ret = put_user(val, (int __user *)arg);
+ break;
+
+ case WDIOC_SETTIMEOUT:
+ if (get_user(val, (int __user *)arg)) {
+ ret = -EFAULT;
+ break;
+ }
+ ret = watchdog_set_timeout(data, val);
+ if (ret > 0)
+ ret = put_user(ret, (int __user *)arg);
+ break;
+
+ case WDIOC_SETOPTIONS:
+ if (get_user(val, (int __user *)arg)) {
+ ret = -EFAULT;
+ break;
+ }
+
+ if (val & WDIOS_DISABLECARD)
+ ret = watchdog_disable(data);
+ else if (val & WDIOS_ENABLECARD)
+ ret = watchdog_enable(data);
+ else
+ ret = -EINVAL;
+
+ break;
+ default:
+ ret = -ENOTTY;
+ }
+
+ return ret;
+}
+
+static const struct file_operations watchdog_fops = {
+ .owner = THIS_MODULE,
+ .llseek = no_llseek,
+ .open = watchdog_open,
+ .release = watchdog_close,
+ .write = watchdog_write,
+ .ioctl = watchdog_ioctl,
+};
+
+/*
+ * Notifier for system down
+ */
+
+static int watchdog_notify_sys(struct notifier_block *this, unsigned long code,
+ void *unused)
+{
+ struct w83793_data *data = NULL;
+
+ if (code = SYS_DOWN || code = SYS_HALT) {
+
+ /* Disable each registered watchdog */
+ mutex_lock(&watchdog_data_mutex);
+ list_for_each_entry(data, &watchdog_data_list, list) {
+ if (data->watchdog_miscdev.minor)
+ watchdog_disable(data);
+ }
+ mutex_unlock(&watchdog_data_mutex);
+ }
+
+ return NOTIFY_DONE;
+}
+
+/*
+ * The WDT needs to learn about soft shutdowns in order to
+ * turn the timebomb registers off.
+ */
+
+static struct notifier_block watchdog_notifier = {
+ .notifier_call = watchdog_notify_sys,
+};
+
+/*
+ * Init / remove routines
+ */
+
static int w83793_remove(struct i2c_client *client)
{
struct w83793_data *data = i2c_get_clientdata(client); struct device *dev = &client->dev;
- int i;
+ int i, tmp;
+
+ /* Unregister the watchdog (if registered) */
+ if (data->watchdog_miscdev.minor) {
+ misc_deregister(&data->watchdog_miscdev);
+
+ if (data->watchdog_is_open) {
+ dev_warn(&client->dev,
+ "i2c client detached with watchdog open! "
+ "Stopping watchdog.\n");
+ watchdog_disable(data);
+ }
+
+ mutex_lock(&watchdog_data_mutex);
+ list_del(&data->list);
+ mutex_unlock(&watchdog_data_mutex);
+
+ /* Tell the watchdog code the client is gone */
+ mutex_lock(&data->watchdog_lock);
+ data->client = NULL;
+ mutex_unlock(&data->watchdog_lock);
+ }
+
+ /* Reset Configuration Register to Disable Watch Dog Registers */
+ tmp = w83793_read_value(client, W83793_REG_CONFIG);
+ w83793_write_value(client, W83793_REG_CONFIG, tmp & ~0x04);
+
+ unregister_reboot_notifier(&watchdog_notifier);
hwmon_device_unregister(data->hwmon_dev);
@@ -1102,6 +1495,10 @@ static int w83793_remove(struct i2c_clie
kfree(data);
+ mutex_lock(&watchdog_data_mutex);
+ kref_put(&data->kref, w83793_release_resources);
+ mutex_unlock(&watchdog_data_mutex);
+
return 0;
}
The kfree(data) should be removed, this is done by w83793_release_resources() now.
@@ -1221,6 +1620,7 @@ static int w83793_probe(struct i2c_clien
const struct i2c_device_id *id)
{
struct device *dev = &client->dev;
+ const int watchdog_minors[] = { WATCHDOG_MINOR, 212, 213, 214, 215 };
struct w83793_data *data;
int i, tmp, val, err;
int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
@@ -1236,6 +1638,14 @@ static int w83793_probe(struct i2c_clien
i2c_set_clientdata(client, data);
data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL); mutex_init(&data->update_lock);
+ mutex_init(&data->watchdog_lock);
+ INIT_LIST_HEAD(&data->list);
+ kref_init(&data->kref);
+
+ /* Store client pointer in our data struct for watchdog usage
+ (where the client is found through a data ptr instead of the
+ otherway around) */
+ data->client = client;
err = w83793_detect_subclients(client);
if (err)
@@ -1398,8 +1808,74 @@ static int w83793_probe(struct i2c_clien
goto exit_remove;
}
+ /* Watchdog initialization */
+
+ /* Register boot notifier */
+ err = register_reboot_notifier(&watchdog_notifier);
+ if (err != 0) {
+ dev_err(&client->dev,
+ "cannot register reboot notifier (err=%d)\n", err);
+ goto exit_devunreg;
+ }
+
+ /* Enable Watchdog registers.
+ Set Configuration Register to Enable Watch Dog Registers
+ (Bit 2) = XXXX, X1XX. */
+ tmp = w83793_read_value(client, W83793_REG_CONFIG);
+ w83793_write_value(client, W83793_REG_CONFIG, tmp | 0x04);
+
+ /* Check, if last reboot was caused by watchdog */
+ data->watchdog_caused_reboot + w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
+
+ /* Disable Soft Watchdog during initialiation */
+ watchdog_disable(data);
+
+ /* We take the data_mutex lock early so that watchdog_open() cannot
+ run when misc_register() has completed, but we've not yet added
+ our data to the watchdog_data_list (and set the default timeout) */
+ mutex_lock(&watchdog_data_mutex);
+ for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
+ /* Register our watchdog part */
+ snprintf(data->watchdog_name, sizeof(data->watchdog_name),
+ "watchdog%c", (i = 0) ? '\0' : ('0' + i));
+ data->watchdog_miscdev.name = data->watchdog_name;
+ data->watchdog_miscdev.fops = &watchdog_fops;
+ data->watchdog_miscdev.minor = watchdog_minors[i];
+
+ err = misc_register(&data->watchdog_miscdev);
+ if (err = -EBUSY)
+ continue;
+ if (err) {
+ data->watchdog_miscdev.minor = 0;
+ dev_err(&client->dev,
+ "Registering watchdog chardev: %d\n", err);
+ break;
+ }
+
+ list_add(&data->list, &watchdog_data_list);
+
+ dev_info(&client->dev,
+ "Registered watchdog chardev major 10, minor: %d\n",
+ watchdog_minors[i]);
+ break;
+ }
+ if (i = ARRAY_SIZE(watchdog_minors)) {
+ data->watchdog_miscdev.minor = 0;
+ dev_warn(&client->dev, "Couldn't register watchdog chardev "
+ "(due to no free minor)\n");
+ }
+
+ mutex_unlock(&watchdog_data_mutex);
+
You do not seem to be setting a default timeout here even though you've made this configurable through a module parameter, but this might be due to the remarks given above wrt the trigger.
return 0;
+ /* Unregister hwmon device */
+
+exit_devunreg:
+
+ hwmon_device_unregister(data->hwmon_dev);
+
/* Unregister sysfs hooks */
exit_remove:
@@ -1646,7 +2124,7 @@ static void __exit sensors_w83793_exit(v
i2c_del_driver(&w83793_driver);
}
-MODULE_AUTHOR("Yuan Mu"); +MODULE_AUTHOR("Yuan Mu, Rudolf Marek, Sven Anders");
MODULE_DESCRIPTION("w83793 driver"); MODULE_LICENSE("GPL");
Not quite sure why you are adding Rudolf Marek here.
drivers/hwmon/Kconfig +2 -1
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VID help If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
Regards,
Hans
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Hi,
Quoted 8 lines · Sven Anders
Quoted 2 lines
Hi,
Comments inline.First: Thanks for the comments!
I attached a new version to this mail, but I did not changed the close function (see comment there!).
See comments to your comments below :)
<snip>
Quoted 14 lines
Quoted 14 lines
drivers/hwmon/w83793.c +13
-0+static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); +
Quoted 14 lines
Quoted 2 lines
Hmm, and here things get a bit funky, you write the TIMEOUT configuration register, are you sure this is the right way to do a trigger ?
Yes. The Winbond chipsets do not have any special register to reset the countdown timer. The counter timer register is decremented during counting down. Most Winbond chipsets use seconds as an unit. This works fine for them. Unfortunatly this chipset uses minutes as unit, which seems to rises an additional problem: The internal timer is only reset, if the value of the register is different. Because the timer counts only minutes this means if it's value is 1 (which means 1 second to 60 seconds left) we cannot write a new value of 1 after 30 seconds into it, because it would not reset the counter. Therefore it's only working for timeouts greater than 1. (Writing a greater value before the correct one will not help!)
Ok, thanks for the explanation.
Quoted 5 lines
Quoted 2 lines
If so you should remember the configured timeout (the one configured through the ioctl) in data and write that each trigger.
The timeout here is an global variable, so it's already done here.
Erm, no.
The watchdog_set_timeout() function currently writes the timeout passed in to the chip, but that will only change the timeout now, and not for future triggers. The way the ioctl should work is that the timeout between 2 triggers (before the system resets) should be changed, so the value written by watchdog_trigger() should be changed. And since this driver can support multiple ic's (unlikely this ever happens but still) the timeout should be stored in the w83793_data struct so that it can be changed per device. The module parameter can then be used to initialize the per device timeout when the device is probed.
So:
-per device timeout in w83793_data
-this gets initialized to the module parameter timeout value -watchdog_set_timeout() changes the per device timeout in the
struct and calls (trigger) to immediately apply the new timeout
-watchdog_get_timeout() returns the timeout from the per device
data struct
-watchdog_trigger writes the per device timeout to the chip.
<snip>
Quoted 18 lines
Quoted 18 lines
drivers/hwmon/w83793.c +15
-0+static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 ,&data->watchdog_is_open); +You are missing:
Quoted 8 lines
Quoted 3 lines
mutex_lock(&watchdog_data_mutex); kref_put(&data->kref, w83793_release_resources); mutex_unlock(&watchdog_data_mutex);I'm not sure if you're right. Closing the watchdog did not remove the module nor does it disable it configurability.
But maybe I misunderstood something here.
Well I'm sure I'm right :) (please don't take this wrong and please
keep asking questions).
The problem with the free-ing of the per device data struct is that there are 2 ways to get to it:
1) Through the hwmon interface
2) Through the watchdog device
Now the following can happen:
1) Driver attaches to w83793 i2c device
2) app opens /dev/watchdog
3) Driver detaches from w83793 i2c device
(for example because the i2c master module
gets unloaded)
Now before your changes 3) Would remove the hwmon interface (and thus the only path to the per device data) and then the per device data would be freed.
However now, someone can still have a reference to the per device data (the app which has /dev/watchdog open). This is why we now use reference counting for the per device data struct (this is what the kref stuff does). So we start by initializing the kref in probe() which puts its counter at 1, then the watchdog open function increases the counter (the kref_get) to 2. Then when the driver detaches, the w83793_remove() function decreases the counter (the kref_put) to 1, this does not call w83793_release_resources, as that will only get called when the kref hits 0.
Now when:
4) The app closes /dev/watchdog
The close function should call kref_put too, so that the counter will hit 0 and the data struct gets free-ed.
Note:
1) that the misc_deregister() call in w83793_remove() only removes the /dev/watchdog node, and does not close any open filehandles already pointing to the watchdog (closing of filehandles is up to the application not the kernel).
2) that this (the i2c client being detached while /dev/watchdog is still open), is the reason for the data->client check in all watchdog functions which actually read/write the chip.
<snip>
Quoted 5 lines
Quoted 5 lines
drivers/hwmon/w83793.c +1
-1-MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Rudolf Marek, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" );
Quoted 7 lines
Quoted 1 line
Not quite sure why you are adding Rudolf Marek here.
He's mentioned in the copyright above. If this entry is only used as a "maintainers" entry, I should set it to:
+MODULE_AUTHOR("Yuan Mu (sensors), Sven Anders (watchdog)");
The meaning of MODULE_AUTHOR is not exactly defined AFAIK, but users often use it as "maintainers" entry, so given that he is not part of the MODULE_AUTHOR value now I don't think you should add him.
Quoted 3 lines
On the other hand, I think you are missing the 'reboot notifier' in your fschmd driver code.
The fsc chips are all part of Fujitsu Siemens Computers, iow the manufacturer of the motherboard = the manufacturer of the watchdog. As such the watchdog always gets initialized by the BIOS, so there is no reason to disable it before shutdown / reboot.
Regards,
Hans
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Quoted 2 lines
Hi,
Comments inline.
First: Thanks for the comments!
I attached a new version to this mail, but I did not changed the close function (see comment there!).
Quoted 10 lines
(quoted diff) +7
-0+static int watchdog_set_timeout(struct w83793_data *data, int timeout) +{ + int ret, stimeout; + + if (timeout > 255) + return -EINVAL; +timeout is in seconds here, you should do the
DIV_ROUND_UPbefore taking the lock, and do this check on stimeout.
Yes, correct. I changed it...
Quoted 14 lines
(quoted diff) +13
-0+ mutex_lock(&data->watchdog_lock); + if (!data->client) { + ret = -ENODEV; + goto leave; + } + + stimeout = DIV_ROUND_UP(timeout, 60); + + /* Set Timeout value (in Minutes) */ + w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT, stimeout); + + ret = stimeout; +
Quoted 1 line
That should be "stimeout * 60".
Corrected, too..
Quoted 14 lines
(quoted diff) +13
-0+static int watchdog_trigger(struct w83793_data *data) +{ + int ret = 0; + + mutex_lock(&data->watchdog_lock); + if (!data->client) { + ret = -ENODEV; + goto leave; + } + + /* Set Timeout value (in Minutes) */ + w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT, timeout); +
Quoted 2 lines
Hmm, and here things get a bit funky, you write the TIMEOUT configuration register, are you sure this is the right way to do a trigger ?
Yes. The Winbond chipsets do not have any special register to reset the countdown timer. The counter timer register is decremented during counting down. Most Winbond chipsets use seconds as an unit. This works fine for them. Unfortunatly this chipset uses minutes as unit, which seems to rises an additional problem: The internal timer is only reset, if the value of the register is different. Because the timer counts only minutes this means if it's value is 1 (which means 1 second to 60 seconds left) we cannot write a new value of 1 after 30 seconds into it, because it would not reset the counter. Therefore it's only working for timeouts greater than 1. (Writing a greater value before the correct one will not help!)
Quoted 2 lines
If so you should remember the configured timeout (the one configured through the ioctl) in data and write that each trigger.
The timeout here is an global variable, so it's already done here.
Quoted 10 lines
(quoted diff) +8
-0+static int watchdog_open(struct inode *inode, struct file *filp) +{ + struct w83793_data *pos, *data = NULL; + + /* We get called from drivers/char/misc.c with misc_mtx hold, and we + call misc_register() from fschmd_probe() with watchdog_data_mutex + hold, as misc_register() takes the misc_mtx lock, this is a possible + deadlock, so we use mutex_trylock here. */That
fschmd_probeshould bew83793_probeI think :)
Yup, cut-and-paste error.
Quoted 16 lines
(quoted diff) +15
-0+static int watchdog_close(struct inode *inode, struct file *filp) +{ + struct w83793_data *data = filp->private_data; + + if (data->watchdog_expect_close) { + watchdog_disable(data); + data->watchdog_expect_close = 0; + } else { + watchdog_trigger(data); + dev_crit(&data->client->dev, + "unexpected close, not stopping watchdog!\n"); + } + + clear_bit(0, &data->watchdog_is_open); +
Quoted 5 lines
You are missing:
mutex_lock(&watchdog_data_mutex); kref_put(&data->kref, w83793_release_resources); mutex_unlock(&watchdog_data_mutex);
I'm not sure if you're right. Closing the watchdog did not remove the module nor does it disable it configurability.
But maybe I misunderstood something here.
Quoted 11 lines
(quoted diff) +4
-0@@ -1102,6 +1495,10 @@ static int w83793_remove(struct i2c_clie kfree(data); + mutex_lock(&watchdog_data_mutex); + kref_put(&data->kref, w83793_release_resources); + mutex_unlock(&watchdog_data_mutex); + return 0; }
Quoted 2 lines
The kfree(data) should be removed, this is done by
w83793_release_resources()now.
You're right. I've overseen this.
Quoted 9 lines
(quoted diff) +8
-0+ if (i == ARRAY_SIZE(watchdog_minors)) { + data->watchdog_miscdev.minor = 0; + dev_warn(&client->dev, "Couldn't register watchdog chardev " + "(due to no free minor)\n"); + } + + mutex_unlock(&watchdog_data_mutex); +
Quoted 3 lines
You do not seem to be setting a default timeout here even though you've made this configurable through a module parameter, but this might be due to the remarks given above wrt the trigger.
See comment above. I set the global variable, so the new timeout value is propagated.
Quoted 10 lines
(quoted diff) +1
-1@@ -1646,7 +2124,7 @@ static void __exit sensors_w83793_exit(v i2c_del_driver(&w83793_driver); } -MODULE_AUTHOR("Yuan Mu"); +MODULE_AUTHOR("Yuan Mu, Rudolf Marek, Sven Anders"); MODULE_DESCRIPTION("w83793 driver"); MODULE_LICENSE("GPL");Not quite sure why you are adding Rudolf Marek here.
He's mentioned in the copyright above. If this entry is only used as a "maintainers" entry, I should set it to:
+MODULE_AUTHOR("Yuan Mu (sensors), Sven Anders (watchdog)");
Feel free to change it!
On the other hand, I think you are missing the 'reboot notifier' in your fschmd driver code.
Regards
Sven
Signature · 9 lines
Sven Anders <[email protected]> () Ascii Ribbon Campaign /\ Support plain text e-mail ANDURAS service solutions AG Innstrasse 71 - 94036 Passau - Germany Web: www.anduras.de - Tel: +49 (0)851-4 90 50-0 - Fax: +49 (0)851-4 90 50-55 Those who would give up essential Liberty, to purchase a little temporary Safety, deserve neither Liberty nor Safety. - Benjamin Franklin
This patch add watchdog functionality to the Winbond 83793 chipset driver.
drivers/hwmon/w83793.c +463 -6
@@ -3,6 +3,10 @@ Copyright (C) 2006 Winbond Electronics Corp. Yuan Mu Rudolf Marek <[email protected]> + Copyright (C) 2009 Sven Anders <[email protected]>, ANDURAS AG. + Watchdog driver part + (Based partially on fschmd driver, + Copyright 2007-2008 by Hans de Goede) 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
@@ -35,10 +39,20 @@#include <linux/hwmon-sysfs.h> #include <linux/err.h> #include <linux/mutex.h> +#include <linux/fs.h> +#include <linux/watchdog.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/kref.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +/* Default values */ +#define WATCHDOG_TIMEOUT 2/* 2 minute default timeout */ /* Addresses to scan */ static const unsigned short normal_i2c[] = {0x2c ,0x2d ,0x2e ,0x2f , -I2C_CLIENT_END }; +I2C_CLIENT_END };/* Insmod parameters */ I2C_CLIENT_INSMOD_1 (w83793);
@@ -52,6 +66,18 @@ static int reset;module_param (reset, bool,0 );MODULE_PARM_DESC (reset,"Set to 1 to reset chip, not recommended" ); +static int timeout =WATCHDOG_TIMEOUT ;/* in minutes */ +module_param (timeout, int,0 ); +MODULE_PARM_DESC (timeout, + "Watchdog timeout in minutes. 2<= timeout <=255 (default=" + __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); + +static int nowayout =WATCHDOG_NOWAYOUT ; +module_param (nowayout, int,0 ); +MODULE_PARM_DESC (nowayout, + "Watchdog cannot be stopped once started (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); +/* Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved as ID, Bank Select registers
@@ -73,6 +99,11 @@ MODULE_PARM_DESC(reset, "Set to 1 to res#define W83793_REG_VID_LATCHB 0x08#define W83793_REG_VID_CTRL 0x59 +#define W83793_REG_WDT_LOCK 0x01 +#define W83793_REG_WDT_ENABLE 0x02 +#define W83793_REG_WDT_STATUS 0x03 +#define W83793_REG_WDT_TIMEOUT 0x04 +static u16 W83793_REG_TEMP_MODE [2 ] = {0x5e ,0x5f };#define TEMP_READ 0
@@ -224,8 +255,36 @@ struct w83793_data {u8 tolerance[3 ];/* Temp tolerance(Smart Fan I/II) */ u8 sf2_pwm[6 ][7 ];/* Smart FanII: Fan duty cycle */ u8 sf2_temp[6 ][7 ];/* Smart FanII: Temp level point */ + +/* watchdog */ +struct i2c_client *client; +struct mutex watchdog_lock; +struct list_head list;/* member of the watchdog_data_list */ +struct kref kref; +struct miscdevice watchdog_miscdev; +unsigned long watchdog_is_open; +char watchdog_expect_close; +char watchdog_name[10 ];/* must be unique to avoid sysfs conflict */ +unsigned int watchdog_caused_reboot; }; +/* Somewhat ugly :( global data pointer list with all devices, so that +we can find our device data as when using misc_register. There is no +other method to get to one's device data from the open file-op and +for usage in the reboot notifier callback. */ +static LIST_HEAD (watchdog_data_list); + +/* Note this lock not only protect list access, but also data.kref access */ +static DEFINE_MUTEX (watchdog_data_mutex); + +/* Release our data struct when we're detached from the i2c client *and* all +references to our watchdog device are released */ +static void w83793_release_resources (struct kref *ref) +{ + struct w83793_data *data = container_of(ref, struct w83793_data, kref); +kfree (data); +} +static u8 w83793_read_value (struct i2c_client *client,u16 reg);static int w83793_write_value (struct i2c_client *client,u16 reg,u8 value); static int w83793_probe(struct i2c_client *client,
@@ -1064,14 +1123,336 @@ static void w83793_init_client(struct i2/* Start monitoring */ w83793_write_value (client,W83793_REG_CONFIG ,w83793_read_value (client,W83793_REG_CONFIG ) |0x01 ); +} + +/* +* Watchdog routines +*/ + +static int watchdog_set_timeout (struct w83793_data *data,int timeout) +{ +int ret, stimeout; + + stimeout =DIV_ROUND_UP (timeout,60 ); + +if (stimeout >255 ) +return -EINVAL ; +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , stimeout); + + ret = stimeout *60 ; + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_get_timeout (struct w83793_data *data) +{ +int gtimeout; + +mutex_lock (&data->watchdog_lock); +if (!data->client) +return -ENODEV ; + +/* Get Timeout value (in Minutes) */ + gtimeout =w83793_read_value (data->client,W83793_REG_WDT_TIMEOUT ) *60 ; + +mutex_unlock (&data->watchdog_lock); + +return gtimeout; } +static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_enable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set initial timeout */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , timeout); + +/* Enable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0x55 ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_disable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Disable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0xAA ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_open (struct inode *inode,struct file *filp) +{ +struct w83793_data *pos, *data =NULL ; + +/* We get called from drivers/char/misc.c with misc_mtx hold, and we +call misc_register() from w83793_probe() with watchdog_data_mutex +hold, as misc_register() takes the misc_mtx lock, this is a possible +deadlock, so we use mutex_trylock here. */ +if (!mutex_trylock (&watchdog_data_mutex)) +return -ERESTARTSYS ; +list_for_each_entry (pos, &watchdog_data_list, list) { +if (pos->watchdog_miscdev.minor ==iminor (inode)) { + data = pos; +break ; + } + } + +/* Note we can never not have found data, so we don't check for this */ +kref_get (&data->kref); +mutex_unlock (&watchdog_data_mutex); + +if (test_and_set_bit (0 , &data->watchdog_is_open)) +return -EBUSY ; + +/* Enable Soft Watchdog */ +watchdog_enable (data); + +/* Store pointer to data into filp's private data */ + filp->private_data = data; + +return nonseekable_open (inode, filp); +} + +static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 , &data->watchdog_is_open); + +return 0 ; +} + +static ssize_t watchdog_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offset) +{ +size_t ret; +struct w83793_data *data = filp->private_data; + +if (count) { +if (!nowayout) { +size_t i; + +/* Clear it in case it was set with a previous write */ + data->watchdog_expect_close =0 ; + +for (i =0 ; i != count; i++) { +char c; +if (get_user (c, buf + i)) +return -EFAULT ; +if (c =='V' ) + data->watchdog_expect_close =1 ; + } + } + ret =watchdog_trigger (data); +if (ret <0 ) +return ret; + } +return count; +} + +static int watchdog_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +static struct watchdog_info ident = { + .options =WDIOF_KEEPALIVEPING | +WDIOF_SETTIMEOUT | +WDIOF_CARDRESET , + .identity ="w83793 watchdog" + }; + +int val, ret =0 ; +struct w83793_data *data = filp->private_data; + +switch (cmd) { +case WDIOC_GETSUPPORT : +if (!nowayout) + ident.options |=WDIOF_MAGICCLOSE ; +if (copy_to_user ((void __user *)arg, &ident,sizeof (ident))) + ret = -EFAULT ; +break ; + +case WDIOC_GETSTATUS : + val = data->watchdog_caused_reboot ?WDIOF_CARDRESET :0 ; + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_GETBOOTSTATUS : + ret =put_user (0 , (int __user *)arg); +break ; + +case WDIOC_KEEPALIVE : + ret =watchdog_trigger (data); +break ; + +case WDIOC_GETTIMEOUT : + val =watchdog_get_timeout (data); + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_SETTIMEOUT : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + ret =watchdog_set_timeout (data, val); +if (ret >0 ) + ret =put_user (ret, (int __user *)arg); +break ; + +case WDIOC_SETOPTIONS : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + +if (val &WDIOS_DISABLECARD ) + ret =watchdog_disable (data); +else if (val &WDIOS_ENABLECARD ) + ret =watchdog_enable (data); +else + ret = -EINVAL ; + +break ; +default : + ret = -ENOTTY ; + } + +return ret; +} + +static const struct file_operations watchdog_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .open = watchdog_open, + .release = watchdog_close, + .write = watchdog_write, + .ioctl = watchdog_ioctl, +}; + +/* +* Notifier for system down +*/ + +static int watchdog_notify_sys (struct notifier_block *this,unsigned long code, +void *unused) +{ +struct w83793_data *data =NULL ; + +if (code ==SYS_DOWN || code ==SYS_HALT ) { + +/* Disable each registered watchdog */ +mutex_lock (&watchdog_data_mutex); +list_for_each_entry (data, &watchdog_data_list, list) { +if (data->watchdog_miscdev.minor) +watchdog_disable (data); + } +mutex_unlock (&watchdog_data_mutex); + } + +return NOTIFY_DONE ; +} + +/* +* The WDT needs to learn about soft shutdowns in order to +* turn the timebomb registers off. +*/ + +static struct notifier_block watchdog_notifier = { + .notifier_call = watchdog_notify_sys, +}; + +/* +* Init / remove routines +*/ +static int w83793_remove (struct i2c_client *client) {struct w83793_data *data =i2c_get_clientdata (client);struct device *dev = &client->dev; -int i; +int i, tmp; + +/* Unregister the watchdog (if registered) */ +if (data->watchdog_miscdev.minor) { +misc_deregister (&data->watchdog_miscdev); + +if (data->watchdog_is_open) { +dev_warn (&client->dev, +"i2c client detached with watchdog open! " +"Stopping watchdog.\n" ); +watchdog_disable (data); + } + +mutex_lock (&watchdog_data_mutex); +list_del (&data->list); +mutex_unlock (&watchdog_data_mutex); + +/* Tell the watchdog code the client is gone */ +mutex_lock (&data->watchdog_lock); + data->client =NULL ; +mutex_unlock (&data->watchdog_lock); + } + +/* Reset Configuration Register to Disable Watch Dog Registers */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp & ~0x04 ); + +unregister_reboot_notifier (&watchdog_notifier);hwmon_device_unregister (data->hwmon_dev);
@@ -1100,7 +1481,9 @@ static int w83793_remove(struct i2c_clieif (data->lm75[1 ] !=NULL )i2c_unregister_device (data->lm75[1 ]); -kfree (data); +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex);return 0 ; }
@@ -1168,9 +1551,8 @@ static int w83793_detect(struct i2c_cliestruct i2c_adapter *adapter = client->adapter;unsigned short address = client->addr; -if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA )) { +if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA ))return -ENODEV ; - } bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );
@@ -1221,6 +1603,7 @@ static int w83793_probe(struct i2c_clien const struct i2c_device_id *id) {struct device *dev = &client->dev; +const int watchdog_minors[] = {WATCHDOG_MINOR ,212 ,213 ,214 ,215 };struct w83793_data *data;int i, tmp, val, err;int files_fan =ARRAY_SIZE (w83793_left_fan) /7 ;
@@ -1236,6 +1619,14 @@ static int w83793_probe(struct i2c_clieni2c_set_clientdata (client, data); data->bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );mutex_init (&data->update_lock); +mutex_init (&data->watchdog_lock); +INIT_LIST_HEAD (&data->list); +kref_init (&data->kref); + +/* Store client pointer in our data struct for watchdog usage +(where the client is found through a data ptr instead of the +otherway around) */ + data->client = client; err =w83793_detect_subclients (client);if (err)
@@ -1398,8 +1789,74 @@ static int w83793_probe(struct i2c_clien goto exit_remove; } +/* Watchdog initialization */ + +/* Register boot notifier */ + err =register_reboot_notifier (&watchdog_notifier); +if (err !=0 ) { +dev_err (&client->dev, +"cannot register reboot notifier (err=%d)\n" , err); + goto exit_devunreg; + } + +/* Enable Watchdog registers. +Set Configuration Register to Enable Watch Dog Registers +(Bit 2) = XXXX, X1XX. */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp |0x04 ); + +/* Check, if last reboot was caused by watchdog */ + data->watchdog_caused_reboot = +w83793_read_value (data->client,W83793_REG_WDT_STATUS ) &0x01 ; + +/* Disable Soft Watchdog during initialiation */ +watchdog_disable (data); + +/* We take the data_mutex lock early so that watchdog_open() cannot +run when misc_register() has completed, but we've not yet added +our data to the watchdog_data_list (and set the default timeout) */ +mutex_lock (&watchdog_data_mutex); +for (i =0 ; i <ARRAY_SIZE (watchdog_minors); i++) { +/* Register our watchdog part */ +snprintf (data->watchdog_name,sizeof (data->watchdog_name), +"watchdog%c" , (i ==0 ) ?'\0' : ('0' + i)); + data->watchdog_miscdev.name = data->watchdog_name; + data->watchdog_miscdev.fops = &watchdog_fops; + data->watchdog_miscdev.minor = watchdog_minors[i]; + + err =misc_register (&data->watchdog_miscdev); +if (err == -EBUSY ) +continue ; +if (err) { + data->watchdog_miscdev.minor =0 ; +dev_err (&client->dev, +"Registering watchdog chardev: %d\n" , err); +break ; + } + +list_add (&data->list, &watchdog_data_list); + +dev_info (&client->dev, +"Registered watchdog chardev major 10, minor: %d\n" , + watchdog_minors[i]); +break ; + } +if (i ==ARRAY_SIZE (watchdog_minors)) { + data->watchdog_miscdev.minor =0 ; +dev_warn (&client->dev,"Couldn't register watchdog chardev " +"(due to no free minor)\n" ); + } + +mutex_unlock (&watchdog_data_mutex); +return 0 ; +/* Unregister hwmon device */ + +exit_devunreg: + +hwmon_device_unregister (data->hwmon_dev); +/* Unregister sysfs hooks */ exit_remove:
@@ -1646,7 +2103,7 @@ static void __exit sensors_w83793_exit(vi2c_del_driver (&w83793_driver); } -MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Rudolf Marek, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" );
drivers/hwmon/Kconfig +2 -1
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VID help If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
begin:vcard
fn:Sven Anders
n:Anders;Sven
org:ANDURAS AG;Research and Development adr;quoted-printable:;;Innstra=C3=9Fe 71;Passau;Bavaria;94036;Germany email;internet:[email protected]
title:Dipl. Inf.
tel;work:++49 (0)851 / 490 50 -0
tel;fax:++49 (0)851 / 590 50 - 55
x-mozilla-html:FALSE
url:http://www.anduras.de
version:2.1
end:vcard
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Hello!
Thanks for you last comments on the code. Now after the holidays, I found time to write you an answer and sent you an updated patch as well.
Quoted 4 lines
Quoted 2 lines
The timeout here is an global variable, so it's already done here.
Erm, no.
Quoted 9 lines
The
watchdog_set_timeout()function currently writes the timeout passed in to the chip, but that will only change the timeout now, and not for future triggers. The way the ioctl should work is that the timeout between 2 triggers (before the system resets) should be changed, so the value written bywatchdog_trigger()should be changed. And since this driver can support multiple ic's (unlikely this ever happens but still) the timeout should be stored in thew83793_datastruct so that it can be changed per device. The module parameter can then be used to initialize the per device timeout when the device is probed.
Ok, I thought I already implemented the assignment but I really missed it. But you're correct, the value should be implemented in the data struct. I've done it in the current patch.
Quoted 20 lines
Quoted 10 lines
Quoted 6 lines
In "static int
watchdog_close(struct inode *inode, struct file *filp)" you are missing:mutex_lock(&watchdog_data_mutex); kref_put(&data->kref, w83793_release_resources); mutex_unlock(&watchdog_data_mutex);I'm not sure if you're right. Closing the watchdog did not remove the module nor does it disable it configurability.
But maybe I misunderstood something here.Well I'm sure I'm right :) (please don't take this wrong and please
keep asking questions).The problem with the free-ing of the per device data struct is that there are 2 ways to get to it:
1) Through the hwmon interface
2) Through the watchdog device
Quoted 7 lines
Now the following can happen:
1) Driver attaches to w83793 i2c device
2) app opens/dev/watchdog
3) Driver detaches from w83793 i2c device
(for example because the i2c master module
gets unloaded)
Is it really possible to unload the i2c master module without unloading any dependend module first? I thought this isn't possible...
Quoted 15 lines
Now before your changes 3) Would remove the hwmon interface (and thus the only path to the per device data) and then the per device data would be freed.
However now, someone can still have a reference to the per device data (the app which has
/dev/watchdogopen). This is why we now use reference counting for the per device data struct (this is what the kref stuff does). So we start by initializing the kref inprobe()which puts its counter at 1, then the watchdog open function increases the counter (thekref_get) to 2. Then when the driver detaches, thew83793_remove()function decreases the counter (thekref_put) to 1, this does not callw83793_release_resources, as that will only get called when the kref hits 0.
Quoted 5 lines
Now when:
4) The app closes/dev/watchdogThe close function should call
kref_puttoo, so that the counter will hit 0 and the data struct gets free-ed.
Ok, I think I now understand this.
Quoted 10 lines
Notes:
1) that the
misc_deregister()call inw83793_remove()only removes the/dev/watchdognode, and does not close any open filehandles already pointing to the watchdog (closing of filehandles is up to the application not the kernel).2) that this (the i2c client being detached while
/dev/watchdogis still open), is the reason for thedata->clientcheck in all watchdog functions which actually read/write the chip.
I assume the already running watchdog app can still access the opened file even if the /dev/watchdog node does not exist anymore. So this should be a problem.
There is one small problem left:
If the watchdog_open() functions failes with EBUSY, we must not increase the counter.
Ok. This was my first encounter with the i2c framework. Until now I was only using direct hardware access, which was easier because anything was coded (and called!) in only one module source file.
Thanks for your explantations!
Quoted 7 lines
Quoted 2 lines
On the other hand, I think you are missing the 'reboot notifier' in your fschmd driver code.
The fsc chips are all part of Fujitsu Siemens Computers, iow the manufacturer of the motherboard == the manufacturer of the watchdog. As such the watchdog always gets initialized by the BIOS, so there is no reason to disable it before shutdown / reboot.
But you will need it, to prevent the watchdog to reboot the machine, if the shutdown sequence needs more time to shutdown than the watchdog is set to.
Consider the following szenario:
1) Watchdog timeout is set to 1 Minute.
2) Watchdog helper tool resets the watchdog timer every 30 seconds.
3) User executes "shutdown" binary.
4) Watchdog timer is currently at 31 seconds and the watchdog helper tool is stopped first.
5) Watchdog timer has now about 30 seconds left.
6) Heavy loaded database needs much time to write it's caches or perform any other tasks during shutdown. For instance it will need about 2 minutes.
7) After 30 seconds the hardware watchdog kicks in and reboots the machine leaving the database in an inconsistent state.
Please notify me, if I need to make some more changes or if you sent the patch upstream.
Regards
Sven Anders
Signature · 9 lines
Sven Anders <[email protected]> () Ascii Ribbon Campaign /\ Support plain text e-mail ANDURAS service solutions AG Innstraße 71 - 94036 Passau - Germany Web: www.anduras.de - Tel: +49 (0)851-4 90 50-0 - Fax: +49 (0)851-4 90 50-55 Rechtsform: Aktiengesellschaft - Sitz: Passau - Amtsgericht Passau HRB 6032 Mitglieder des Vorstands: Sven Anders, Marcus Junker Vorsitzender des Aufsichtsrats: Mark Peters
This patch add watchdog functionality to the Winbond 83793 chipset driver.
drivers/hwmon/w83793.c +484 -8
@@ -3,6 +3,10 @@ Copyright (C) 2006 Winbond Electronics Corp. Yuan Mu Rudolf Marek <[email protected]> + Copyright (C) 2009-2010 Sven Anders <[email protected]>, ANDURAS AG. + Watchdog driver part + (Based partially on fschmd driver, + Copyright 2007-2008 by Hans de Goede) 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
@@ -35,10 +39,20 @@#include <linux/hwmon-sysfs.h> #include <linux/err.h> #include <linux/mutex.h> +#include <linux/fs.h> +#include <linux/watchdog.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/kref.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +/* Default values */ +#define WATCHDOG_TIMEOUT 2/* 2 minute default timeout */ /* Addresses to scan */ static const unsigned short normal_i2c[] = {0x2c ,0x2d ,0x2e ,0x2f , -I2C_CLIENT_END }; +I2C_CLIENT_END };/* Insmod parameters */ I2C_CLIENT_INSMOD_1 (w83793);
@@ -52,6 +66,18 @@module_param (reset, bool,0 );MODULE_PARM_DESC (reset,"Set to 1 to reset chip, not recommended" ); +static int timeout =WATCHDOG_TIMEOUT ;/* default timeout in minutes */ +module_param (timeout, int,0 ); +MODULE_PARM_DESC (timeout, + "Watchdog timeout in minutes. 2<= timeout <=255 (default=" + __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); + +static int nowayout =WATCHDOG_NOWAYOUT ; +module_param (nowayout, int,0 ); +MODULE_PARM_DESC (nowayout, + "Watchdog cannot be stopped once started (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); +/* Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved as ID, Bank Select registers
@@ -73,6 +99,11 @@#define W83793_REG_VID_LATCHB 0x08#define W83793_REG_VID_CTRL 0x59 +#define W83793_REG_WDT_LOCK 0x01 +#define W83793_REG_WDT_ENABLE 0x02 +#define W83793_REG_WDT_STATUS 0x03 +#define W83793_REG_WDT_TIMEOUT 0x04 +static u16 W83793_REG_TEMP_MODE [2 ] = {0x5e ,0x5f };#define TEMP_READ 0
@@ -224,8 +255,37 @@u8 tolerance[3 ];/* Temp tolerance(Smart Fan I/II) */ u8 sf2_pwm[6 ][7 ];/* Smart FanII: Fan duty cycle */ u8 sf2_temp[6 ][7 ];/* Smart FanII: Temp level point */ + +/* watchdog */ +struct i2c_client *client; +struct mutex watchdog_lock; +struct list_head list;/* member of the watchdog_data_list */ +struct kref kref; +struct miscdevice watchdog_miscdev; +unsigned long watchdog_is_open; +char watchdog_expect_close; +char watchdog_name[10 ];/* must be unique to avoid sysfs conflict */ +unsigned int watchdog_caused_reboot; +int watchdog_timeout; }; +/* Somewhat ugly :( global data pointer list with all devices, so that +we can find our device data as when using misc_register. There is no +other method to get to one's device data from the open file-op and +for usage in the reboot notifier callback. */ +static LIST_HEAD (watchdog_data_list); + +/* Note this lock not only protect list access, but also data.kref access */ +static DEFINE_MUTEX (watchdog_data_mutex); + +/* Release our data struct when we're detached from the i2c client *and* all +references to our watchdog device are released */ +static void w83793_release_resources (struct kref *ref) +{ + struct w83793_data *data = container_of(ref, struct w83793_data, kref); +kfree (data); +} +static u8 w83793_read_value (struct i2c_client *client,u16 reg);static int w83793_write_value (struct i2c_client *client,u16 reg,u8 value); static int w83793_probe(struct i2c_client *client,
@@ -1064,14 +1124,349 @@/* Start monitoring */ w83793_write_value (client,W83793_REG_CONFIG ,w83793_read_value (client,W83793_REG_CONFIG ) |0x01 ); +} + +/* +* Watchdog routines +*/ + +static int watchdog_set_timeout (struct w83793_data *data,int timeout) +{ +int ret, stimeout; + + stimeout =DIV_ROUND_UP (timeout,60 ); + +if (stimeout >255 ) +return -EINVAL ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , stimeout); + + ret = stimeout *60 ; + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_get_timeout (struct w83793_data *data) +{ +int gtimeout; + +mutex_lock (&data->watchdog_lock); +if (!data->client) +return -ENODEV ; + +/* Get Timeout value (in Minutes) */ + gtimeout =w83793_read_value (data->client,W83793_REG_WDT_TIMEOUT ) *60 ; + +mutex_unlock (&data->watchdog_lock); + +return gtimeout; +} + +static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , + data->watchdog_timeout); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_enable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set initial timeout */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , + data->watchdog_timeout); + +/* Enable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0x55 ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_disable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Disable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0xAA ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_open (struct inode *inode,struct file *filp) +{ +struct w83793_data *pos, *data =NULL ; + +/* We get called from drivers/char/misc.c with misc_mtx hold, and we +call misc_register() from w83793_probe() with watchdog_data_mutex +hold, as misc_register() takes the misc_mtx lock, this is a possible +deadlock, so we use mutex_trylock here. */ +if (!mutex_trylock (&watchdog_data_mutex)) +return -ERESTARTSYS ; +list_for_each_entry (pos, &watchdog_data_list, list) { +if (pos->watchdog_miscdev.minor ==iminor (inode)) { + data = pos; +break ; + } + } + +/* Check, if device is already open and do not increase +data ref counter in this case... */ +if (test_and_set_bit (0 , &data->watchdog_is_open)) { +mutex_unlock (&watchdog_data_mutex); +return -EBUSY ; + } + +/* Increase data reference counter. +Note we can never not have found data, so we don't check for this */ +kref_get (&data->kref); +mutex_unlock (&watchdog_data_mutex); + +/* Enable Soft Watchdog */ +watchdog_enable (data); + +/* Store pointer to data into filp's private data */ + filp->private_data = data; + +return nonseekable_open (inode, filp); } +static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 , &data->watchdog_is_open); + +/* Decrease data reference counter */ +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex); + +return 0 ; +} + +static ssize_t watchdog_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offset) +{ +size_t ret; +struct w83793_data *data = filp->private_data; + +if (count) { +if (!nowayout) { +size_t i; + +/* Clear it in case it was set with a previous write */ + data->watchdog_expect_close =0 ; + +for (i =0 ; i != count; i++) { +char c; +if (get_user (c, buf + i)) +return -EFAULT ; +if (c =='V' ) + data->watchdog_expect_close =1 ; + } + } + ret =watchdog_trigger (data); +if (ret <0 ) +return ret; + } +return count; +} + +static int watchdog_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +static struct watchdog_info ident = { + .options =WDIOF_KEEPALIVEPING | +WDIOF_SETTIMEOUT | +WDIOF_CARDRESET , + .identity ="w83793 watchdog" + }; + +int val, ret =0 ; +struct w83793_data *data = filp->private_data; + +switch (cmd) { +case WDIOC_GETSUPPORT : +if (!nowayout) + ident.options |=WDIOF_MAGICCLOSE ; +if (copy_to_user ((void __user *)arg, &ident,sizeof (ident))) + ret = -EFAULT ; +break ; + +case WDIOC_GETSTATUS : + val = data->watchdog_caused_reboot ?WDIOF_CARDRESET :0 ; + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_GETBOOTSTATUS : + ret =put_user (0 , (int __user *)arg); +break ; + +case WDIOC_KEEPALIVE : + ret =watchdog_trigger (data); +break ; + +case WDIOC_GETTIMEOUT : + val =watchdog_get_timeout (data); + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_SETTIMEOUT : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + data->watchdog_timeout = val; + ret =watchdog_set_timeout (data, val); +if (ret >0 ) + ret =put_user (ret, (int __user *)arg); +break ; + +case WDIOC_SETOPTIONS : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + +if (val &WDIOS_DISABLECARD ) + ret =watchdog_disable (data); +else if (val &WDIOS_ENABLECARD ) + ret =watchdog_enable (data); +else + ret = -EINVAL ; + +break ; +default : + ret = -ENOTTY ; + } + +return ret; +} + +static const struct file_operations watchdog_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .open = watchdog_open, + .release = watchdog_close, + .write = watchdog_write, + .ioctl = watchdog_ioctl, +}; + +/* +* Notifier for system down +*/ + +static int watchdog_notify_sys (struct notifier_block *this,unsigned long code, +void *unused) +{ +struct w83793_data *data =NULL ; + +if (code ==SYS_DOWN || code ==SYS_HALT ) { + +/* Disable each registered watchdog */ +mutex_lock (&watchdog_data_mutex); +list_for_each_entry (data, &watchdog_data_list, list) { +if (data->watchdog_miscdev.minor) +watchdog_disable (data); + } +mutex_unlock (&watchdog_data_mutex); + } + +return NOTIFY_DONE ; +} + +/* +* The WDT needs to learn about soft shutdowns in order to +* turn the timebomb registers off. +*/ + +static struct notifier_block watchdog_notifier = { + .notifier_call = watchdog_notify_sys, +}; + +/* +* Init / remove routines +*/ +static int w83793_remove (struct i2c_client *client) {struct w83793_data *data =i2c_get_clientdata (client);struct device *dev = &client->dev; -int i; +int i, tmp; + +/* Unregister the watchdog (if registered) */ +if (data->watchdog_miscdev.minor) { +misc_deregister (&data->watchdog_miscdev); + +if (data->watchdog_is_open) { +dev_warn (&client->dev, +"i2c client detached with watchdog open! " +"Stopping watchdog.\n" ); +watchdog_disable (data); + } + +mutex_lock (&watchdog_data_mutex); +list_del (&data->list); +mutex_unlock (&watchdog_data_mutex); + +/* Tell the watchdog code the client is gone */ +mutex_lock (&data->watchdog_lock); + data->client =NULL ; +mutex_unlock (&data->watchdog_lock); + } + +/* Reset Configuration Register to Disable Watch Dog Registers */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp & ~0x04 ); + +unregister_reboot_notifier (&watchdog_notifier);hwmon_device_unregister (data->hwmon_dev);
@@ -1100,7 +1495,10 @@if (data->lm75[1 ] !=NULL )i2c_unregister_device (data->lm75[1 ]); -kfree (data); +/* Decrease data reference counter */ +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex);return 0 ; }
@@ -1168,9 +1566,8 @@struct i2c_adapter *adapter = client->adapter;unsigned short address = client->addr; -if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA )) { +if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA ))return -ENODEV ; - } bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );
@@ -1221,6 +1618,7 @@ const struct i2c_device_id *id) {struct device *dev = &client->dev; +const int watchdog_minors[] = {WATCHDOG_MINOR ,212 ,213 ,214 ,215 };struct w83793_data *data;int i, tmp, val, err;int files_fan =ARRAY_SIZE (w83793_left_fan) /7 ;
@@ -1236,6 +1634,14 @@i2c_set_clientdata (client, data); data->bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );mutex_init (&data->update_lock); +mutex_init (&data->watchdog_lock); +INIT_LIST_HEAD (&data->list); +kref_init (&data->kref); + +/* Store client pointer in our data struct for watchdog usage +(where the client is found through a data ptr instead of the +otherway around) */ + data->client = client; err =w83793_detect_subclients (client);if (err)
@@ -1398,8 +1804,77 @@ goto exit_remove; } +/* Watchdog initialization */ + +/* Register boot notifier */ + err =register_reboot_notifier (&watchdog_notifier); +if (err !=0 ) { +dev_err (&client->dev, +"cannot register reboot notifier (err=%d)\n" , err); + goto exit_devunreg; + } + +/* Enable Watchdog registers. +Set Configuration Register to Enable Watch Dog Registers +(Bit 2) = XXXX, X1XX. */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp |0x04 ); + +/* Set the default watchdog timeout */ + data->watchdog_timeout = timeout; + +/* Check, if last reboot was caused by watchdog */ + data->watchdog_caused_reboot = +w83793_read_value (data->client,W83793_REG_WDT_STATUS ) &0x01 ; + +/* Disable Soft Watchdog during initialiation */ +watchdog_disable (data); + +/* We take the data_mutex lock early so that watchdog_open() cannot +run when misc_register() has completed, but we've not yet added +our data to the watchdog_data_list (and set the default timeout) */ +mutex_lock (&watchdog_data_mutex); +for (i =0 ; i <ARRAY_SIZE (watchdog_minors); i++) { +/* Register our watchdog part */ +snprintf (data->watchdog_name,sizeof (data->watchdog_name), +"watchdog%c" , (i ==0 ) ?'\0' : ('0' + i)); + data->watchdog_miscdev.name = data->watchdog_name; + data->watchdog_miscdev.fops = &watchdog_fops; + data->watchdog_miscdev.minor = watchdog_minors[i]; + + err =misc_register (&data->watchdog_miscdev); +if (err == -EBUSY ) +continue ; +if (err) { + data->watchdog_miscdev.minor =0 ; +dev_err (&client->dev, +"Registering watchdog chardev: %d\n" , err); +break ; + } + +list_add (&data->list, &watchdog_data_list); + +dev_info (&client->dev, +"Registered watchdog chardev major 10, minor: %d\n" , + watchdog_minors[i]); +break ; + } +if (i ==ARRAY_SIZE (watchdog_minors)) { + data->watchdog_miscdev.minor =0 ; +dev_warn (&client->dev,"Couldn't register watchdog chardev " +"(due to no free minor)\n" ); + } + +mutex_unlock (&watchdog_data_mutex); +return 0 ; +/* Unregister hwmon device */ + +exit_devunreg: + +hwmon_device_unregister (data->hwmon_dev); +/* Unregister sysfs hooks */ exit_remove:
@@ -1646,7 +2121,7 @@i2c_del_driver (&w83793_driver); } -MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" ); --- linux-2.6.29.6/drivers/hwmon/Kconfig 2009-07-03 01:41:20.000000000 +0200 +++ linux-2.6.29.6.watchdog/drivers/hwmon/Kconfig 2009-12-04 12:13:08.000000000 +0100
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VIDhelp If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
begin:vcard
fn:Sven Anders
n:Anders;Sven
org:ANDURAS AG;Research and Development adr;quoted-printable:;;Innstra=C3=9Fe 71;Passau;Bavaria;94036;Germany email;internet:[email protected]
title:Dipl. Inf.
tel;work:++49 (0)851 / 490 50 -0
tel;fax:++49 (0)851 / 590 50 - 55
x-mozilla-html:FALSE
url:http://www.anduras.de
version:2.1
end:vcard
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Hi,
Quoted 4 lines · Sven Anders
Hello!
Thanks for you last comments on the code. Now after the holidays, I found time to write you an answer and sent you an updated patch as well.
You're welcome, thanks for being persistent, so this can get into the kernel eventually.
<snip>
Quoted 11 lines
Quoted 7 lines
Now the following can happen:
1) Driver attaches to w83793 i2c device
2) app opens/dev/watchdog
3) Driver detaches from w83793 i2c device
(for example because the i2c master module
gets unloaded)Is it really possible to unload the i2c master module without unloading any dependend module first? I thought this isn't possible...
Yes, their is no dependency relation between the modules, only a driver binding, when the i2c master goes away, the i2c driver will simply have its detach function called.
Quoted 4 lines
I assume the already running watchdog app can still access the opened file even if the
/dev/watchdognode does not exist anymore. So this should be a problem.
Correct, this is exactly why the ref counting is there, and why the watchdog functions called through the device check if client has not disappeared.
Quoted 5 lines
There is one small problem left:
If the
watchdog_open()functions failes with EBUSY, we must not increase the counter.
Oh, good catch that bug is present in the fschmd.c code too. Note that the way you've fixed this with an unlock in the error path is sort of frowned up on. It is correct, but we usually try to keep locks and unlocks in balanced pairs, so that it is easy to check for missing unlocks. See the patch I've done to fix this same issue for fschmd (attached).
Quoted 8 lines
Quoted 7 lines
Quoted 2 lines
On the other hand, I think you are missing the 'reboot notifier' in your fschmd driver code.
The fsc chips are all part of Fujitsu Siemens Computers, iow the manufacturer of the motherboard == the manufacturer of the watchdog. As such the watchdog always gets initialized by the BIOS, so there is no reason to disable it before shutdown / reboot.
Quoted 8 lines
But you will need it, to prevent the watchdog to reboot the machine, if the shutdown sequence needs more time to shutdown than the watchdog is set to.
Consider the following szenario:
1) Watchdog timeout is set to 1 Minute.
2) Watchdog helper tool resets the watchdog timer every 30 seconds.
3) User executes "shutdown" binary.
Shutdown is pure userspaces, and does not do much more then signal init to switch runlevel.
Quoted 5 lines
4) Watchdog timer is currently at 31 seconds and the watchdog helper tool is stopped first.
5) Watchdog timer has now about 30 seconds left.
6) Heavy loaded database needs much time to write it's caches or perform any other tasks during shutdown. For instance it will need about 2 minutes.
That would be an initscripts bug then, the watchdog tool should be stopped as one of the last tasks in the runlevel.
Quoted 3 lines
7) After 30 seconds the hardware watchdog kicks in and reboots the machine leaving the database in an inconsistent state.
This will happen even with a reboot/halt notifier. That won't get called until the kernel actually is going to do the reboot (as in make the BIOS call to do a soft reset).
Quoted 3 lines
Please notify me, if I need to make some more changes or if you sent the patch upstream.
Well, I don't have any path for sending patches directly upstream, Jean Delvare usually does that for hwmon tree patches. I can ack this though, telling Jean it has been reviewed by me and I don't see any more issues.
But atm I still do see a few issues:
watchdog_get_timeout():
Should return data->watchdog_timeout, not the register value, as that register actually counts down the minutes till it will reboot. IOW it does not contain the counter reload value (which is what we want to return), but it contains the actual counter.
+ case WDIOC_SETTIMEOUT:
+ if (get_user(val, (int __user *)arg)) {
+ ret = -EFAULT;
+ break;
+ } + data->watchdog_timeout = val; + ret = watchdog_set_timeout(data, val); + if (ret > 0)
+ ret = put_user(ret, (int __user *)arg);
+ break;
Note that here you store val, which is in seconds! into data->watchdog_timeout, and then on the next trigger you will write that to W83793_REG_WDT_TIMEOUT, resulting in a timeout of as many minutes as the user asked seconds. I think it would best to remove the setting of data->watchdog_timeout here (esp as no rounding and bounds checking has been done yet), and set it to stimeout in watchdog_set_timeout() after all error checking has been done there.
And I think Jean might fall over the balanced lock unlock thingie, Jean ?
Regards,
Hans
hwmon fschmd: Fix a memleak on multiple opens of /dev/watchdog
When /dev/watchdog gets opened a second time we return -EBUSY, but we already have got a kref then, so we end up leaking our data struct. This patch fixes this.
drivers/hwmon/fschmd.c renamed from drivers/hwmon/fschmd.c~ +5 -2
@@ -767,6 +767,7 @@ leave:static int watchdog_open (struct inode *inode,struct file *filp) {struct fschmd_data *pos, *data =NULL ; +int watchdog_is_open;/* We get called from drivers/char/misc.c with misc_mtx hold, and we call misc_register() from fschmd_probe() with watchdog_data_mutex
@@ -781,10 +782,12 @@ static int watchdog_open(struct inode *i } }/* Note we can never not have found data, so we don't check for this */ -kref_get (&data->kref); + watchdog_is_open =test_and_set_bit (0 , &data->watchdog_is_open); +if (!watchdog_is_open) +kref_get (&data->kref);mutex_unlock (&watchdog_data_mutex); -if (test_and_set_bit (0 , &data->watchdog_is_open)) +if (watchdog_is_open)return -EBUSY ;/* Start the watchdog */
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Hi Hans,
Quoted 11 lines · Hans de Goede
Quoted 4 lines · Sven Anders
There is one small problem left:
If the
watchdog_open()functions failes with EBUSY, we must not increase the counter.Oh, good catch that bug is present in the
fschmd.ccode too. Note that the way you've fixed this with an unlock in the error path is sort of frowned up on. It is correct, but we usually try to keep locks and unlocks in balanced pairs, so that it is easy to check for missing unlocks. See the patch I've done to fix this same issue for fschmd (attached).
I'll go apply that patch right now.
Quoted 6 lines
Quoted 2 lines
Please notify me, if I need to make some more changes or if you sent the patch upstream.
Well, I don't have any path for sending patches directly upstream, Jean Delvare usually does that for hwmon tree patches. I can ack this though, telling Jean it has been reviewed by me and I don't see any more issues.
Yes, if the patch is acked by Hans, I'll pick it.
Quoted 2 lines
(...)
And I think Jean might fall over the balanced lock unlock thingie, Jean ?
I don't care either way. As long as the code is correct, I'm fine.
Signature · 6 lines
Jean Delvare _______________________________________________ lm-sensors mailing list [email protected] http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Quoted 6 lines · Hans de Goede
Quoted 3 lines
Thanks for you last comments on the code. Now after the holidays, I found time to write you an answer and sent you an updated patch as well.
You're welcome, thanks for being persistent, so this can get into the kernel eventually.
No problem. I learned to be persistent.
One of my last patches, which went upstream, took over an year to get accepted. If I only had more time... ;-)
Quoted 6 lines
Quoted 2 lines
Is it really possible to unload the i2c master module without unloading any dependend module first? I thought this isn't possible...
Yes, their is no dependency relation between the modules, only a driver binding, when the i2c master goes away, the i2c driver will simply have its detach function called.
Thanks for the explanation.
Quoted 6 lines
Correct, this is exactly why the ref counting is there, and why the watchdog functions called through the device check if client has not disappeared.
Quoted 2 lines
There is one small problem left:
Quoted 8 lines
Quoted 2 lines
If the
watchdog_open()functions failes with EBUSY, we must not increase the counter.Oh, good catch that bug is present in the
fschmd.ccode too. Note that the way you've fixed this with an unlock in the error path is sort of frowned up on. It is correct, but we usually try to keep locks and unlocks in balanced pairs, so that it is easy to check for missing unlocks. See the patch I've done to fix this same issue for fschmd (attached).
Ok, I reordered the code. New patch is attached.
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 2 lines
On the other hand, I think you are missing the 'reboot notifier' in your fschmd driver code.
The fsc chips are all part of Fujitsu Siemens Computers, iow the manufacturer of the motherboard == the manufacturer of the watchdog. As such the watchdog always gets initialized by the BIOS, so there is no reason to disable it before shutdown / reboot.
Ok, thanks for that clarification too. Because I cannot be certain, that die BIOS resets the watchdog for my chipset, I will need the notifier (at least) for my code.
Quoted 6 lines
Well, I don't have any path for sending patches directly upstream, Jean Delvare usually does that for hwmon tree patches. I can ack this though, telling Jean it has been reviewed by me and I don't see any more issues.
But atm I still do see a few issues:
Quoted 7 lines
watchdog_get_timeout():
Should returndata->watchdog_timeout, not the register value, as that register
actually counts down the minutes till it will reboot. IOW it does not contain
the counter reload value (which is what we want to return), but it contains the actual counter.
Ok. Corrected. What I'm still missing are the specs or a "how-to write a watchdog driver" docs...
Quoted 7 lines
Note that in "case
WDIOC_SETTIMEOUT:..." you store val, which is in seconds! into "data->watchdog_timeout", and then on the next trigger you will write that toW83793_REG_WDT_TIMEOUT, resulting in a timeout of as many minutes as the user asked seconds. I think it would best to remove the setting ofdata->watchdog_timeouthere (esp as no rounding and bounds checking has been done yet), and set it to stimeout inwatchdog_set_timeout()after all error checking has been done there.
You're correct. I did my last correction not thoroughly enough. My fault. It's corrected now...
I'll hope this will be the last one...
Regards
Sven
Signature · 9 lines
Sven Anders <[email protected]> () Ascii Ribbon Campaign /\ Support plain text e-mail ANDURAS service solutions AG Innstraße 71 - 94036 Passau - Germany Web: www.anduras.de - Tel: +49 (0)851-4 90 50-0 - Fax: +49 (0)851-4 90 50-55 Rechtsform: Aktiengesellschaft - Sitz: Passau - Amtsgericht Passau HRB 6032 Mitglieder des Vorstands: Sven Anders, Marcus Junker Vorsitzender des Aufsichtsrats: Mark Peters
This patch add watchdog functionality to the Winbond 83793 chipset driver.
drivers/hwmon/w83793.c +481 -6
@@ -3,6 +3,10 @@ Copyright (C) 2006 Winbond Electronics Corp. Yuan Mu Rudolf Marek <[email protected]> + Copyright (C) 2009-2010 Sven Anders <[email protected]>, ANDURAS AG. + Watchdog driver part + (Based partially on fschmd driver, + Copyright 2007-2008 by Hans de Goede) 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
@@ -35,10 +39,20 @@#include <linux/hwmon-sysfs.h> #include <linux/err.h> #include <linux/mutex.h> +#include <linux/fs.h> +#include <linux/watchdog.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/kref.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +/* Default values */ +#define WATCHDOG_TIMEOUT 2/* 2 minute default timeout */ /* Addresses to scan */ static const unsigned short normal_i2c[] = {0x2c ,0x2d ,0x2e ,0x2f , -I2C_CLIENT_END }; +I2C_CLIENT_END };/* Insmod parameters */ I2C_CLIENT_INSMOD_1 (w83793);
@@ -52,6 +66,18 @@module_param (reset, bool,0 );MODULE_PARM_DESC (reset,"Set to 1 to reset chip, not recommended" ); +static int timeout =WATCHDOG_TIMEOUT ;/* default timeout in minutes */ +module_param (timeout, int,0 ); +MODULE_PARM_DESC (timeout, + "Watchdog timeout in minutes. 2<= timeout <=255 (default=" + __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); + +static int nowayout =WATCHDOG_NOWAYOUT ; +module_param (nowayout, int,0 ); +MODULE_PARM_DESC (nowayout, + "Watchdog cannot be stopped once started (default=" + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); +/* Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved as ID, Bank Select registers
@@ -73,6 +99,11 @@#define W83793_REG_VID_LATCHB 0x08#define W83793_REG_VID_CTRL 0x59 +#define W83793_REG_WDT_LOCK 0x01 +#define W83793_REG_WDT_ENABLE 0x02 +#define W83793_REG_WDT_STATUS 0x03 +#define W83793_REG_WDT_TIMEOUT 0x04 +static u16 W83793_REG_TEMP_MODE [2 ] = {0x5e ,0x5f };#define TEMP_READ 0
@@ -224,8 +255,37 @@u8 tolerance[3 ];/* Temp tolerance(Smart Fan I/II) */ u8 sf2_pwm[6 ][7 ];/* Smart FanII: Fan duty cycle */ u8 sf2_temp[6 ][7 ];/* Smart FanII: Temp level point */ + +/* watchdog */ +struct i2c_client *client; +struct mutex watchdog_lock; +struct list_head list;/* member of the watchdog_data_list */ +struct kref kref; +struct miscdevice watchdog_miscdev; +unsigned long watchdog_is_open; +char watchdog_expect_close; +char watchdog_name[10 ];/* must be unique to avoid sysfs conflict */ +unsigned int watchdog_caused_reboot; +int watchdog_timeout;/* watchdog timeout in minutes */ }; +/* Somewhat ugly :( global data pointer list with all devices, so that +we can find our device data as when using misc_register. There is no +other method to get to one's device data from the open file-op and +for usage in the reboot notifier callback. */ +static LIST_HEAD (watchdog_data_list); + +/* Note this lock not only protect list access, but also data.kref access */ +static DEFINE_MUTEX (watchdog_data_mutex); + +/* Release our data struct when we're detached from the i2c client *and* all +references to our watchdog device are released */ +static void w83793_release_resources (struct kref *ref) +{ + struct w83793_data *data = container_of(ref, struct w83793_data, kref); +kfree (data); +} +static u8 w83793_read_value (struct i2c_client *client,u16 reg);static int w83793_write_value (struct i2c_client *client,u16 reg,u8 value); static int w83793_probe(struct i2c_client *client,
@@ -1064,14 +1124,349 @@/* Start monitoring */ w83793_write_value (client,W83793_REG_CONFIG ,w83793_read_value (client,W83793_REG_CONFIG ) |0x01 ); +} + +/* +* Watchdog routines +*/ + +static int watchdog_set_timeout (struct w83793_data *data,int timeout) +{ +int ret, mtimeout; + + mtimeout =DIV_ROUND_UP (timeout,60 ); + +if (mtimeout >255 ) +return -EINVAL ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + + data->watchdog_timeout = mtimeout; + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , + data->watchdog_timeout); + + ret = mtimeout *60 ; + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_get_timeout (struct w83793_data *data) +{ +int timeout; + +mutex_lock (&data->watchdog_lock); + timeout = data->watchdog_timeout *60 ; +mutex_unlock (&data->watchdog_lock); + +return timeout; +} + +static int watchdog_trigger (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set Timeout value (in Minutes) */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , + data->watchdog_timeout); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_enable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Set initial timeout */ +w83793_write_value (data->client,W83793_REG_WDT_TIMEOUT , + data->watchdog_timeout); + +/* Enable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0x55 ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_disable (struct w83793_data *data) +{ +int ret =0 ; + +mutex_lock (&data->watchdog_lock); +if (!data->client) { + ret = -ENODEV ; + goto leave; + } + +/* Disable Soft Watchdog */ +w83793_write_value (data->client,W83793_REG_WDT_LOCK ,0xAA ); + +leave: +mutex_unlock (&data->watchdog_lock); +return ret; +} + +static int watchdog_open (struct inode *inode,struct file *filp) +{ +struct w83793_data *pos, *data =NULL ; +int watchdog_is_open; + +/* We get called from drivers/char/misc.c with misc_mtx hold, and we +call misc_register() from w83793_probe() with watchdog_data_mutex +hold, as misc_register() takes the misc_mtx lock, this is a possible +deadlock, so we use mutex_trylock here. */ +if (!mutex_trylock (&watchdog_data_mutex)) +return -ERESTARTSYS ; +list_for_each_entry (pos, &watchdog_data_list, list) { +if (pos->watchdog_miscdev.minor ==iminor (inode)) { + data = pos; +break ; + } + } + +/* Check, if device is already open */ + watchdog_is_open =test_and_set_bit (0 , &data->watchdog_is_open); + +/* Increase data reference counter (if not already done). +Note we can never not have found data, so we don't check for this */ +if (!watchdog_is_open) +kref_get (&data->kref); + +mutex_unlock (&watchdog_data_mutex); + +/* Check, if device is already open and possibly issue error */ +if (watchdog_is_open) +return -EBUSY ; + +/* Enable Soft Watchdog */ +watchdog_enable (data); + +/* Store pointer to data into filp's private data */ + filp->private_data = data; + +return nonseekable_open (inode, filp); +} +static int watchdog_close (struct inode *inode,struct file *filp) +{ +struct w83793_data *data = filp->private_data; + +if (data->watchdog_expect_close) { +watchdog_disable (data); + data->watchdog_expect_close =0 ; + }else { +watchdog_trigger (data); +dev_crit (&data->client->dev, +"unexpected close, not stopping watchdog!\n" ); + } + +clear_bit (0 , &data->watchdog_is_open); + +/* Decrease data reference counter */ +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex); + +return 0 ; +} + +static ssize_t watchdog_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offset) +{ +size_t ret; +struct w83793_data *data = filp->private_data; + +if (count) { +if (!nowayout) { +size_t i; + +/* Clear it in case it was set with a previous write */ + data->watchdog_expect_close =0 ; + +for (i =0 ; i != count; i++) { +char c; +if (get_user (c, buf + i)) +return -EFAULT ; +if (c =='V' ) + data->watchdog_expect_close =1 ; + } + } + ret =watchdog_trigger (data); +if (ret <0 ) +return ret; + } +return count; +} + +static int watchdog_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +static struct watchdog_info ident = { + .options =WDIOF_KEEPALIVEPING | +WDIOF_SETTIMEOUT | +WDIOF_CARDRESET , + .identity ="w83793 watchdog" + }; + +int val, ret =0 ; +struct w83793_data *data = filp->private_data; + +switch (cmd) { +case WDIOC_GETSUPPORT : +if (!nowayout) + ident.options |=WDIOF_MAGICCLOSE ; +if (copy_to_user ((void __user *)arg, &ident,sizeof (ident))) + ret = -EFAULT ; +break ; + +case WDIOC_GETSTATUS : + val = data->watchdog_caused_reboot ?WDIOF_CARDRESET :0 ; + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_GETBOOTSTATUS : + ret =put_user (0 , (int __user *)arg); +break ; + +case WDIOC_KEEPALIVE : + ret =watchdog_trigger (data); +break ; + +case WDIOC_GETTIMEOUT : + val =watchdog_get_timeout (data); + ret =put_user (val, (int __user *)arg); +break ; + +case WDIOC_SETTIMEOUT : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + ret =watchdog_set_timeout (data, val); +if (ret >0 ) + ret =put_user (ret, (int __user *)arg); +break ; + +case WDIOC_SETOPTIONS : +if (get_user (val, (int __user *)arg)) { + ret = -EFAULT ; +break ; + } + +if (val &WDIOS_DISABLECARD ) + ret =watchdog_disable (data); +else if (val &WDIOS_ENABLECARD ) + ret =watchdog_enable (data); +else + ret = -EINVAL ; + +break ; +default : + ret = -ENOTTY ; + } + +return ret; +} + +static const struct file_operations watchdog_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .open = watchdog_open, + .release = watchdog_close, + .write = watchdog_write, + .ioctl = watchdog_ioctl, +}; + +/* +* Notifier for system down +*/ + +static int watchdog_notify_sys (struct notifier_block *this,unsigned long code, +void *unused) +{ +struct w83793_data *data =NULL ; + +if (code ==SYS_DOWN || code ==SYS_HALT ) { + +/* Disable each registered watchdog */ +mutex_lock (&watchdog_data_mutex); +list_for_each_entry (data, &watchdog_data_list, list) { +if (data->watchdog_miscdev.minor) +watchdog_disable (data); + } +mutex_unlock (&watchdog_data_mutex); + } + +return NOTIFY_DONE ; } +/* +* The WDT needs to learn about soft shutdowns in order to +* turn the timebomb registers off. +*/ + +static struct notifier_block watchdog_notifier = { + .notifier_call = watchdog_notify_sys, +}; + +/* +* Init / remove routines +*/ +static int w83793_remove (struct i2c_client *client) {struct w83793_data *data =i2c_get_clientdata (client);struct device *dev = &client->dev; -int i; +int i, tmp; + +/* Unregister the watchdog (if registered) */ +if (data->watchdog_miscdev.minor) { +misc_deregister (&data->watchdog_miscdev); + +if (data->watchdog_is_open) { +dev_warn (&client->dev, +"i2c client detached with watchdog open! " +"Stopping watchdog.\n" ); +watchdog_disable (data); + } + +mutex_lock (&watchdog_data_mutex); +list_del (&data->list); +mutex_unlock (&watchdog_data_mutex); + +/* Tell the watchdog code the client is gone */ +mutex_lock (&data->watchdog_lock); + data->client =NULL ; +mutex_unlock (&data->watchdog_lock); + } + +/* Reset Configuration Register to Disable Watch Dog Registers */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp & ~0x04 ); + +unregister_reboot_notifier (&watchdog_notifier);hwmon_device_unregister (data->hwmon_dev);
@@ -1100,7 +1495,10 @@if (data->lm75[1 ] !=NULL )i2c_unregister_device (data->lm75[1 ]); -kfree (data); +/* Decrease data reference counter */ +mutex_lock (&watchdog_data_mutex); +kref_put (&data->kref, w83793_release_resources); +mutex_unlock (&watchdog_data_mutex);return 0 ; }
@@ -1168,9 +1566,8 @@struct i2c_adapter *adapter = client->adapter;unsigned short address = client->addr; -if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA )) { +if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA ))return -ENODEV ; - } bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );
@@ -1221,6 +1618,7 @@ const struct i2c_device_id *id) {struct device *dev = &client->dev; +const int watchdog_minors[] = {WATCHDOG_MINOR ,212 ,213 ,214 ,215 };struct w83793_data *data;int i, tmp, val, err;int files_fan =ARRAY_SIZE (w83793_left_fan) /7 ;
@@ -1236,6 +1634,14 @@i2c_set_clientdata (client, data); data->bank =i2c_smbus_read_byte_data (client,W83793_REG_BANKSEL );mutex_init (&data->update_lock); +mutex_init (&data->watchdog_lock); +INIT_LIST_HEAD (&data->list); +kref_init (&data->kref); + +/* Store client pointer in our data struct for watchdog usage +(where the client is found through a data ptr instead of the +otherway around) */ + data->client = client; err =w83793_detect_subclients (client);if (err)
@@ -1398,8 +1804,77 @@ goto exit_remove; } +/* Watchdog initialization */ + +/* Register boot notifier */ + err =register_reboot_notifier (&watchdog_notifier); +if (err !=0 ) { +dev_err (&client->dev, +"cannot register reboot notifier (err=%d)\n" , err); + goto exit_devunreg; + } + +/* Enable Watchdog registers. +Set Configuration Register to Enable Watch Dog Registers +(Bit 2) = XXXX, X1XX. */ + tmp =w83793_read_value (client,W83793_REG_CONFIG ); +w83793_write_value (client,W83793_REG_CONFIG , tmp |0x04 ); + +/* Set the default watchdog timeout */ + data->watchdog_timeout = timeout; + +/* Check, if last reboot was caused by watchdog */ + data->watchdog_caused_reboot = +w83793_read_value (data->client,W83793_REG_WDT_STATUS ) &0x01 ; + +/* Disable Soft Watchdog during initialiation */ +watchdog_disable (data); + +/* We take the data_mutex lock early so that watchdog_open() cannot +run when misc_register() has completed, but we've not yet added +our data to the watchdog_data_list (and set the default timeout) */ +mutex_lock (&watchdog_data_mutex); +for (i =0 ; i <ARRAY_SIZE (watchdog_minors); i++) { +/* Register our watchdog part */ +snprintf (data->watchdog_name,sizeof (data->watchdog_name), +"watchdog%c" , (i ==0 ) ?'\0' : ('0' + i)); + data->watchdog_miscdev.name = data->watchdog_name; + data->watchdog_miscdev.fops = &watchdog_fops; + data->watchdog_miscdev.minor = watchdog_minors[i]; + + err =misc_register (&data->watchdog_miscdev); +if (err == -EBUSY ) +continue ; +if (err) { + data->watchdog_miscdev.minor =0 ; +dev_err (&client->dev, +"Registering watchdog chardev: %d\n" , err); +break ; + } + +list_add (&data->list, &watchdog_data_list); + +dev_info (&client->dev, +"Registered watchdog chardev major 10, minor: %d\n" , + watchdog_minors[i]); +break ; + } +if (i ==ARRAY_SIZE (watchdog_minors)) { + data->watchdog_miscdev.minor =0 ; +dev_warn (&client->dev,"Couldn't register watchdog chardev " +"(due to no free minor)\n" ); + } + +mutex_unlock (&watchdog_data_mutex); +return 0 ; +/* Unregister hwmon device */ + +exit_devunreg: + +hwmon_device_unregister (data->hwmon_dev); +/* Unregister sysfs hooks */ exit_remove:
@@ -1646,7 +2121,7 @@i2c_del_driver (&w83793_driver); } -MODULE_AUTHOR ("Yuan Mu" ); +MODULE_AUTHOR ("Yuan Mu, Sven Anders" );MODULE_DESCRIPTION ("w83793 driver" );MODULE_LICENSE ("GPL" );
drivers/hwmon/Kconfig +2 -1
@@ -789,7 +789,8 @@ config SENSORS_W83793 select HWMON_VID help If you say yes here you get support for the Winbond W83793 - hardware monitoring chip. + hardware monitoring chip, including support for the integrated + watchdog. This driver can also be built as a module. If so, the module will be called w83793.
begin:vcard
fn:Sven Anders
n:Anders;Sven
org:ANDURAS AG;Research and Development adr;quoted-printable:;;Innstra=C3=9Fe 71;Passau;Bavaria;94036;Germany email;internet:[email protected]
title:Dipl. Inf.
tel;work:++49 (0)851 / 490 50 -0
tel;fax:++49 (0)851 / 590 50 - 55
x-mozilla-html:FALSE
url:http://www.anduras.de
version:2.1
end:vcard
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Hi,
On 01/25/2010 11:15 AM, Sven Anders wrote:
<snip>
Quoted 3 lines
You're correct. I did my last correction not thoroughly enough. My fault. It's corrected now...
I'll hope this will be the last one...
It is as far as I'm concerned. I don't see any other issues with this patch, so this latest version of the patch is:
Regards,
Hans
_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Jean Delvare
AppliedQuoted 6 lines · Hans de Goede
Hi,
On 01/25/2010 11:15 AM, Sven Anders wrote:
<snip>
Quoted 7 lines
Quoted 3 lines
You're correct. I did my last correction not thoroughly enough. My fault. It's corrected now...
I'll hope this will be the last one...It is as far as I'm concerned. I don't see any other issues with this patch, so this latest version of the patch is:
Acked-by Hans de Goede <[email protected]>
Applied, thanks.
Signature · 6 lines
Jean Delvare _______________________________________________ lm-sensors mailing list [email protected] http://lists.lm-sensors.org/mailman/listinfo/lm-sensors