Commit 19ce0a99 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://www.linux-watchdog.org/linux-watchdog 

Pull second set of watchdog updates from Wim Van Sebroeck:
 "This changeset contains following changes:
   * Add support for multiple watchdog devices.  We use dynamically
     allocated device id's for this.
   * Add locking into the generic watchdog infrastructure.
   * Add support for dynamically allocated watchdog_device structs so
     that we can deal with devices that get unbound.
   * convert following drivers to the generic watchdog framework:
     sch5627, sch5636 and sp805_wdt.
   * Add DA9052/53 PMIC watchdog support
   * Fix printk format warnings for iTCO_wdt.c"

* git://www.linux-watchdog.org/linux-watchdog:
  watchdog: iTCO_wdt.c: fix printk format warnings
  watchdog: sp805_wdt: Add clk_{un}prepare support
  watchdog: sp805_wdt: convert to watchdog core
  hwmon/sch56xx: Depend on watchdog for watchdog core functions
  watchdog: sch56xx-common: set correct bits in register()
  Watchdog: DA9052/53 PMIC watchdog support
  watchdog: sch56xx-common: Add proper ref-counting of watchdog data
  watchdog: sch56xx: Remove unnecessary checks for register changes
  watchdog: sch56xx: Use watchdog core
  watchdog: Add support for dynamically allocated watchdog_device structs
  watchdog: Add Locking support
  watchdog: watchdog_dev: Rewrite wrapper code
  watchdog: use dev_ functions
  watchdog: create all the proper device files
  watchdog: Add a flag to indicate the watchdog doesn't reboot things
  watchdog: Add multiple device support
  watchdog: watchdog_core.h: make functions extern
  watchdog: correct the name of the watchdog_core inlude file
  watchdog: Add watchdog_active() routine
  watchdog: watchdog_dev: include private header to pickup global symbol prototypes
parents 6bb340c7 4b98b32a

Documentation/watchdog/watchdog-kernel-api.txt

+42 −1
Original line number Diff line number Diff line 
The Linux WatchDog Timer Driver Core kernel API.

===============================================

Last reviewed: 16-Mar-2012

Last reviewed: 22-May-2012



Wim Van Sebroeck <wim@iguana.be>
@@ -39,6 +39,10 @@ watchdog_device structure. 
The watchdog device structure looks like this:



struct watchdog_device {

	int id;

	struct cdev cdev;

	struct device *dev;

	struct device *parent;

	const struct watchdog_info *info;

	const struct watchdog_ops *ops;

	unsigned int bootstatus;
@@ -46,10 +50,20 @@ struct watchdog_device { 
	unsigned int min_timeout;

	unsigned int max_timeout;

	void *driver_data;

	struct mutex lock;

	unsigned long status;

};



It contains following fields:

* id: set by watchdog_register_device, id 0 is special. It has both a

  /dev/watchdog0 cdev (dynamic major, minor 0) as well as the old

  /dev/watchdog miscdev. The id is set automatically when calling

  watchdog_register_device.

* cdev: cdev for the dynamic /dev/watchdog<id> device nodes. This

  field is also populated by watchdog_register_device.

* dev: device under the watchdog class (created by watchdog_register_device).

* parent: set this to the parent device (or NULL) before calling

  watchdog_register_device.

* info: a pointer to a watchdog_info structure. This structure gives some

  additional information about the watchdog timer itself. (Like it's unique name)

* ops: a pointer to the list of watchdog operations that the watchdog supports.
@@ -61,6 +75,7 @@ It contains following fields: 
* driver_data: a pointer to the drivers private data of a watchdog device.

  This data should only be accessed via the watchdog_set_drvdata and

  watchdog_get_drvdata routines.

* lock: Mutex for WatchDog Timer Driver Core internal use only.

* status: this field contains a number of status bits that give extra

  information about the status of the device (Like: is the watchdog timer

  running/active, is the nowayout bit set, is the device opened via
@@ -78,6 +93,8 @@ struct watchdog_ops { 
	unsigned int (*status)(struct watchdog_device *);

	int (*set_timeout)(struct watchdog_device *, unsigned int);

	unsigned int (*get_timeleft)(struct watchdog_device *);

	void (*ref)(struct watchdog_device *);

	void (*unref)(struct watchdog_device *);

	long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);

};
@@ -85,6 +102,21 @@ It is important that you first define the module owner of the watchdog timer 
driver's operations. This module owner will be used to lock the module when

the watchdog is active. (This to avoid a system crash when you unload the

module and /dev/watchdog is still open).



If the watchdog_device struct is dynamically allocated, just locking the module

is not enough and a driver also needs to define the ref and unref operations to

ensure the structure holding the watchdog_device does not go away.



The simplest (and usually sufficient) implementation of this is to:

1) Add a kref struct to the same structure which is holding the watchdog_device

2) Define a release callback for the kref which frees the struct holding both

