[RFT] Prototype of new watchdog

[Oliver Neukum]

---
 drivers/watchdog/Kconfig         |  16 ++
 drivers/watchdog/Makefile        |   1 +
 drivers/watchdog/pcwd_usb_nova.c | 425 +++++++++++++++++++++++++++++++
 3 files changed, 442 insertions(+)
 create mode 100644 drivers/watchdog/pcwd_usb_nova.c

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index f22138709bf5..f7999fb7caaa 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -2210,6 +2210,22 @@ config USBPCWATCHDOG
 
 	  Most people will say N.
 
+config USBPCWATCHDOGNOVA
+        tristate "Berkshire Products USB-PC Watchdog (new driver)"
+        depends on USB
+        help
+          This is the driver for the Berkshire Products USB-PC Watchdog card.
+          This card simply watches your kernel to make sure it doesn't freeze,
+          and if it does, it reboots your computer after a certain amount of
+          time. The card can also monitor the internal temperature of the PC.
+          More info is available at <http://www.berkprod.com/usb_pc_watchdog.htm>.
+        
+          To compile this driver as a module, choose M here: the
+          module will be called pcwd_usb_nova.
+          
+          Most people will say N.
+
+
 config KEEMBAY_WATCHDOG
 	tristate "Intel Keem Bay SoC non-secure watchdog"
 	depends on ARCH_KEEMBAY || (ARM64 && COMPILE_TEST)
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index b4c4ccf2d703..8364e0184424 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -33,6 +33,7 @@ obj-$(CONFIG_WDTPCI) += wdt_pci.o
 
 # USB-based Watchdog Cards
 obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
+obj-$(CONFIG_USBPCWATCHDOGNOVA) += pcwd_usb_nova.o
 
 # ALPHA Architecture
 
