On Thu, 2016-03-10 at 02:29 +0000, Alexey Klimov wrote: > This patch creates new driver that supports StreamLabs usb watchdog > device. This device plugs into 9-pin usb header and connects to > reset pin and reset button on common PC. Hi, a few remarks. Regards Oliver > > USB commands used to communicate with device were reverse > engineered using usbmon. > > Signed-off-by: Alexey Klimov <klimov.linux@xxxxxxxxx> > --- > drivers/watchdog/Kconfig | 15 ++ > drivers/watchdog/Makefile | 1 + > drivers/watchdog/streamlabs_wdt.c | 370 ++++++++++++++++++++++++++++++++++++++ > 3 files changed, 386 insertions(+) > create mode 100644 drivers/watchdog/streamlabs_wdt.c > > diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig > index 80825a7..95d8f72 100644 > --- a/drivers/watchdog/Kconfig > +++ b/drivers/watchdog/Kconfig > @@ -1705,4 +1705,19 @@ config USBPCWATCHDOG > > Most people will say N. > > +config USB_STREAMLABS_WATCHDOG > + tristate "StreamLabs USB watchdog driver" > + depends on USB > + ---help--- > + This is the driver for the USB Watchdog dongle from StreamLabs. > + If you correctly connect reset pins to motherboard Reset pin and > + to Reset button then this device will simply watch your kernel to make > + sure it doesn't freeze, and if it does, it reboots your computer > + after a certain amount of time. > + > + > + To compile this driver as a module, choose M here: the > + module will be called streamlabs_wdt. > + > + Most people will say N. Say yes or M if you want to use such usb device. > endif # WATCHDOG > diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile > index f6a6a38..d54fd31 100644 > --- a/drivers/watchdog/Makefile > +++ b/drivers/watchdog/Makefile > @@ -25,6 +25,7 @@ obj-$(CONFIG_WDTPCI) += wdt_pci.o > > # USB-based Watchdog Cards > obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o > +obj-$(CONFIG_USB_STREAMLABS_WATCHDOG) += streamlabs_wdt.o > > # ALPHA Architecture > > diff --git a/drivers/watchdog/streamlabs_wdt.c b/drivers/watchdog/streamlabs_wdt.c > new file mode 100644 > index 0000000..031dbc35 > --- /dev/null > +++ b/drivers/watchdog/streamlabs_wdt.c > @@ -0,0 +1,370 @@ > +/* > + * StreamLabs USB Watchdog driver > + * > + * Copyright (c) 2016 Alexey Klimov <klimov.linux@xxxxxxxxx> > + * > + * This program is free software; you may redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include <linux/errno.h> > +#include <linux/kernel.h> > +#include <linux/module.h> > +#include <linux/mutex.h> > +#include <linux/slab.h> > +#include <linux/usb.h> > +#include <linux/watchdog.h> > + > +/* > + * USB Watchdog device from Streamlabs > + * http://www.stream-labs.com/products/devices/watchdog/ > + * > + * USB commands have been reverse engineered using usbmon. > + */ > + > +#define DRIVER_AUTHOR "Alexey Klimov <klimov.linux@xxxxxxxxx>" > +#define DRIVER_DESC "StreamLabs USB watchdog driver" > +#define DRIVER_NAME "usb_streamlabs_wdt" > + > +MODULE_AUTHOR(DRIVER_AUTHOR); > +MODULE_DESCRIPTION(DRIVER_DESC); > +MODULE_LICENSE("GPL"); > + > +#define USB_STREAMLABS_WATCHDOG_VENDOR 0x13c0 > +#define USB_STREAMLABS_WATCHDOG_PRODUCT 0x0011 > + > +/* one buffer is used for communication, however transmitted message is only > + * 32 bytes long */ > +#define BUFFER_TRANSFER_LENGTH 32 > +#define BUFFER_LENGTH 64 > +#define USB_TIMEOUT 350 > + > +#define STREAMLABS_CMD_START 0 > +#define STREAMLABS_CMD_STOP 1 > + > +#define STREAMLABS_WDT_MIN_TIMEOUT 1 > +#define STREAMLABS_WDT_MAX_TIMEOUT 46 > + > +struct streamlabs_wdt { > + struct watchdog_device wdt_dev; > + struct usb_device *usbdev; You can always deduce the device from the interface. There's no need to store it. > + struct usb_interface *intf; > + > + struct kref kref; > + struct mutex lock; > + u8 *buffer; > +}; > + > +static bool nowayout = WATCHDOG_NOWAYOUT; > + > +static int usb_streamlabs_wdt_validate_response(u8 *buf) > +{ > + /* If watchdog device understood the command it will acknowledge > + * with values 1,2,3,4 at indexes 10, 11, 12, 13 in response message. > + */ > + if (buf[10] != 1 || buf[11] != 2 || buf[12] != 3 || buf[13] != 4) > + return -EINVAL; > + > + return 0; > +} > + > +static int usb_streamlabs_wdt_command(struct watchdog_device *wdt_dev, int cmd) > +{ > + struct streamlabs_wdt *streamlabs_wdt = watchdog_get_drvdata(wdt_dev); > + int retval; > + int size; > + unsigned long timeout_msec; > + int retry_counter = 10; /* how many times to re-send stop cmd */ > + > + mutex_lock(&streamlabs_wdt->lock); > + > + timeout_msec = wdt_dev->timeout * MSEC_PER_SEC; > + > + /* Prepare message that will be sent to device. > + * This buffer is allocated by kzalloc(). Only initialize required > + * fields. > + */ > + if (cmd == STREAMLABS_CMD_START) { > + streamlabs_wdt->buffer[0] = 0xcc; > + streamlabs_wdt->buffer[1] = 0xaa; > + } else { /* assume stop command if it's not start */ > + streamlabs_wdt->buffer[0] = 0xff; > + streamlabs_wdt->buffer[1] = 0xbb; > + } > + > + streamlabs_wdt->buffer[3] = 0x80; > + > + streamlabs_wdt->buffer[6] = (timeout_msec & 0xff) << 8; > + streamlabs_wdt->buffer[7] = (timeout_msec & 0xff00) >> 8; We have macros for such conversions. Please use them. > +retry: Why rewrite only a part of the buffer this way? > + streamlabs_wdt->buffer[10] = 0x00; > + streamlabs_wdt->buffer[11] = 0x00; > + streamlabs_wdt->buffer[12] = 0x00; > + streamlabs_wdt->buffer[13] = 0x00; > + > + /* send command to watchdog */ > + retval = usb_interrupt_msg(streamlabs_wdt->usbdev, > + usb_sndintpipe(streamlabs_wdt->usbdev, 0x02), > + streamlabs_wdt->buffer, BUFFER_TRANSFER_LENGTH, > + &size, USB_TIMEOUT); > + > + if (retval || size != BUFFER_TRANSFER_LENGTH) { > + dev_err(&streamlabs_wdt->intf->dev, > + "error %i when submitting interrupt msg\n", retval); > + retval = -EIO; > + goto out; > + } > + > + /* and read response from watchdog */ > + retval = usb_interrupt_msg(streamlabs_wdt->usbdev, > + usb_rcvintpipe(streamlabs_wdt->usbdev, 0x81), > + streamlabs_wdt->buffer, BUFFER_LENGTH, > + &size, USB_TIMEOUT); > + > + if (retval || size != BUFFER_LENGTH) { > + dev_err(&streamlabs_wdt->intf->dev, > + "error %i when receiving interrupt msg\n", retval); > + retval = -EIO; > + goto out; > + } > + > + /* check if watchdog actually acked/recognized command */ > + retval = usb_streamlabs_wdt_validate_response(streamlabs_wdt->buffer); > + if (retval) { > + dev_err(&streamlabs_wdt->intf->dev, > + "watchdog didn't ACK command!\n"); > + goto out; > + } > + > + /* Transition from enabled to disabled state in this device > + * doesn't happen immediately. Usually, 2 or 3 (sometimes even 4) stop > + * commands should be sent until watchdog answers 'I'm stopped!'. > + * Retry stop command if watchdog fails to answer correctly > + * about its state. After 10 attempts, report error and return -EIO. > + */ > + if (cmd == STREAMLABS_CMD_STOP) { > + if (--retry_counter <= 0) { > + dev_err(&streamlabs_wdt->intf->dev, > + "failed to stop watchdog after 9 attempts!\n"); > + retval = -EIO; > + goto out; > + } > + /* > + * Check if watchdog actually changed state to disabled. > + * If watchdog is still enabled then reset message and retry > + * stop command. > + */ > + if (streamlabs_wdt->buffer[0] != 0xff || > + streamlabs_wdt->buffer[1] != 0xbb) { > + streamlabs_wdt->buffer[0] = 0xff; > + streamlabs_wdt->buffer[1] = 0xbb; > + goto retry; > + } > + } > + > +out: > + mutex_unlock(&streamlabs_wdt->lock); > + return retval; > +} > + > +static int usb_streamlabs_wdt_start(struct watchdog_device *wdt_dev) > +{ > + return usb_streamlabs_wdt_command(wdt_dev, STREAMLABS_CMD_START); > +} > + > +static int usb_streamlabs_wdt_stop(struct watchdog_device *wdt_dev) > +{ > + return usb_streamlabs_wdt_command(wdt_dev, STREAMLABS_CMD_STOP); > +} > + > +static int usb_streamlabs_wdt_settimeout(struct watchdog_device *wdt_dev, > + unsigned int timeout) > +{ > + struct streamlabs_wdt *streamlabs_wdt = watchdog_get_drvdata(wdt_dev); > + > + mutex_lock(&streamlabs_wdt->lock); > + wdt_dev->timeout = timeout; > + mutex_unlock(&streamlabs_wdt->lock); > + > + return 0; > +} > + > +static void usb_streamlabs_wdt_release_resources(struct kref *kref) > +{ > + struct streamlabs_wdt *streamlabs_wdt = > + container_of(kref, struct streamlabs_wdt, kref); > + > + mutex_destroy(&streamlabs_wdt->lock); > + kfree(streamlabs_wdt->buffer); > + kfree(streamlabs_wdt); > +} > + > +static void usb_streamlabs_wdt_ref(struct watchdog_device *wdt_dev) > +{ > + struct streamlabs_wdt *streamlabs_wdt = watchdog_get_drvdata(wdt_dev); > + > + kref_get(&streamlabs_wdt->kref); > +} > + > +static void usb_streamlabs_wdt_unref(struct watchdog_device *wdt_dev) > +{ > + struct streamlabs_wdt *streamlabs_wdt = watchdog_get_drvdata(wdt_dev); > + > + kref_put(&streamlabs_wdt->kref, usb_streamlabs_wdt_release_resources); > +} > + > +static const struct watchdog_info streamlabs_wdt_ident = { > + .options = (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING), > + .identity = DRIVER_NAME, > +}; > + > +static struct watchdog_ops usb_streamlabs_wdt_ops = { > + .owner = THIS_MODULE, > + .start = usb_streamlabs_wdt_start, > + .stop = usb_streamlabs_wdt_stop, > + .set_timeout = usb_streamlabs_wdt_settimeout, > + .ref = usb_streamlabs_wdt_ref, > + .unref = usb_streamlabs_wdt_unref, > +}; > + > +static int usb_streamlabs_wdt_probe(struct usb_interface *intf, > + const struct usb_device_id *id) > +{ > + struct usb_device *dev = interface_to_usbdev(intf); > + struct streamlabs_wdt *streamlabs_wdt; > + int retval; > + > + /* USB IDs of this device appear to be weird/unregistered. Hence, do > + * an additional check on product and manufacturer. > + * If there is similar device in the field with same values then > + * there is stop command in probe() below that checks if the device > + * behaves as a watchdog. */ > + if (dev->product && dev->manufacturer && > + (strncmp(dev->product, "USBkit", 6) != 0 > + || strncmp(dev->manufacturer, "STREAM LABS", 11) != 0)) > + return -ENODEV; > + > + streamlabs_wdt = kmalloc(sizeof(struct streamlabs_wdt), GFP_KERNEL); > + if (!streamlabs_wdt) { > + dev_err(&intf->dev, "kmalloc failed\n"); > + return -ENOMEM; > + } > + > + streamlabs_wdt->buffer = kzalloc(BUFFER_LENGTH, GFP_KERNEL); > + if (!streamlabs_wdt->buffer) { > + dev_err(&intf->dev, "kzalloc for watchdog->buffer failed\n"); > + retval = -ENOMEM; > + goto err_nobuf; > + } > + > + mutex_init(&streamlabs_wdt->lock); > + > + streamlabs_wdt->wdt_dev.info = &streamlabs_wdt_ident; > + streamlabs_wdt->wdt_dev.ops = &usb_streamlabs_wdt_ops; > + streamlabs_wdt->wdt_dev.timeout = STREAMLABS_WDT_MAX_TIMEOUT; > + streamlabs_wdt->wdt_dev.max_timeout = STREAMLABS_WDT_MAX_TIMEOUT; > + streamlabs_wdt->wdt_dev.min_timeout = STREAMLABS_WDT_MIN_TIMEOUT; > + streamlabs_wdt->wdt_dev.parent = &intf->dev; > + > + streamlabs_wdt->usbdev = interface_to_usbdev(intf); > + streamlabs_wdt->intf = intf; > + usb_set_intfdata(intf, &streamlabs_wdt->wdt_dev); > + watchdog_set_drvdata(&streamlabs_wdt->wdt_dev, streamlabs_wdt); > + > + watchdog_init_timeout(&streamlabs_wdt->wdt_dev, > + streamlabs_wdt->wdt_dev.timeout, &intf->dev); > + watchdog_set_nowayout(&streamlabs_wdt->wdt_dev, nowayout); > + > + kref_init(&streamlabs_wdt->kref); > + > + retval = usb_streamlabs_wdt_stop(&streamlabs_wdt->wdt_dev); > + if (retval) > + goto err_wdt_buf; > + > + retval = watchdog_register_device(&streamlabs_wdt->wdt_dev); > + if (retval) { > + dev_err(&intf->dev, "failed to register watchdog device\n"); > + goto err_wdt_buf; > + } > + > + dev_info(&intf->dev, "StreamLabs USB watchdog loaded.\n"); > + > + return 0; > + > +err_wdt_buf: > + mutex_destroy(&streamlabs_wdt->lock); > + kfree(streamlabs_wdt->buffer); > + > +err_nobuf: > + kfree(streamlabs_wdt); > + return retval; > +} > + > + > + > +static int usb_streamlabs_wdt_suspend(struct usb_interface *intf, > + pm_message_t message) > +{ > + struct streamlabs_wdt *streamlabs_wdt = usb_get_intfdata(intf); > + > + if (watchdog_active(&streamlabs_wdt->wdt_dev)) > + usb_streamlabs_wdt_command(&streamlabs_wdt->wdt_dev, > + STREAMLABS_CMD_STOP); > + > + return 0; > +} If the result of a failure would be a spurious reset, you cannot drop errors. > + > +static int usb_streamlabs_wdt_resume(struct usb_interface *intf) > +{ > + struct streamlabs_wdt *streamlabs_wdt = usb_get_intfdata(intf); > + > + if (watchdog_active(&streamlabs_wdt->wdt_dev)) > + return usb_streamlabs_wdt_command(&streamlabs_wdt->wdt_dev, > + STREAMLABS_CMD_START); > + > + return 0; > +} > + > +static void usb_streamlabs_wdt_disconnect(struct usb_interface *intf) > +{ > + struct streamlabs_wdt *streamlabs_wdt = usb_get_intfdata(intf); > + > + /* First, stop sending USB messages to device. */ That is problematic. A disconnect can be triggered by removal of the hardware or in software through sysfs. In the latter case a running device without a driver would trigger a reset, wouldn't it? So I think for watchdog devices you need to go to an inactive state in disconnect(). > + mutex_lock(&streamlabs_wdt->lock); > + usb_set_intfdata(intf, NULL); > + streamlabs_wdt->usbdev = NULL; > + mutex_unlock(&streamlabs_wdt->lock); > + > + /* after commincation with device has stopped we can > + * unregister watchdog device. unref callback will clear the rest on > + * release of device if it was opened. > + */ > + watchdog_unregister_device(&streamlabs_wdt->wdt_dev); > + kref_put(&streamlabs_wdt->kref, usb_streamlabs_wdt_release_resources); > +} > + > +static struct usb_device_id usb_streamlabs_wdt_device_table[] = { > + { USB_DEVICE(USB_STREAMLABS_WATCHDOG_VENDOR, USB_STREAMLABS_WATCHDOG_PRODUCT) }, > + { } /* Terminating entry */ > +}; > + > +MODULE_DEVICE_TABLE(usb, usb_streamlabs_wdt_device_table); > + > +static struct usb_driver usb_streamlabs_wdt_driver = { > + .name = DRIVER_NAME, > + .probe = usb_streamlabs_wdt_probe, > + .disconnect = usb_streamlabs_wdt_disconnect, > + .suspend = usb_streamlabs_wdt_suspend, > + .resume = usb_streamlabs_wdt_resume, > + .reset_resume = usb_streamlabs_wdt_resume, > + .id_table = usb_streamlabs_wdt_device_table, > +}; > + > +module_usb_driver(usb_streamlabs_wdt_driver); -- To unsubscribe from this list: send the line "unsubscribe linux-usb" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