3) Call kref_init on this kref *before* calling watchdog_register_device()

4) Define a ref operation calling kref_get on this kref

5) Define a unref operation calling kref_put on this kref

6) When it is time to cleanup:

 * Do not kfree() the struct holding both, the last kref_put will do this!

 * *After* calling watchdog_unregister_device() call kref_put on the kref



Some operations are mandatory and some are optional. The mandatory operations

are:

* start: this is a pointer to the routine that starts the watchdog timer
@@ -125,6 +157,10 @@ they are supported. These optional routines/operations are: 
  (Note: the WDIOF_SETTIMEOUT needs to be set in the options field of the

  watchdog's info structure).

* get_timeleft: this routines returns the time that's left before a reset.

* ref: the operation that calls kref_get on the kref of a dynamically

  allocated watchdog_device struct.

* unref: the operation that calls kref_put on the kref of a dynamically

  allocated watchdog_device struct.

* ioctl: if this routine is present then it will be called first before we do

  our own internal ioctl call handling. This routine should return -ENOIOCTLCMD

  if a command is not supported. The parameters that are passed to the ioctl
@@ -144,6 +180,11 @@ bit-operations. The status bits that are defined are: 
  (This bit should only be used by the WatchDog Timer Driver Core).

* WDOG_NO_WAY_OUT: this bit stores the nowayout setting for the watchdog.

  If this bit is set then the watchdog timer will not be able to stop.

* WDOG_UNREGISTERED: this bit gets set by the WatchDog Timer Driver Core

  after calling watchdog_unregister_device, and then checked before calling

  any watchdog_ops, so that you can be sure that no operations (other then

  unref) will get called after unregister, even if userspace still holds a

  reference to /dev/watchdog



  To set the WDOG_NO_WAY_OUT status bit (before registering your watchdog

  timer device) you can either:

Documentation/watchdog/watchdog-parameters.txt

+5 −0
Original line number Diff line number Diff line
@@ -78,6 +78,11 @@ wd0_timeout: Default watchdog0 timeout in 1/10secs 
wd1_timeout: Default watchdog1 timeout in 1/10secs

wd2_timeout: Default watchdog2 timeout in 1/10secs

-------------------------------------------------

da9052wdt:

timeout: Watchdog timeout in seconds. 2<= timeout <=131, default=2.048s

nowayout: Watchdog cannot be stopped once started

	(default=kernel config parameter)

-------------------------------------------------

davinci_wdt:

heartbeat: Watchdog heartbeat period in seconds from 1 to 600, default 60

-------------------------------------------------

drivers/hwmon/Kconfig

+4 −2
Original line number Diff line number Diff line
@@ -1036,8 +1036,9 @@ config SENSORS_SCH56XX_COMMON 


config SENSORS_SCH5627

	tristate "SMSC SCH5627"

	depends on !PPC

	depends on !PPC && WATCHDOG

	select SENSORS_SCH56XX_COMMON

	select WATCHDOG_CORE

	help

	  If you say yes here you get support for the hardware monitoring

	  features of the SMSC SCH5627 Super-I/O chip including support for
@@ -1048,8 +1049,9 @@ config SENSORS_SCH5627 


config SENSORS_SCH5636

	tristate "SMSC SCH5636"

	depends on !PPC

	depends on !PPC && WATCHDOG

	select SENSORS_SCH56XX_COMMON

	select WATCHDOG_CORE

	help

	  SMSC SCH5636 Super I/O chips include an embedded microcontroller for

	  hardware monitoring solutions, allowing motherboard manufacturers to

drivers/hwmon/sch5627.c

+1 −1
Original line number Diff line number Diff line
@@ -579,7 +579,7 @@ static int __devinit sch5627_probe(struct platform_device *pdev) 
	}



	/* Note failing to register the watchdog is not a fatal error */

	data->watchdog = sch56xx_watchdog_register(data->addr,

	data->watchdog = sch56xx_watchdog_register(&pdev->dev, data->addr,

			(build_code << 24) | (build_id << 8) | hwmon_rev,

			&data->update_lock, 1);

drivers/hwmon/sch5636.c

+1 −1
Original line number Diff line number Diff line
@@ -510,7 +510,7 @@ static int __devinit sch5636_probe(struct platform_device *pdev) 
	}



	/* Note failing to register the watchdog is not a fatal error */

	data->watchdog = sch56xx_watchdog_register(data->addr,

	data->watchdog = sch56xx_watchdog_register(&pdev->dev, data->addr,

					(revision[0] << 8) | revision[1],

					&data->update_lock, 0);

CRA Git | Maintained and supported by SUSTech CRA and CCSE