Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 222818c3 authored by Tomas Winkler's avatar Tomas Winkler Committed by Greg Kroah-Hartman
Browse files

watchdog: mei_wdt: implement MEI iAMT watchdog driver 



Create a driver with the generic watchdog interface
for the MEI iAMT watchdog device.

Signed-off-by: default avatarAlexander Usyskin <alexander.usyskin@intel.com>
Signed-off-by: default avatarTomas Winkler <tomas.winkler@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent fdd9b865

Documentation/misc-devices/mei/mei.txt

+6 −6
Original line number Diff line number Diff line
@@ -231,15 +231,15 @@ IT knows when a platform crashes even when there is a hard failure on the host. 
The Intel AMT Watchdog is composed of two parts:

	1) Firmware feature - receives the heartbeats

	   and sends an event when the heartbeats stop.

	2) Intel MEI driver - connects to the watchdog feature, configures the

	   watchdog and sends the heartbeats.

	2) Intel MEI iAMT watchdog driver - connects to the watchdog feature,

	   configures the watchdog and sends the heartbeats.



The Intel MEI driver uses the kernel watchdog API to configure the Intel AMT

Watchdog and to send heartbeats to it. The default timeout of the

The Intel iAMT watchdog MEI driver uses the kernel watchdog API to configure

the Intel AMT Watchdog and to send heartbeats to it. The default timeout of the

watchdog is 120 seconds.



If the Intel AMT Watchdog feature does not exist (i.e. the connection failed),

the Intel MEI driver will disable the sending of heartbeats.

If the Intel AMT is not enabled in the firmware then the watchdog client won't enumerate

on the me client bus and watchdog devices won't be exposed.





Supported Chipsets

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -5751,6 +5751,7 @@ S: Supported 
F:	include/uapi/linux/mei.h

F:	include/linux/mei_cl_bus.h

F:	drivers/misc/mei/*

F:	drivers/watchdog/mei_wdt.c

F:	Documentation/misc-devices/mei/*



INTEL MIC DRIVERS (mic)

drivers/watchdog/Kconfig

+15 −0
Original line number Diff line number Diff line
@@ -1212,6 +1212,21 @@ config SBC_EPX_C3_WATCHDOG 
	  To compile this driver as a module, choose M here: the

	  module will be called sbc_epx_c3.



config INTEL_MEI_WDT

	tristate "Intel MEI iAMT Watchdog"

	depends on INTEL_MEI && X86

	select WATCHDOG_CORE

	---help---

	  A device driver for the Intel MEI iAMT watchdog.



	  The Intel AMT Watchdog is an OS Health (Hang/Crash) watchdog.

	  Whenever the OS hangs or crashes, iAMT will send an event

	  to any subscriber to this event. The watchdog doesn't reset the

	  the platform.



	  To compile this driver as a module, choose M here:

	  the module will be called mei_wdt.



# M32R Architecture



# M68K Architecture

drivers/watchdog/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -126,6 +126,7 @@ obj-$(CONFIG_MACHZ_WDT) += machzwd.o 
obj-$(CONFIG_SBC_EPX_C3_WATCHDOG) += sbc_epx_c3.o

obj-$(CONFIG_INTEL_SCU_WATCHDOG) += intel_scu_watchdog.o

obj-$(CONFIG_INTEL_MID_WATCHDOG) += intel-mid_wdt.o

obj-$(CONFIG_INTEL_MEI_WDT) += mei_wdt.o



# M32R Architecture

drivers/watchdog/mei_wdt.c

0 → 100644
+404 −0
Original line number Diff line number Diff line 
/*

 * Intel Management Engine Interface (Intel MEI) Linux driver

 * Copyright (c) 2015, Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope 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/module.h>

#include <linux/slab.h>

#include <linux/interrupt.h>

#include <linux/watchdog.h>



#include <linux/uuid.h>

#include <linux/mei_cl_bus.h>



/*

 * iAMT Watchdog Device

 */

#define INTEL_AMT_WATCHDOG_ID "iamt_wdt"



#define MEI_WDT_DEFAULT_TIMEOUT   120  /* seconds */

#define MEI_WDT_MIN_TIMEOUT       120  /* seconds */

#define MEI_WDT_MAX_TIMEOUT     65535  /* seconds */



/* Commands */

#define MEI_MANAGEMENT_CONTROL 0x02



/* MEI Management Control version number */

#define MEI_MC_VERSION_NUMBER  0x10



/* Sub Commands */

#define MEI_MC_START_WD_TIMER_REQ  0x13

#define MEI_MC_STOP_WD_TIMER_REQ   0x14



/**

 * enum mei_wdt_state - internal watchdog state

 *

 * @MEI_WDT_IDLE: wd is idle and not opened

 * @MEI_WDT_START: wd was opened, start was called

 * @MEI_WDT_RUNNING: wd is expecting keep alive pings

 * @MEI_WDT_STOPPING: wd is stopping and will move to IDLE

 */

enum mei_wdt_state {

	MEI_WDT_IDLE,

	MEI_WDT_START,