diff --git a/drivers/watchdog/pcwd_usb_nova.c b/drivers/watchdog/pcwd_usb_nova.c
new file mode 100644
index 000000000000..8a92ba8776ae
--- /dev/null
+++ b/drivers/watchdog/pcwd_usb_nova.c
@@ -0,0 +1,425 @@
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/usb.h>
+#include <linux/mutex.h>
+
+#include <linux/watchdog.h>
+#include <linux/hid.h>
+
+#include <asm/byteorder.h>
+#include <asm/unaligned.h>
+
+#define MIN_BUF_LENGTH 8
+
+/* stuff taken from the old driver */
+
+/* according to documentation max. time to process a command for the USB
+ * watchdog card is 100 or 200 ms, so we give it 250 ms to do it's job */
+#define USB_COMMAND_TIMEOUT	250
+
+/* Watchdog's internal commands */
+#define CMD_READ_TEMP			0x02    /* Read Temperature;
+							Re-trigger Watchdog */
+#define CMD_TRIGGER			CMD_READ_TEMP
+#define CMD_GET_STATUS			0x04	/* Get Status Information */
+#define CMD_GET_FIRMWARE_VERSION	0x08	/* Get Firmware Version */
+#define CMD_GET_DIP_SWITCH_SETTINGS	0x0c	/* Get Dip Switch Settings */
+#define CMD_READ_WATCHDOG_TIMEOUT	0x18	/* Read Current Watchdog Time */
+#define CMD_WRITE_WATCHDOG_TIMEOUT	0x19	/* Write Current WatchdogTime */
+#define CMD_ENABLE_WATCHDOG		0x30	/* Enable / Disable Watchdog */
+#define CMD_DISABLE_WATCHDOG		CMD_ENABLE_WATCHDOG
+
+/* Watchdog's Dip Switch heartbeat values */
+static const int heartbeat_tbl[] = {
+	5,	/* OFF-OFF-OFF	=  5 Sec  */
+	10,	/* OFF-OFF-ON	= 10 Sec  */
+	30,	/* OFF-ON-OFF	= 30 Sec  */
+	60,	/* OFF-ON-ON	=  1 Min  */
+	300,	/* ON-OFF-OFF	=  5 Min  */
+	600,	/* ON-OFF-ON	= 10 Min  */
+	1800,	/* ON-ON-OFF	= 30 Min  */
+	3600,	/* ON-ON-ON	=  1 hour */
+};
+
+/* The vendor and product id's for the USB-PC Watchdog card */
+#define USB_PCWD_VENDOR_ID	0x0c98
+#define USB_PCWD_PRODUCT_ID	0x1140
+
+/*
+ * --- data structures ---
+ */
+
+struct pcwd_nova_command {
+	u8 command;
+	__be16 value;
+	u8 reserved0;
+	u8 reserved1;
+	u8 reserved2;
+}__attribute__ ((__packed__));
+
+struct pcwd_nova_wdt {
+	struct watchdog_device wdd;
+	struct mutex command_excl;
+	struct completion response_available;
+	int command_result;
+	struct usb_interface *interface;
+	int intr_size;
+	struct pcwd_nova_command *intr_buffer;
+	struct urb *intr_urb;
+	struct pcwd_nova_command *command_buffer;
+};
+
+static bool nowayout = WATCHDOG_NOWAYOUT;
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+		__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static const struct watchdog_info pcwd_nova_info;
+/*
+ * --- helpers ---
+ */
+
+static bool ack_valid(int response)
+{
+	/* the upper byte can be garbage */
+	return (response & 0xff) != 0x00;
+}
+
+static int send_command(struct pcwd_nova_wdt *pwd, u8 command, u16 value)
+{
+	int result = -EIO;
+	int transmitted;
+	long left;
+	struct pcwd_nova_command *cmd = pwd->command_buffer;
+	struct usb_device *dev = interface_to_usbdev(pwd->interface);
+
+	mutex_lock(&pwd->command_excl);
+
+	cmd->command = command;
+	cmd->value = cpu_to_be16(value);
+	cmd->reserved0 = cmd->reserved1 = cmd->reserved2 = 0;
+
+	reinit_completion(&pwd->response_available);
+	transmitted = usb_control_msg(
+			dev,
+			usb_sndctrlpipe(dev, 0),
+			HID_REQ_SET_REPORT,
+			HID_DT_REPORT,
+			0x0200,
+			pwd->interface->cur_altsetting->desc.bInterfaceNumber,
+			cmd,
+			sizeof(struct pcwd_nova_command),
+			USB_CTRL_SET_TIMEOUT);
+	if (transmitted != sizeof(struct pcwd_nova_command)) 
+		goto error;
+
+	left = wait_for_completion_timeout(&pwd->response_available,
+			msecs_to_jiffies(USB_COMMAND_TIMEOUT));
+	if (!left)
+		goto error;
+	result = pwd->command_result;
+error:
+	mutex_unlock(&pwd->command_excl);
+
+	return result;
+}
+
+static int usb_pcwd_stop(struct pcwd_nova_wdt *pwd)
+{
+	int retval;
+
+	retval = send_command(pwd, CMD_DISABLE_WATCHDOG, 0xA5C3);
+	if (retval < 0)
+		goto error;
+
+	if (!ack_valid(retval))
+		retval = -EIO;
+	else
+		retval = 0;
+error:
+	return retval;
+}
+
+static int usb_pcwd_start(struct pcwd_nova_wdt *pwd)
+{
+	int retval;
+
+	retval = send_command(pwd, CMD_ENABLE_WATCHDOG, 0x0000);
+	if (retval < 0)
+		goto error;
+
+	if (!ack_valid(retval))
+		retval = -EIO;
+	else
+		retval = 0;
+
+error:
+	return retval;
+}
+
+static int usb_pcwd_set_heartbeat(struct pcwd_nova_wdt *pwd, u16 hb)
+{
+	int retval;
+
+	retval = send_command(pwd, CMD_WRITE_WATCHDOG_TIMEOUT, hb);
+
+	return retval;
+}
+
+static int usb_pcwd_keepalive(struct pcwd_nova_wdt *pwd)
+{
+	int retval;
+
+	retval = send_command(pwd, CMD_TRIGGER, 0x00);
+
+	return retval;
+}
+
+static int usb_pcwd_get_timeleft(struct pcwd_nova_wdt *pwd)
+{
+	int retval;
+
+	retval = send_command(pwd, CMD_READ_WATCHDOG_TIMEOUT, 0x00);
+
+	return retval < 0 ? -EIO : retval;
+}
+
+static int evaluate_device(struct pcwd_nova_wdt *pwd)
+{
+	int rv;
+	u16 heartbeat;
+
+	rv = usb_pcwd_stop(pwd);
+	if (rv < 0)
+		goto error;
+
+	/* errors intentionally ignored */
+	send_command(pwd, CMD_GET_FIRMWARE_VERSION, 0);
+
+	rv = send_command(pwd, CMD_GET_DIP_SWITCH_SETTINGS, 0);
+	if (rv < 0)
+		goto error;
+
+	heartbeat = heartbeat_tbl[(rv & 0x07)];
+	rv = usb_pcwd_set_heartbeat(pwd, heartbeat);
+	if (rv < 0)
+		/* retry with default */
+		rv = usb_pcwd_set_heartbeat(pwd, 0);
+
+error:
+	return rv;
+}
+
+/*
+ * --- watchdog operations ---
+ */
+
+static int pcwd_nova_pm_start(struct watchdog_device *wdd)
+{
+	struct pcwd_nova_wdt *pwd = (struct pcwd_nova_wdt *)wdd;
+	int r;
+
+	r = usb_pcwd_start(pwd);
+
+	return r;
+}
+
+static int pcwd_nova_pm_stop(struct watchdog_device *wdd)
+{
+	struct pcwd_nova_wdt *pwd = (struct pcwd_nova_wdt *)wdd;
+	int r;
+
+	r = usb_pcwd_stop(pwd);
+
+	return r;
+}
+
+static int pcwd_nova_pm_ping(struct watchdog_device *wdd)
+{
+	struct pcwd_nova_wdt *pwd = (struct pcwd_nova_wdt *)wdd;
+	int r;
+
+	r = usb_pcwd_keepalive(pwd);
+
+	return r;
+}	
+
+static int pcwd_nova_pm_set_heartbeat(struct watchdog_device *wdd,
+		unsigned int new_timeout)
+{
+	struct pcwd_nova_wdt *pwd = (struct pcwd_nova_wdt *)wdd;
+	int r;
+
+	r = usb_pcwd_set_heartbeat(pwd, new_timeout);
+
+	return r;
+}
+
+static unsigned int pcwd_nova_pm_get_timeleft(struct watchdog_device *wdd)
+{
+	struct pcwd_nova_wdt *pwd = (struct pcwd_nova_wdt *)wdd;
+	int r;
+
+	r = usb_pcwd_get_timeleft(pwd);
+
+	return r;
+}
+/*
+ * --- usb operations ---
+ */
+
+static void pwd_intr_callback(struct urb *u)
+{
+	struct pcwd_nova_wdt *pwd = u->context;
+	struct pcwd_nova_command *result = pwd->intr_buffer;
+	int status = u->status;
+
+	switch (status) {
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		goto death;
+	case 0:
+		/* get the payload */
+		pwd->command_result = be16_to_cpu(result->value);
+		break;
+	default:
+		pwd->command_result = -EIO;
+		goto resubmit;
+	}
+
+	complete(&pwd->response_available);
+resubmit:
+	usb_submit_urb(u, GFP_ATOMIC);
+	return;
+death:
+	pwd->command_result = -EIO;
+	complete(&pwd->response_available);
+}
+
+static int usb_pcwd_probe(struct usb_interface *interface,
+		const struct usb_device_id *id)
+{
+	struct pcwd_nova_wdt *pwd;
+	struct usb_endpoint_descriptor *int_in;
+	int r = -EINVAL;
+	int rv, size;
+
+	rv = usb_find_common_endpoints(interface->cur_altsetting,
+		       	NULL, NULL, &int_in, NULL);
+	if (rv < 0)
+		goto err_abort;
+
+	/* keeping allocations together for error handling */
+	r = -ENOMEM;
+	pwd = kzalloc(sizeof(struct pcwd_nova_wdt), GFP_KERNEL);
+	if (!pwd)
+		goto err_abort;
+	pwd->interface = interface;
+	size = max(usb_endpoint_maxp(int_in), MIN_BUF_LENGTH);
+	pwd->intr_buffer = kmalloc(size, GFP_KERNEL);
+	if (!pwd->intr_buffer)
+		goto err_free_pwd;
+	pwd->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
+	if (!pwd->intr_urb)
+		goto err_free_buffer;
+	pwd->command_buffer = kmalloc(sizeof(struct pcwd_nova_command), GFP_KERNEL);
+	if (!pwd->command_buffer)
+		goto err_free_urb;
+
+	mutex_init(&pwd->command_excl);
+	init_completion(&pwd->response_available);
+	usb_fill_int_urb(pwd->intr_urb,
+			interface_to_usbdev(interface),
+			usb_rcvintpipe(interface_to_usbdev(interface),
+				int_in->bEndpointAddress),
+			pwd->intr_buffer,
+			size,
+			pwd_intr_callback,
+			pwd,
+			int_in->bInterval);
+
+	/*
+	 * we need to start IO now, because we need the device settings
+	 * that means even an unused device takes up bandwidth
+	 */
+	r = usb_submit_urb(pwd->intr_urb, GFP_KERNEL);
+	if (r < 0)
+		goto err_free_all_buffers;
+	r = evaluate_device(pwd);
+	if (r < 0)
+		goto err_free_all_buffers;
+
+	usb_set_intfdata(interface, pwd);
+
+	pwd->wdd.info = &pcwd_nova_info;
+	watchdog_set_drvdata(&pwd->wdd, pwd);
+	watchdog_set_nowayout(&pwd->wdd, nowayout);
+	watchdog_stop_on_reboot(&pwd->wdd);
+	watchdog_stop_on_unregister(&pwd->wdd);
+
+	r = watchdog_register_device(&pwd->wdd);
+	if (r < 0)
+		goto err_kill_urb;
+
+	return 0;
+
+err_kill_urb:
+	usb_kill_urb(pwd->intr_urb);
+	usb_set_intfdata(interface, NULL);
+err_free_all_buffers:
+	kfree(pwd->command_buffer);
+err_free_urb:
+	usb_free_urb(pwd->intr_urb);
+err_free_buffer:
+	kfree(pwd->intr_buffer);
+err_free_pwd:
+	kfree(pwd);
+err_abort:
+	return r;
+}
+
+static void usb_pcwd_disconnect(struct usb_interface *interface)
+{
+	struct pcwd_nova_wdt *pwd;
+
+	pwd = usb_get_intfdata(interface);
+	usb_kill_urb(pwd->intr_urb);
+	complete(&pwd->response_available);
+	watchdog_unregister_device(&pwd->wdd);
+	usb_free_urb(pwd->intr_urb);
+	kfree(pwd->intr_buffer);
+	kfree(pwd->command_buffer);
+	kfree(pwd);
+}
+
+static const struct watchdog_info pcwd_nova_info = {
+	.options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE |
+		WDIOF_SETTIMEOUT,
+	.identity = "PC watchdog new driver",
+};
+
+static const struct watchdog_ops pcwd_nova_ops = {
+        .owner = THIS_MODULE,
+        .start = pcwd_nova_pm_start,
+        .stop = pcwd_nova_pm_stop,
+	.ping = pcwd_nova_pm_ping,
+	.set_timeout = pcwd_nova_pm_set_heartbeat,
+	.get_timeleft = pcwd_nova_pm_get_timeleft,
+};
+
+static const struct usb_device_id usb_pcwd_table[] = {
+        { USB_DEVICE(USB_PCWD_VENDOR_ID, USB_PCWD_PRODUCT_ID) },
+	{ },				/* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, usb_pcwd_table);
+
+static struct usb_driver usb_pcwd_drivernova = {
+	"New API PCWD",
+	.probe =	usb_pcwd_probe,
+	.disconnect =	usb_pcwd_disconnect,
+	.id_table =	usb_pcwd_table,
+};
+
+module_usb_driver(usb_pcwd_drivernova);
+MODULE_LICENSE("GPL");
-- 
2.41.0