mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
Here is the large set of char/misc/whatever driver subsystem updates for 5.12-rc1. Over time it seems like this tree is collecting more and more tiny driver subsystems in one place, making it easier for those maintainers, which is why this is getting larger. Included in here are: - coresight driver updates - habannalabs driver updates - virtual acrn driver addition (proper acks from the x86 maintainers) - broadcom misc driver addition - speakup driver updates - soundwire driver updates - fpga driver updates - amba driver updates - mei driver updates - vfio driver updates - greybus driver updates - nvmeem driver updates - phy driver updates - mhi driver updates - interconnect driver udpates - fsl-mc bus driver updates - random driver fix - some small misc driver updates (rtsx, pvpanic, etc.) All of these have been in linux-next for a while, with the only reported issue being a merge conflict in include/linux/mod_devicetable.h that you will hit in your tree due to the dfl_device_id addition from the fpga subsystem in here. The resolution should be simple. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> -----BEGIN PGP SIGNATURE----- iG0EABECAC0WIQT0tgzFv3jCIUoxPcsxR9QN2y37KQUCYDZf9w8cZ3JlZ0Brcm9h aC5jb20ACgkQMUfUDdst+yk3xgCcCEN+pCJTum+uAzSNH3YKs/onaDgAnRSVwOUw tNW6n1JhXLYl9f5JdhvS =MOHs -----END PGP SIGNATURE----- Merge tag 'char-misc-5.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc Pull char/misc driver updates from Greg KH: "Here is the large set of char/misc/whatever driver subsystem updates for 5.12-rc1. Over time it seems like this tree is collecting more and more tiny driver subsystems in one place, making it easier for those maintainers, which is why this is getting larger. Included in here are: - coresight driver updates - habannalabs driver updates - virtual acrn driver addition (proper acks from the x86 maintainers) - broadcom misc driver addition - speakup driver updates - soundwire driver updates - fpga driver updates - amba driver updates - mei driver updates - vfio driver updates - greybus driver updates - nvmeem driver updates - phy driver updates - mhi driver updates - interconnect driver udpates - fsl-mc bus driver updates - random driver fix - some small misc driver updates (rtsx, pvpanic, etc.) All of these have been in linux-next for a while, with the only reported issue being a merge conflict due to the dfl_device_id addition from the fpga subsystem in here" * tag 'char-misc-5.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (311 commits) spmi: spmi-pmic-arb: Fix hw_irq overflow Documentation: coresight: Add PID tracing description coresight: etm-perf: Support PID tracing for kernel at EL2 coresight: etm-perf: Clarify comment on perf options ACRN: update MAINTAINERS: mailing list is subscribers-only regmap: sdw-mbq: use MODULE_LICENSE("GPL") regmap: sdw: use no_pm routines for SoundWire 1.2 MBQ regmap: sdw: use _no_pm functions in regmap_read/write soundwire: intel: fix possible crash when no device is detected MAINTAINERS: replace my with email with replacements mhi: Fix double dma free uapi: map_to_7segment: Update example in documentation uio: uio_pci_generic: don't fail probe if pdev->irq equals to IRQ_NOTCONNECTED drivers/misc/vmw_vmci: restrict too big queue size in qp_host_alloc_queue firewire: replace tricky statement by two simple ones vme: make remove callback return void firmware: google: make coreboot driver's remove callback return void firmware: xilinx: Use explicit values for all enum values sample/acrn: Introduce a sample of HSM ioctl interface usage virt: acrn: Introduce an interface for Service VM to control vCPU ...
664 lines
15 KiB
C
664 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Intel Management Engine Interface (Intel MEI) Linux driver
|
|
* Copyright (c) 2015, Intel Corporation.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/completion.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_START_WD_TIMER_RES 0x83
|
|
#define MEI_WDT_STATUS_SUCCESS 0
|
|
#define MEI_WDT_WDSTATE_NOT_REQUIRED 0x1
|
|
#define MEI_MC_STOP_WD_TIMER_REQ 0x14
|
|
|
|
/**
|
|
* enum mei_wdt_state - internal watchdog state
|
|
*
|
|
* @MEI_WDT_PROBE: wd in probing stage
|
|
* @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
|
|
* @MEI_WDT_NOT_REQUIRED: wd device is not required
|
|
*/
|
|
enum mei_wdt_state {
|
|
MEI_WDT_PROBE,
|
|
MEI_WDT_IDLE,
|
|
MEI_WDT_START,
|
|
MEI_WDT_RUNNING,
|
|
MEI_WDT_STOPPING,
|
|
MEI_WDT_NOT_REQUIRED,
|
|
};
|
|
|
|
static const char *mei_wdt_state_str(enum mei_wdt_state state)
|
|
{
|
|
switch (state) {
|
|
case MEI_WDT_PROBE:
|
|
return "PROBE";
|
|
case MEI_WDT_IDLE:
|
|
return "IDLE";
|
|
case MEI_WDT_START:
|
|
return "START";
|
|
case MEI_WDT_RUNNING:
|
|
return "RUNNING";
|
|
case MEI_WDT_STOPPING:
|
|
return "STOPPING";
|
|
case MEI_WDT_NOT_REQUIRED:
|
|
return "NOT_REQUIRED";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* struct mei_wdt - mei watchdog driver
|
|
* @wdd: watchdog device
|
|
*
|
|
* @cldev: mei watchdog client device
|
|
* @state: watchdog internal state
|
|
* @resp_required: ping required response
|
|
* @response: ping response completion
|
|
* @unregister: unregister worker
|
|
* @reg_lock: watchdog device registration lock
|
|
* @timeout: watchdog current timeout
|
|
*
|
|
* @dbgfs_dir: debugfs dir entry
|
|
*/
|
|
struct mei_wdt {
|
|
struct watchdog_device wdd;
|
|
|
|
struct mei_cl_device *cldev;
|
|
enum mei_wdt_state state;
|
|
bool resp_required;
|
|
struct completion response;
|
|
struct work_struct unregister;
|
|
struct mutex reg_lock;
|
|
u16 timeout;
|
|
|
|
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
|
struct dentry *dbgfs_dir;
|
|
#endif /* CONFIG_DEBUG_FS */
|
|
};
|
|
|
|
/*
|
|
* 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_start_response watchdog start/ping response
|
|
*
|
|
* @hdr: Management Control Command Header
|
|
* @status: operation status
|
|
* @wdstate: watchdog status bit mask
|
|
*/
|
|
struct mei_wdt_start_response {
|
|
struct mei_mc_hdr hdr;
|
|
u8 status;
|
|
u8 wdstate;
|
|
} __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;
|
|
|
|
if (wdt->resp_required)
|
|
init_completion(&wdt->response);
|
|
|
|
wdt->state = MEI_WDT_RUNNING;
|
|
ret = mei_wdt_ping(wdt);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (wdt->resp_required)
|
|
ret = wait_for_completion_killable(&wdt->response);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* 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_is_registered - check if wdt is registered
|
|
*
|
|
* @wdt: mei watchdog device
|
|
*
|
|
* Return: true if the wdt is registered with the watchdog subsystem
|
|
* Locking: should be called under wdt->reg_lock
|
|
*/
|
|
static inline bool __mei_wdt_is_registered(struct mei_wdt *wdt)
|
|
{
|
|
return !!watchdog_get_drvdata(&wdt->wdd);
|
|
}
|
|
|
|
/**
|
|
* mei_wdt_unregister - unregister from the watchdog subsystem
|
|
*
|
|
* @wdt: mei watchdog device
|
|
*/
|
|
static void mei_wdt_unregister(struct mei_wdt *wdt)
|
|
{
|
|
mutex_lock(&wdt->reg_lock);
|
|
|
|
if (__mei_wdt_is_registered(wdt)) {
|
|
watchdog_unregister_device(&wdt->wdd);
|
|
watchdog_set_drvdata(&wdt->wdd, NULL);
|
|
memset(&wdt->wdd, 0, sizeof(wdt->wdd));
|
|
}
|
|
|
|
mutex_unlock(&wdt->reg_lock);
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
|
|
mutex_lock(&wdt->reg_lock);
|
|
|
|
if (__mei_wdt_is_registered(wdt)) {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
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);
|
|
watchdog_stop_on_reboot(&wdt->wdd);
|
|
watchdog_stop_on_unregister(&wdt->wdd);
|
|
|
|
ret = watchdog_register_device(&wdt->wdd);
|
|
if (ret)
|
|
watchdog_set_drvdata(&wdt->wdd, NULL);
|
|
|
|
wdt->state = MEI_WDT_IDLE;
|
|
|
|
out:
|
|
mutex_unlock(&wdt->reg_lock);
|
|
return ret;
|
|
}
|
|
|
|
static void mei_wdt_unregister_work(struct work_struct *work)
|
|
{
|
|
struct mei_wdt *wdt = container_of(work, struct mei_wdt, unregister);
|
|
|
|
mei_wdt_unregister(wdt);
|
|
}
|
|
|
|
/**
|
|
* mei_wdt_rx - callback for data receive
|
|
*
|
|
* @cldev: bus device
|
|
*/
|
|
static void mei_wdt_rx(struct mei_cl_device *cldev)
|
|
{
|
|
struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev);
|
|
struct mei_wdt_start_response res;
|
|
const size_t res_len = sizeof(res);
|
|
int ret;
|
|
|
|
ret = mei_cldev_recv(wdt->cldev, (u8 *)&res, res_len);
|
|
if (ret < 0) {
|
|
dev_err(&cldev->dev, "failure in recv %d\n", ret);
|
|
return;
|
|
}
|
|
|
|
/* Empty response can be sent on stop */
|
|
if (ret == 0)
|
|
return;
|
|
|
|
if (ret < sizeof(struct mei_mc_hdr)) {
|
|
dev_err(&cldev->dev, "recv small data %d\n", ret);
|
|
return;
|
|
}
|
|
|
|
if (res.hdr.command != MEI_MANAGEMENT_CONTROL ||
|
|
res.hdr.versionnumber != MEI_MC_VERSION_NUMBER) {
|
|
dev_err(&cldev->dev, "wrong command received\n");
|
|
return;
|
|
}
|
|
|
|
if (res.hdr.subcommand != MEI_MC_START_WD_TIMER_RES) {
|
|
dev_warn(&cldev->dev, "unsupported command %d :%s[%d]\n",
|
|
res.hdr.subcommand,
|
|
mei_wdt_state_str(wdt->state),
|
|
wdt->state);
|
|
return;
|
|
}
|
|
|
|
/* Run the unregistration in a worker as this can be
|
|
* run only after ping completion, otherwise the flow will
|
|
* deadlock on watchdog core mutex.
|
|
*/
|
|
if (wdt->state == MEI_WDT_RUNNING) {
|
|
if (res.wdstate & MEI_WDT_WDSTATE_NOT_REQUIRED) {
|
|
wdt->state = MEI_WDT_NOT_REQUIRED;
|
|
schedule_work(&wdt->unregister);
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
if (wdt->state == MEI_WDT_PROBE) {
|
|
if (res.wdstate & MEI_WDT_WDSTATE_NOT_REQUIRED) {
|
|
wdt->state = MEI_WDT_NOT_REQUIRED;
|
|
} else {
|
|
/* stop the watchdog and register watchdog device */
|
|
mei_wdt_stop(wdt);
|
|
mei_wdt_register(wdt);
|
|
}
|
|
return;
|
|
}
|
|
|
|
dev_warn(&cldev->dev, "not in correct state %s[%d]\n",
|
|
mei_wdt_state_str(wdt->state), wdt->state);
|
|
|
|
out:
|
|
if (!completion_done(&wdt->response))
|
|
complete(&wdt->response);
|
|
}
|
|
|
|
/*
|
|
* mei_wdt_notif - callback for event notification
|
|
*
|
|
* @cldev: bus device
|
|
*/
|
|
static void mei_wdt_notif(struct mei_cl_device *cldev)
|
|
{
|
|
struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev);
|
|
|
|
if (wdt->state != MEI_WDT_NOT_REQUIRED)
|
|
return;
|
|
|
|
mei_wdt_register(wdt);
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
|
|
|
static ssize_t mei_dbgfs_read_activation(struct file *file, char __user *ubuf,
|
|
size_t cnt, loff_t *ppos)
|
|
{
|
|
struct mei_wdt *wdt = file->private_data;
|
|
const size_t bufsz = 32;
|
|
char buf[32];
|
|
ssize_t pos;
|
|
|
|
mutex_lock(&wdt->reg_lock);
|
|
pos = scnprintf(buf, bufsz, "%s\n",
|
|
__mei_wdt_is_registered(wdt) ? "activated" : "deactivated");
|
|
mutex_unlock(&wdt->reg_lock);
|
|
|
|
return simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
|
|
}
|
|
|
|
static const struct file_operations dbgfs_fops_activation = {
|
|
.open = simple_open,
|
|
.read = mei_dbgfs_read_activation,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static ssize_t mei_dbgfs_read_state(struct file *file, char __user *ubuf,
|
|
size_t cnt, loff_t *ppos)
|
|
{
|
|
struct mei_wdt *wdt = file->private_data;
|
|
char buf[32];
|
|
ssize_t pos;
|
|
|
|
pos = scnprintf(buf, sizeof(buf), "state: %s\n",
|
|
mei_wdt_state_str(wdt->state));
|
|
|
|
return simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
|
|
}
|
|
|
|
static const struct file_operations dbgfs_fops_state = {
|
|
.open = simple_open,
|
|
.read = mei_dbgfs_read_state,
|
|
.llseek = generic_file_llseek,
|
|
};
|
|
|
|
static void dbgfs_unregister(struct mei_wdt *wdt)
|
|
{
|
|
debugfs_remove_recursive(wdt->dbgfs_dir);
|
|
wdt->dbgfs_dir = NULL;
|
|
}
|
|
|
|
static void dbgfs_register(struct mei_wdt *wdt)
|
|
{
|
|
struct dentry *dir;
|
|
|
|
dir = debugfs_create_dir(KBUILD_MODNAME, NULL);
|
|
wdt->dbgfs_dir = dir;
|
|
|
|
debugfs_create_file("state", S_IRUSR, dir, wdt, &dbgfs_fops_state);
|
|
|
|
debugfs_create_file("activation", S_IRUSR, dir, wdt,
|
|
&dbgfs_fops_activation);
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void dbgfs_unregister(struct mei_wdt *wdt) {}
|
|
static inline void dbgfs_register(struct mei_wdt *wdt) {}
|
|
#endif /* CONFIG_DEBUG_FS */
|
|
|
|
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_PROBE;
|
|
wdt->cldev = cldev;
|
|
wdt->resp_required = mei_cldev_ver(cldev) > 0x1;
|
|
mutex_init(&wdt->reg_lock);
|
|
init_completion(&wdt->response);
|
|
INIT_WORK(&wdt->unregister, mei_wdt_unregister_work);
|
|
|
|
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;
|
|
}
|
|
|
|
ret = mei_cldev_register_rx_cb(wdt->cldev, mei_wdt_rx);
|
|
if (ret) {
|
|
dev_err(&cldev->dev, "Could not reg rx event ret=%d\n", ret);
|
|
goto err_disable;
|
|
}
|
|
|
|
ret = mei_cldev_register_notif_cb(wdt->cldev, mei_wdt_notif);
|
|
/* on legacy devices notification is not supported
|
|
*/
|
|
if (ret && ret != -EOPNOTSUPP) {
|
|
dev_err(&cldev->dev, "Could not reg notif event ret=%d\n", ret);
|
|
goto err_disable;
|
|
}
|
|
|
|
wd_info.firmware_version = mei_cldev_ver(cldev);
|
|
|
|
if (wdt->resp_required)
|
|
ret = mei_wdt_ping(wdt);
|
|
else
|
|
ret = mei_wdt_register(wdt);
|
|
|
|
if (ret)
|
|
goto err_disable;
|
|
|
|
dbgfs_register(wdt);
|
|
|
|
return 0;
|
|
|
|
err_disable:
|
|
mei_cldev_disable(cldev);
|
|
|
|
err_out:
|
|
kfree(wdt);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void mei_wdt_remove(struct mei_cl_device *cldev)
|
|
{
|
|
struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev);
|
|
|
|
/* Free the caller in case of fw initiated or unexpected reset */
|
|
if (!completion_done(&wdt->response))
|
|
complete(&wdt->response);
|
|
|
|
cancel_work_sync(&wdt->unregister);
|
|
|
|
mei_wdt_unregister(wdt);
|
|
|
|
mei_cldev_disable(cldev);
|
|
|
|
dbgfs_unregister(wdt);
|
|
|
|
kfree(wdt);
|
|
}
|
|
|
|
#define MEI_UUID_WD UUID_LE(0x05B79A6F, 0x4628, 0x4D7F, \
|
|
0x89, 0x9D, 0xA9, 0x15, 0x14, 0xCB, 0x32, 0xAB)
|
|
|
|
static const struct mei_cl_device_id mei_wdt_tbl[] = {
|
|
{ .uuid = MEI_UUID_WD, .version = MEI_CL_VERSION_ANY },
|
|
/* 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,
|
|
};
|
|
|
|
module_mei_cl_driver(mei_wdt_driver);
|
|
|
|
MODULE_AUTHOR("Intel Corporation");
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_DESCRIPTION("Device driver for Intel MEI iAMT watchdog");
|