	MEI_WDT_RUNNING,

	MEI_WDT_STOPPING,

};



/**

 * struct mei_wdt - mei watchdog driver

 * @wdd: watchdog device

 *

 * @cldev: mei watchdog client device

 * @state: watchdog internal state

 * @timeout: watchdog current timeout

 */

struct mei_wdt {

	struct watchdog_device wdd;



	struct mei_cl_device *cldev;

	enum mei_wdt_state state;

	u16 timeout;

};



/*

 * struct mei_mc_hdr - Management Control Command Header

 *

 * @command: Management Control (0x2)

 * @bytecount: Number of bytes in the message beyond this byte

 * @subcommand: Management Control Subcommand

 * @versionnumber: Management Control Version (0x10)

 */

struct mei_mc_hdr {

	u8 command;

	u8 bytecount;

	u8 subcommand;

	u8 versionnumber;

};



/**

 * struct mei_wdt_start_request watchdog start/ping

 *

 * @hdr: Management Control Command Header

 * @timeout: timeout value

 * @reserved: reserved (legacy)

 */

struct mei_wdt_start_request {

	struct mei_mc_hdr hdr;

	u16 timeout;

	u8 reserved[17];

} __packed;



/**

 * struct mei_wdt_stop_request - watchdog stop

 *

 * @hdr: Management Control Command Header

 */

struct mei_wdt_stop_request {

	struct mei_mc_hdr hdr;

} __packed;



/**

 * mei_wdt_ping - send wd start/ping command

 *

 * @wdt: mei watchdog device

 *

 * Return: 0 on success,

 *         negative errno code on failure

 */

static int mei_wdt_ping(struct mei_wdt *wdt)

{

	struct mei_wdt_start_request req;

	const size_t req_len = sizeof(req);

	int ret;



	memset(&req, 0, req_len);

	req.hdr.command = MEI_MANAGEMENT_CONTROL;

	req.hdr.bytecount = req_len - offsetof(struct mei_mc_hdr, subcommand);

	req.hdr.subcommand = MEI_MC_START_WD_TIMER_REQ;

	req.hdr.versionnumber = MEI_MC_VERSION_NUMBER;

	req.timeout = wdt->timeout;



	ret = mei_cldev_send(wdt->cldev, (u8 *)&req, req_len);

	if (ret < 0)

		return ret;



	return 0;

}



/**

 * mei_wdt_stop - send wd stop command

 *

 * @wdt: mei watchdog device

 *

 * Return: 0 on success,

 *         negative errno code on failure

 */

static int mei_wdt_stop(struct mei_wdt *wdt)

{

	struct mei_wdt_stop_request req;

	const size_t req_len = sizeof(req);

	int ret;



	memset(&req, 0, req_len);

	req.hdr.command = MEI_MANAGEMENT_CONTROL;

	req.hdr.bytecount = req_len - offsetof(struct mei_mc_hdr, subcommand);

	req.hdr.subcommand = MEI_MC_STOP_WD_TIMER_REQ;

	req.hdr.versionnumber = MEI_MC_VERSION_NUMBER;



	ret = mei_cldev_send(wdt->cldev, (u8 *)&req, req_len);

	if (ret < 0)

		return ret;



	return 0;

}



/**

 * mei_wdt_ops_start - wd start command from the watchdog core.

 *

 * @wdd: watchdog device

 *

 * Return: 0 on success or -ENODEV;

 */

static int mei_wdt_ops_start(struct watchdog_device *wdd)

{

	struct mei_wdt *wdt = watchdog_get_drvdata(wdd);



	wdt->state = MEI_WDT_START;

	wdd->timeout = wdt->timeout;

	return 0;

}



/**

 * mei_wdt_ops_stop - wd stop command from the watchdog core.

 *

 * @wdd: watchdog device

 *

 * Return: 0 if success, negative errno code for failure

 */

static int mei_wdt_ops_stop(struct watchdog_device *wdd)

{

	struct mei_wdt *wdt = watchdog_get_drvdata(wdd);

	int ret;



	if (wdt->state != MEI_WDT_RUNNING)

		return 0;



	wdt->state = MEI_WDT_STOPPING;



	ret = mei_wdt_stop(wdt);

	if (ret)

		return ret;



	wdt->state = MEI_WDT_IDLE;



	return 0;

}



/**

 * mei_wdt_ops_ping - wd ping command from the watchdog core.

 *

 * @wdd: watchdog device

 *

 * Return: 0 if success, negative errno code on failure

 */

static int mei_wdt_ops_ping(struct watchdog_device *wdd)

{

	struct mei_wdt *wdt = watchdog_get_drvdata(wdd);

	int ret;



	if (wdt->state != MEI_WDT_START && wdt->state != MEI_WDT_RUNNING)

		return 0;



	ret = mei_wdt_ping(wdt);

	if (ret)

		return ret;



	wdt->state = MEI_WDT_RUNNING;



	return 0;

}



