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

- reg			: Physical base address and size

Optional properties:

- clocks		: Input clock specifier. Refer to common clock

			  bindings.

- clock-frequency	: Frequency of clock in Hz

- xlnx,wdt-enable-once	: 0 - Watchdog can be restarted

			  1 - Watchdog can be enabled just once

axi-timebase-wdt@40100000 {

	clock-frequency = <50000000>;

	compatible = "xlnx,xps-timebase-wdt-1.00.a";

	clocks = <&clkc 15>;

	reg = <0x40100000 0x10000>;

	xlnx,wdt-enable-once = <0x0>;

	xlnx,wdt-interval = <0x1b>;

Required properties

- compatible 	: Must be one of: "st,stih407-lpc" "st,stih416-lpc"

				  "st,stih415-lpc" "st,stid127-lpc"

- compatible 	: Should be: "st,stih407-lpc"

- reg		: LPC registers base address + size

- interrupts    : LPC interrupt line number and associated flags

- clocks	: Clock used by LPC device (See: ../clock/clock-bindings.txt)

	const struct attribute_group **groups;

	const struct watchdog_info *info;

	const struct watchdog_ops *ops;

	const struct watchdog_governor *gov;

	unsigned int bootstatus;

	unsigned int timeout;

	unsigned int pretimeout;

	unsigned int min_timeout;

	unsigned int max_timeout;

	unsigned int min_hw_heartbeat_ms;

* 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.

* gov: a pointer to the assigned watchdog device pretimeout governor or NULL.

* timeout: the watchdog timer's timeout value (in seconds).

  This is the time after which the system will reboot if user space does

  not send a heartbeat request if WDOG_ACTIVE is set.

* pretimeout: the watchdog timer's pretimeout value (in seconds).

* min_timeout: the watchdog timer's minimum timeout value (in seconds).

  If set, the minimum configurable value for 'timeout'.

* max_timeout: the watchdog timer's maximum timeout value (in seconds),

	int (*ping)(struct watchdog_device *);

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

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

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

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

	int (*restart)(struct watchdog_device *);

	void (*ref)(struct watchdog_device *) __deprecated;

  If set_timeout is not provided but, WDIOF_SETTIMEOUT is set, the watchdog

  infrastructure updates the timeout value of the watchdog_device internally

  to the requested value.

  If the pretimeout feature is used (WDIOF_PRETIMEOUT), then set_timeout must

  also take care of checking if pretimeout is still valid and set up the timer

  accordingly. This can't be done in the core without races, so it is the

  duty of the driver.

* set_pretimeout: this routine checks and changes the pretimeout value of

  the watchdog. It is optional because not all watchdogs support pretimeout

  notification. The timeout value is not an absolute time, but the number of

  seconds before the actual timeout would happen. It returns 0 on success,

  -EINVAL for "parameter out of range" and -EIO for "could not write value to

  the watchdog". A value of 0 disables pretimeout notification.

  (Note: the WDIOF_PRETIMEOUT needs to be set in the options field of the

  watchdog's info structure).

  If the watchdog driver does not have to perform any action but setting the

  watchdog_device.pretimeout, this callback can be omitted. That means if

  set_pretimeout is not provided but WDIOF_PRETIMEOUT is set, the watchdog

  infrastructure updates the pretimeout value of the watchdog_device internally

  to the requested value.

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

* restart: this routine restarts the machine. It returns 0 on success or a

  negative errno code for failure.

* 128: default restart handler, use if no other handler is expected to be

  available, and/or if restart is sufficient to restart the entire system

* 255: highest priority, will preempt all other restart handlers

To raise a pretimeout notification, the following function should be used:

void watchdog_notify_pretimeout(struct watchdog_device *wdd)

The function can be called in the interrupt context. If watchdog pretimeout

governor framework (kbuild CONFIG_WATCHDOG_PRETIMEOUT_GOV symbol) is enabled,

an action is taken by a preconfigured pretimeout governor preassigned to

the watchdog device. If watchdog pretimeout governor framework is not

enabled, watchdog_notify_pretimeout() prints a notification message to

the kernel log buffer.

	  Most people will say N.

comment "Watchdog Pretimeout Governors"

config WATCHDOG_PRETIMEOUT_GOV

	bool "Enable watchdog pretimeout governors"

	help

	  The option allows to select watchdog pretimeout governors.

if WATCHDOG_PRETIMEOUT_GOV

choice

	prompt "Default Watchdog Pretimeout Governor"

	default WATCHDOG_PRETIMEOUT_DEFAULT_GOV_PANIC

	help

	  This option selects a default watchdog pretimeout governor.

	  The governor takes its action, if a watchdog is capable

	  to report a pretimeout event.

config WATCHDOG_PRETIMEOUT_DEFAULT_GOV_NOOP

	bool "noop"

	select WATCHDOG_PRETIMEOUT_GOV_NOOP

	help

	  Use noop watchdog pretimeout governor by default. If noop

	  governor is selected by a user, write a short message to

	  the kernel log buffer and don't do any system changes.

config WATCHDOG_PRETIMEOUT_DEFAULT_GOV_PANIC

	bool "panic"

	select WATCHDOG_PRETIMEOUT_GOV_PANIC

	help

	  Use panic watchdog pretimeout governor by default, if

	  a watchdog pretimeout event happens, consider that

	  a watchdog feeder is dead and reboot is unavoidable.

endchoice

config WATCHDOG_PRETIMEOUT_GOV_NOOP

	tristate "Noop watchdog pretimeout governor"

	help

	  Noop watchdog pretimeout governor, only an informational

	  message is added to kernel log buffer.

config WATCHDOG_PRETIMEOUT_GOV_PANIC

	tristate "Panic watchdog pretimeout governor"

	help

	  Panic watchdog pretimeout governor, on watchdog pretimeout

	  event put the kernel into panic.

endif # WATCHDOG_PRETIMEOUT_GOV

endif # WATCHDOG

#

# The WatchDog Timer Driver Core.

watchdog-objs	+= watchdog_core.o watchdog_dev.o

obj-$(CONFIG_WATCHDOG_CORE)	+= watchdog.o

watchdog-objs	+= watchdog_core.o watchdog_dev.o

watchdog-$(CONFIG_WATCHDOG_PRETIMEOUT_GOV)	+= watchdog_pretimeout.o

obj-$(CONFIG_WATCHDOG_PRETIMEOUT_GOV_NOOP)	+= pretimeout_noop.o

obj-$(CONFIG_WATCHDOG_PRETIMEOUT_GOV_PANIC)	+= pretimeout_panic.o

# Only one watchdog can succeed. We probe the ISA/PCI/USB based

# watchdog-cards first, then the architecture specific watchdog

# drivers and then the architecture independent "softdog" driver.