/**

 * mei_wdt_ops_set_timeout - wd set timeout command from the watchdog core.

 *

 * @wdd: watchdog device

 * @timeout: timeout value to set

 *

 * Return: 0 if success, negative errno code for failure

 */

static int mei_wdt_ops_set_timeout(struct watchdog_device *wdd,

				   unsigned int timeout)

{



	struct mei_wdt *wdt = watchdog_get_drvdata(wdd);



	/* valid value is already checked by the caller */

	wdt->timeout = timeout;

	wdd->timeout = timeout;



	return 0;

}



static const struct watchdog_ops wd_ops = {

	.owner       = THIS_MODULE,

	.start       = mei_wdt_ops_start,

	.stop        = mei_wdt_ops_stop,

	.ping        = mei_wdt_ops_ping,

	.set_timeout = mei_wdt_ops_set_timeout,

};



/* not const as the firmware_version field need to be retrieved */

static struct watchdog_info wd_info = {

	.identity = INTEL_AMT_WATCHDOG_ID,

	.options  = WDIOF_KEEPALIVEPING |

		    WDIOF_SETTIMEOUT |

		    WDIOF_ALARMONLY,

};



/**

 * mei_wdt_unregister - unregister from the watchdog subsystem

 *

 * @wdt: mei watchdog device

 */

static void mei_wdt_unregister(struct mei_wdt *wdt)

{

	watchdog_unregister_device(&wdt->wdd);

	watchdog_set_drvdata(&wdt->wdd, NULL);

}



/**

 * mei_wdt_register - register with the watchdog subsystem

 *

 * @wdt: mei watchdog device

 *

 * Return: 0 if success, negative errno code for failure

 */

static int mei_wdt_register(struct mei_wdt *wdt)

{

	struct device *dev;

	int ret;



	if (!wdt || !wdt->cldev)

		return -EINVAL;



	dev = &wdt->cldev->dev;



	wdt->wdd.info = &wd_info;

	wdt->wdd.ops = &wd_ops;

	wdt->wdd.parent = dev;

	wdt->wdd.timeout = MEI_WDT_DEFAULT_TIMEOUT;

	wdt->wdd.min_timeout = MEI_WDT_MIN_TIMEOUT;

	wdt->wdd.max_timeout = MEI_WDT_MAX_TIMEOUT;



	watchdog_set_drvdata(&wdt->wdd, wdt);

	ret = watchdog_register_device(&wdt->wdd);

	if (ret) {

		dev_err(dev, "unable to register watchdog device = %d.\n", ret);

		watchdog_set_drvdata(&wdt->wdd, NULL);

	}



	return ret;

}



static int mei_wdt_probe(struct mei_cl_device *cldev,

			 const struct mei_cl_device_id *id)

{

	struct mei_wdt *wdt;

	int ret;



	wdt = kzalloc(sizeof(struct mei_wdt), GFP_KERNEL);

	if (!wdt)

		return -ENOMEM;



	wdt->timeout = MEI_WDT_DEFAULT_TIMEOUT;

	wdt->state = MEI_WDT_IDLE;

	wdt->cldev = cldev;

	mei_cldev_set_drvdata(cldev, wdt);



	ret = mei_cldev_enable(cldev);

	if (ret < 0) {

		dev_err(&cldev->dev, "Could not enable cl device\n");

		goto err_out;

	}



	wd_info.firmware_version = mei_cldev_ver(cldev);



	ret = mei_wdt_register(wdt);

	if (ret)

		goto err_disable;



	return 0;



err_disable:

	mei_cldev_disable(cldev);



err_out:

	kfree(wdt);



	return ret;

}



static int mei_wdt_remove(struct mei_cl_device *cldev)

{

	struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev);



	mei_wdt_unregister(wdt);



	mei_cldev_disable(cldev);



	kfree(wdt);



	return 0;

}



#define MEI_UUID_WD UUID_LE(0x05B79A6F, 0x4628, 0x4D7F, \

			    0x89, 0x9D, 0xA9, 0x15, 0x14, 0xCB, 0x32, 0xAB)



static struct mei_cl_device_id mei_wdt_tbl[] = {

	{ .uuid = MEI_UUID_WD, .version = 0x1},

	/* required last entry */

	{ }

};

MODULE_DEVICE_TABLE(mei, mei_wdt_tbl);



static struct mei_cl_driver mei_wdt_driver = {

	.id_table = mei_wdt_tbl,

	.name = KBUILD_MODNAME,



	.probe = mei_wdt_probe,

	.remove = mei_wdt_remove,

};



static int __init mei_wdt_init(void)

{

	int ret;



	ret = mei_cldev_driver_register(&mei_wdt_driver);

	if (ret) {

		pr_err(KBUILD_MODNAME ": module registration failed\n");

		return ret;

	}

	return 0;

}



static void __exit mei_wdt_exit(void)

{

	mei_cldev_driver_unregister(&mei_wdt_driver);

}



module_init(mei_wdt_init);

module_exit(mei_wdt_exit);



MODULE_AUTHOR("Intel Corporation");

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Device driver for Intel MEI iAMT watchdog");