2019-03-12 06:10:41 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
/*
|
2019-03-12 06:10:44 +08:00
|
|
|
* Copyright (c) 2003-2019, Intel Corporation. All rights reserved.
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
* Intel Management Engine Interface (Intel MEI) Linux driver
|
|
|
|
*/
|
|
|
|
|
2017-02-03 02:15:33 +08:00
|
|
|
#include <linux/sched/signal.h>
|
2013-01-09 05:07:13 +08:00
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/delay.h>
|
2014-09-29 21:31:46 +08:00
|
|
|
#include <linux/slab.h>
|
2014-03-19 04:52:04 +08:00
|
|
|
#include <linux/pm_runtime.h>
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
|
2012-05-09 21:38:59 +08:00
|
|
|
#include <linux/mei.h>
|
2012-12-26 01:06:03 +08:00
|
|
|
|
|
|
|
#include "mei_dev.h"
|
2013-01-09 05:07:12 +08:00
|
|
|
#include "hbm.h"
|
2013-01-09 05:07:14 +08:00
|
|
|
#include "client.h"
|
|
|
|
|
2015-01-11 06:07:16 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_init - initialize me client
|
|
|
|
*
|
|
|
|
* @me_cl: me client
|
|
|
|
*/
|
|
|
|
void mei_me_cl_init(struct mei_me_client *me_cl)
|
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&me_cl->list);
|
|
|
|
kref_init(&me_cl->refcnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_me_cl_get - increases me client refcount
|
|
|
|
*
|
|
|
|
* @me_cl: me client
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* Return: me client or NULL
|
|
|
|
*/
|
|
|
|
struct mei_me_client *mei_me_cl_get(struct mei_me_client *me_cl)
|
|
|
|
{
|
2015-02-10 16:39:31 +08:00
|
|
|
if (me_cl && kref_get_unless_zero(&me_cl->refcnt))
|
|
|
|
return me_cl;
|
2015-01-11 06:07:16 +08:00
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
return NULL;
|
2015-01-11 06:07:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-02-10 16:39:31 +08:00
|
|
|
* mei_me_cl_release - free me client
|
2015-01-11 06:07:16 +08:00
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* @ref: me_client refcount
|
|
|
|
*/
|
|
|
|
static void mei_me_cl_release(struct kref *ref)
|
|
|
|
{
|
|
|
|
struct mei_me_client *me_cl =
|
|
|
|
container_of(ref, struct mei_me_client, refcnt);
|
2015-02-10 16:39:31 +08:00
|
|
|
|
2015-01-11 06:07:16 +08:00
|
|
|
kfree(me_cl);
|
|
|
|
}
|
2015-02-10 16:39:31 +08:00
|
|
|
|
2015-01-11 06:07:16 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_put - decrease me client refcount and free client if necessary
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* @me_cl: me client
|
|
|
|
*/
|
|
|
|
void mei_me_cl_put(struct mei_me_client *me_cl)
|
|
|
|
{
|
|
|
|
if (me_cl)
|
|
|
|
kref_put(&me_cl->refcnt, mei_me_cl_release);
|
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
/**
|
2015-05-04 14:43:54 +08:00
|
|
|
* __mei_me_cl_del - delete me client from the list and decrease
|
2015-02-10 16:39:31 +08:00
|
|
|
* reference counter
|
|
|
|
*
|
|
|
|
* @dev: mei device
|
|
|
|
* @me_cl: me client
|
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
|
|
|
*/
|
|
|
|
static void __mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl)
|
|
|
|
{
|
|
|
|
if (!me_cl)
|
|
|
|
return;
|
|
|
|
|
2015-05-04 14:43:54 +08:00
|
|
|
list_del_init(&me_cl->list);
|
2015-02-10 16:39:31 +08:00
|
|
|
mei_me_cl_put(me_cl);
|
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:54 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_del - delete me client from the list and decrease
|
|
|
|
* reference counter
|
|
|
|
*
|
|
|
|
* @dev: mei device
|
|
|
|
* @me_cl: me client
|
|
|
|
*/
|
|
|
|
void mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl)
|
|
|
|
{
|
|
|
|
down_write(&dev->me_clients_rwsem);
|
|
|
|
__mei_me_cl_del(dev, me_cl);
|
|
|
|
up_write(&dev->me_clients_rwsem);
|
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_add - add me client to the list
|
|
|
|
*
|
|
|
|
* @dev: mei device
|
|
|
|
* @me_cl: me client
|
|
|
|
*/
|
|
|
|
void mei_me_cl_add(struct mei_device *dev, struct mei_me_client *me_cl)
|
|
|
|
{
|
|
|
|
down_write(&dev->me_clients_rwsem);
|
|
|
|
list_add(&me_cl->list, &dev->me_clients);
|
|
|
|
up_write(&dev->me_clients_rwsem);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __mei_me_cl_by_uuid - locate me client by uuid
|
2015-01-11 06:07:16 +08:00
|
|
|
* increases ref count
|
2013-01-09 05:07:14 +08:00
|
|
|
*
|
|
|
|
* @dev: mei device
|
2014-09-29 21:31:49 +08:00
|
|
|
* @uuid: me client uuid
|
2014-02-17 21:13:22 +08:00
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: me client or NULL if not found
|
2015-02-10 16:39:31 +08:00
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
2013-01-09 05:07:14 +08:00
|
|
|
*/
|
2015-02-10 16:39:31 +08:00
|
|
|
static struct mei_me_client *__mei_me_cl_by_uuid(struct mei_device *dev,
|
2014-08-24 17:08:55 +08:00
|
|
|
const uuid_le *uuid)
|
2013-01-09 05:07:14 +08:00
|
|
|
{
|
2014-08-21 19:29:13 +08:00
|
|
|
struct mei_me_client *me_cl;
|
2015-02-10 16:39:31 +08:00
|
|
|
const uuid_le *pn;
|
2013-01-09 05:07:14 +08:00
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
|
|
|
|
|
|
|
|
list_for_each_entry(me_cl, &dev->me_clients, list) {
|
|
|
|
pn = &me_cl->props.protocol_name;
|
|
|
|
if (uuid_le_cmp(*uuid, *pn) == 0)
|
2015-01-11 06:07:16 +08:00
|
|
|
return mei_me_cl_get(me_cl);
|
2015-02-10 16:39:31 +08:00
|
|
|
}
|
2013-01-09 05:07:14 +08:00
|
|
|
|
2014-08-24 17:08:55 +08:00
|
|
|
return NULL;
|
2013-01-09 05:07:14 +08:00
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_by_uuid - locate me client by uuid
|
|
|
|
* increases ref count
|
|
|
|
*
|
|
|
|
* @dev: mei device
|
|
|
|
* @uuid: me client uuid
|
|
|
|
*
|
|
|
|
* Return: me client or NULL if not found
|
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
|
|
|
*/
|
|
|
|
struct mei_me_client *mei_me_cl_by_uuid(struct mei_device *dev,
|
|
|
|
const uuid_le *uuid)
|
|
|
|
{
|
|
|
|
struct mei_me_client *me_cl;
|
|
|
|
|
|
|
|
down_read(&dev->me_clients_rwsem);
|
|
|
|
me_cl = __mei_me_cl_by_uuid(dev, uuid);
|
|
|
|
up_read(&dev->me_clients_rwsem);
|
|
|
|
|
|
|
|
return me_cl;
|
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
/**
|
2014-09-29 21:31:49 +08:00
|
|
|
* mei_me_cl_by_id - locate me client by client id
|
2015-01-11 06:07:16 +08:00
|
|
|
* increases ref count
|
2013-01-09 05:07:14 +08:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @client_id: me client id
|
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: me client or NULL if not found
|
2015-02-10 16:39:31 +08:00
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
2013-01-09 05:07:14 +08:00
|
|
|
*/
|
2014-08-24 17:08:55 +08:00
|
|
|
struct mei_me_client *mei_me_cl_by_id(struct mei_device *dev, u8 client_id)
|
2013-01-09 05:07:14 +08:00
|
|
|
{
|
2014-02-17 21:13:22 +08:00
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
struct mei_me_client *__me_cl, *me_cl = NULL;
|
|
|
|
|
|
|
|
down_read(&dev->me_clients_rwsem);
|
|
|
|
list_for_each_entry(__me_cl, &dev->me_clients, list) {
|
|
|
|
if (__me_cl->client_id == client_id) {
|
|
|
|
me_cl = mei_me_cl_get(__me_cl);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
up_read(&dev->me_clients_rwsem);
|
|
|
|
|
|
|
|
return me_cl;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __mei_me_cl_by_uuid_id - locate me client by client id and uuid
|
|
|
|
* increases ref count
|
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @uuid: me client uuid
|
|
|
|
* @client_id: me client id
|
|
|
|
*
|
|
|
|
* Return: me client or null if not found
|
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
|
|
|
*/
|
|
|
|
static struct mei_me_client *__mei_me_cl_by_uuid_id(struct mei_device *dev,
|
|
|
|
const uuid_le *uuid, u8 client_id)
|
|
|
|
{
|
2014-08-21 19:29:13 +08:00
|
|
|
struct mei_me_client *me_cl;
|
2015-02-10 16:39:31 +08:00
|
|
|
const uuid_le *pn;
|
|
|
|
|
|
|
|
WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
|
2013-01-09 05:07:14 +08:00
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
list_for_each_entry(me_cl, &dev->me_clients, list) {
|
|
|
|
pn = &me_cl->props.protocol_name;
|
|
|
|
if (uuid_le_cmp(*uuid, *pn) == 0 &&
|
|
|
|
me_cl->client_id == client_id)
|
2015-01-11 06:07:16 +08:00
|
|
|
return mei_me_cl_get(me_cl);
|
2015-02-10 16:39:31 +08:00
|
|
|
}
|
2015-01-11 06:07:16 +08:00
|
|
|
|
2014-08-24 17:08:55 +08:00
|
|
|
return NULL;
|
2013-01-09 05:07:14 +08:00
|
|
|
}
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
|
2014-09-29 21:31:49 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_by_uuid_id - locate me client by client id and uuid
|
2015-01-11 06:07:16 +08:00
|
|
|
* increases ref count
|
2014-09-29 21:31:49 +08:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @uuid: me client uuid
|
|
|
|
* @client_id: me client id
|
|
|
|
*
|
2015-02-10 16:39:31 +08:00
|
|
|
* Return: me client or null if not found
|
2014-09-29 21:31:49 +08:00
|
|
|
*/
|
2014-08-21 19:29:15 +08:00
|
|
|
struct mei_me_client *mei_me_cl_by_uuid_id(struct mei_device *dev,
|
|
|
|
const uuid_le *uuid, u8 client_id)
|
|
|
|
{
|
|
|
|
struct mei_me_client *me_cl;
|
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
down_read(&dev->me_clients_rwsem);
|
|
|
|
me_cl = __mei_me_cl_by_uuid_id(dev, uuid, client_id);
|
|
|
|
up_read(&dev->me_clients_rwsem);
|
2015-01-11 06:07:16 +08:00
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
return me_cl;
|
2014-08-21 19:29:15 +08:00
|
|
|
}
|
|
|
|
|
2014-08-21 19:29:14 +08:00
|
|
|
/**
|
2015-01-11 06:07:16 +08:00
|
|
|
* mei_me_cl_rm_by_uuid - remove all me clients matching uuid
|
2014-08-21 19:29:14 +08:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @uuid: me client uuid
|
2015-01-11 06:07:16 +08:00
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
2014-08-21 19:29:14 +08:00
|
|
|
*/
|
2015-01-11 06:07:16 +08:00
|
|
|
void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid)
|
2014-08-21 19:29:14 +08:00
|
|
|
{
|
2015-02-10 16:39:31 +08:00
|
|
|
struct mei_me_client *me_cl;
|
2014-08-21 19:29:14 +08:00
|
|
|
|
2015-01-11 06:07:16 +08:00
|
|
|
dev_dbg(dev->dev, "remove %pUl\n", uuid);
|
2015-02-10 16:39:31 +08:00
|
|
|
|
|
|
|
down_write(&dev->me_clients_rwsem);
|
|
|
|
me_cl = __mei_me_cl_by_uuid(dev, uuid);
|
|
|
|
__mei_me_cl_del(dev, me_cl);
|
2020-05-13 06:31:40 +08:00
|
|
|
mei_me_cl_put(me_cl);
|
2015-02-10 16:39:31 +08:00
|
|
|
up_write(&dev->me_clients_rwsem);
|
2015-01-11 06:07:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_me_cl_rm_by_uuid_id - remove all me clients matching client id
|
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @uuid: me client uuid
|
|
|
|
* @id: me client id
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*/
|
|
|
|
void mei_me_cl_rm_by_uuid_id(struct mei_device *dev, const uuid_le *uuid, u8 id)
|
|
|
|
{
|
2015-02-10 16:39:31 +08:00
|
|
|
struct mei_me_client *me_cl;
|
2015-01-11 06:07:16 +08:00
|
|
|
|
|
|
|
dev_dbg(dev->dev, "remove %pUl %d\n", uuid, id);
|
2015-02-10 16:39:31 +08:00
|
|
|
|
|
|
|
down_write(&dev->me_clients_rwsem);
|
|
|
|
me_cl = __mei_me_cl_by_uuid_id(dev, uuid, id);
|
|
|
|
__mei_me_cl_del(dev, me_cl);
|
2020-05-13 06:31:40 +08:00
|
|
|
mei_me_cl_put(me_cl);
|
2015-02-10 16:39:31 +08:00
|
|
|
up_write(&dev->me_clients_rwsem);
|
2014-08-21 19:29:14 +08:00
|
|
|
}
|
|
|
|
|
2015-01-11 06:07:16 +08:00
|
|
|
/**
|
|
|
|
* mei_me_cl_rm_all - remove all me clients
|
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*/
|
|
|
|
void mei_me_cl_rm_all(struct mei_device *dev)
|
|
|
|
{
|
|
|
|
struct mei_me_client *me_cl, *next;
|
|
|
|
|
2015-02-10 16:39:31 +08:00
|
|
|
down_write(&dev->me_clients_rwsem);
|
2015-01-11 06:07:16 +08:00
|
|
|
list_for_each_entry_safe(me_cl, next, &dev->me_clients, list)
|
2015-02-10 16:39:31 +08:00
|
|
|
__mei_me_cl_del(dev, me_cl);
|
|
|
|
up_write(&dev->me_clients_rwsem);
|
2015-01-11 06:07:16 +08:00
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:45 +08:00
|
|
|
/**
|
|
|
|
* mei_io_cb_free - free mei_cb_private related memory
|
|
|
|
*
|
|
|
|
* @cb: mei callback struct
|
|
|
|
*/
|
|
|
|
void mei_io_cb_free(struct mei_cl_cb *cb)
|
|
|
|
{
|
|
|
|
if (cb == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_del(&cb->list);
|
|
|
|
kfree(cb->buf.data);
|
|
|
|
kfree(cb);
|
|
|
|
}
|
|
|
|
|
2018-02-26 02:07:05 +08:00
|
|
|
/**
|
|
|
|
* mei_tx_cb_queue - queue tx callback
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* @cb: mei callback struct
|
|
|
|
* @head: an instance of list to queue on
|
|
|
|
*/
|
|
|
|
static inline void mei_tx_cb_enqueue(struct mei_cl_cb *cb,
|
|
|
|
struct list_head *head)
|
|
|
|
{
|
|
|
|
list_add_tail(&cb->list, head);
|
|
|
|
cb->cl->tx_cb_queued++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_tx_cb_dequeue - dequeue tx callback
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* @cb: mei callback struct to dequeue and free
|
|
|
|
*/
|
|
|
|
static inline void mei_tx_cb_dequeue(struct mei_cl_cb *cb)
|
|
|
|
{
|
|
|
|
if (!WARN_ON(cb->cl->tx_cb_queued == 0))
|
|
|
|
cb->cl->tx_cb_queued--;
|
|
|
|
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:45 +08:00
|
|
|
/**
|
|
|
|
* mei_io_cb_init - allocate and initialize io callback
|
|
|
|
*
|
|
|
|
* @cl: mei client
|
|
|
|
* @type: operation type
|
|
|
|
* @fp: pointer to file structure
|
|
|
|
*
|
|
|
|
* Return: mei_cl_cb pointer or NULL;
|
|
|
|
*/
|
2016-07-26 06:06:05 +08:00
|
|
|
static struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl,
|
|
|
|
enum mei_cb_file_ops type,
|
|
|
|
const struct file *fp)
|
2015-02-10 16:39:45 +08:00
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
|
|
|
|
cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
|
|
|
|
if (!cb)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&cb->list);
|
2016-02-08 05:35:24 +08:00
|
|
|
cb->fp = fp;
|
2015-02-10 16:39:45 +08:00
|
|
|
cb->cl = cl;
|
|
|
|
cb->buf_idx = 0;
|
|
|
|
cb->fop_type = type;
|
|
|
|
return cb;
|
|
|
|
}
|
|
|
|
|
2014-03-10 21:10:40 +08:00
|
|
|
/**
|
2018-02-26 02:07:05 +08:00
|
|
|
* mei_io_list_flush_cl - removes cbs belonging to the cl.
|
2014-03-10 21:10:40 +08:00
|
|
|
*
|
2017-01-27 22:32:45 +08:00
|
|
|
* @head: an instance of our list structure
|
2018-02-26 02:07:05 +08:00
|
|
|
* @cl: host client
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2018-02-26 02:07:05 +08:00
|
|
|
static void mei_io_list_flush_cl(struct list_head *head,
|
|
|
|
const struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2015-02-10 16:39:45 +08:00
|
|
|
struct mei_cl_cb *cb, *next;
|
2013-01-09 05:07:13 +08:00
|
|
|
|
2017-01-27 22:32:45 +08:00
|
|
|
list_for_each_entry_safe(cb, next, head, list) {
|
2019-01-30 16:12:26 +08:00
|
|
|
if (cl == cb->cl) {
|
2015-02-10 16:39:45 +08:00
|
|
|
list_del_init(&cb->list);
|
2019-01-30 16:12:26 +08:00
|
|
|
if (cb->fop_type == MEI_FOP_READ)
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
}
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-10 21:10:40 +08:00
|
|
|
/**
|
2018-02-26 02:07:05 +08:00
|
|
|
* mei_io_tx_list_free_cl - removes cb belonging to the cl and free them
|
2014-03-10 21:10:40 +08:00
|
|
|
*
|
2017-01-27 22:32:45 +08:00
|
|
|
* @head: An instance of our list structure
|
2014-03-10 21:10:40 +08:00
|
|
|
* @cl: host client
|
|
|
|
*/
|
2018-02-26 02:07:05 +08:00
|
|
|
static void mei_io_tx_list_free_cl(struct list_head *head,
|
|
|
|
const struct mei_cl *cl)
|
2014-03-10 21:10:40 +08:00
|
|
|
{
|
2018-02-26 02:07:05 +08:00
|
|
|
struct mei_cl_cb *cb, *next;
|
2014-03-10 21:10:40 +08:00
|
|
|
|
2018-02-26 02:07:05 +08:00
|
|
|
list_for_each_entry_safe(cb, next, head, list) {
|
2018-11-06 18:04:39 +08:00
|
|
|
if (cl == cb->cl)
|
2018-02-26 02:07:05 +08:00
|
|
|
mei_tx_cb_dequeue(cb);
|
|
|
|
}
|
2017-01-27 22:32:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_io_list_free_fp - free cb from a list that matches file pointer
|
|
|
|
*
|
|
|
|
* @head: io list
|
|
|
|
* @fp: file pointer (matching cb file object), may be NULL
|
|
|
|
*/
|
2017-03-20 21:04:03 +08:00
|
|
|
static void mei_io_list_free_fp(struct list_head *head, const struct file *fp)
|
2017-01-27 22:32:46 +08:00
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb, *next;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cb, next, head, list)
|
|
|
|
if (!fp || fp == cb->fp)
|
|
|
|
mei_io_cb_free(cb);
|
2014-03-10 21:10:40 +08:00
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:43 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_alloc_cb - a convenient wrapper for allocating read cb
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @length: size of the buffer
|
2016-11-11 09:00:09 +08:00
|
|
|
* @fop_type: operation type
|
2015-02-10 16:39:43 +08:00
|
|
|
* @fp: associated file pointer (might be NULL)
|
|
|
|
*
|
|
|
|
* Return: cb on success and NULL on failure
|
|
|
|
*/
|
|
|
|
struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,
|
2016-07-26 06:06:05 +08:00
|
|
|
enum mei_cb_file_ops fop_type,
|
2016-02-08 05:35:23 +08:00
|
|
|
const struct file *fp)
|
2015-02-10 16:39:43 +08:00
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
|
2016-07-26 06:06:05 +08:00
|
|
|
cb = mei_io_cb_init(cl, fop_type, fp);
|
2015-02-10 16:39:43 +08:00
|
|
|
if (!cb)
|
|
|
|
return NULL;
|
|
|
|
|
2016-05-25 04:03:41 +08:00
|
|
|
if (length == 0)
|
|
|
|
return cb;
|
|
|
|
|
2018-11-22 19:11:39 +08:00
|
|
|
cb->buf.data = kmalloc(roundup(length, MEI_SLOT_SIZE), GFP_KERNEL);
|
2016-05-25 04:03:41 +08:00
|
|
|
if (!cb->buf.data) {
|
2015-02-10 16:39:43 +08:00
|
|
|
mei_io_cb_free(cb);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-05-25 04:03:41 +08:00
|
|
|
cb->buf.size = length;
|
2015-02-10 16:39:43 +08:00
|
|
|
|
|
|
|
return cb;
|
|
|
|
}
|
|
|
|
|
2016-07-26 06:06:05 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_enqueue_ctrl_wr_cb - a convenient wrapper for allocating
|
|
|
|
* and enqueuing of the control commands cb
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @length: size of the buffer
|
2016-11-11 09:00:09 +08:00
|
|
|
* @fop_type: operation type
|
2016-07-26 06:06:05 +08:00
|
|
|
* @fp: associated file pointer (might be NULL)
|
|
|
|
*
|
|
|
|
* Return: cb on success and NULL on failure
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*/
|
|
|
|
struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,
|
|
|
|
enum mei_cb_file_ops fop_type,
|
|
|
|
const struct file *fp)
|
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
|
|
|
|
/* for RX always allocate at least client's mtu */
|
|
|
|
if (length)
|
|
|
|
length = max_t(size_t, length, mei_cl_mtu(cl));
|
|
|
|
|
|
|
|
cb = mei_cl_alloc_cb(cl, length, fop_type, fp);
|
|
|
|
if (!cb)
|
|
|
|
return NULL;
|
|
|
|
|
2017-01-27 22:32:45 +08:00
|
|
|
list_add_tail(&cb->list, &cl->dev->ctrl_wr_list);
|
2016-07-26 06:06:05 +08:00
|
|
|
return cb;
|
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:46 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_read_cb - find this cl's callback in the read list
|
|
|
|
* for a specific file
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @fp: file pointer (matching cb file object), may be NULL
|
|
|
|
*
|
|
|
|
* Return: cb on success, NULL if cb is not found
|
|
|
|
*/
|
|
|
|
struct mei_cl_cb *mei_cl_read_cb(const struct mei_cl *cl, const struct file *fp)
|
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
|
|
|
|
list_for_each_entry(cb, &cl->rd_completed, list)
|
2016-02-08 05:35:24 +08:00
|
|
|
if (!fp || fp == cb->fp)
|
2015-02-10 16:39:46 +08:00
|
|
|
return cb;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:13 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_flush_queues - flushes queue lists belonging to cl.
|
|
|
|
*
|
|
|
|
* @cl: host client
|
2015-02-10 16:39:46 +08:00
|
|
|
* @fp: file pointer (matching cb file object), may be NULL
|
2014-09-29 21:31:50 +08:00
|
|
|
*
|
|
|
|
* Return: 0 on success, -EINVAL if cl or cl->dev is NULL.
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2015-02-10 16:39:46 +08:00
|
|
|
int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2013-09-15 23:11:07 +08:00
|
|
|
struct mei_device *dev;
|
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
2013-01-09 05:07:13 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-09-15 23:11:07 +08:00
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
cl_dbg(dev, cl, "remove list entry belonging to cl\n");
|
2018-02-26 02:07:05 +08:00
|
|
|
mei_io_tx_list_free_cl(&cl->dev->write_list, cl);
|
|
|
|
mei_io_tx_list_free_cl(&cl->dev->write_waiting_list, cl);
|
2017-01-27 22:32:46 +08:00
|
|
|
mei_io_list_flush_cl(&cl->dev->ctrl_wr_list, cl);
|
|
|
|
mei_io_list_flush_cl(&cl->dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_free_fp(&cl->rd_pending, fp);
|
|
|
|
mei_io_list_free_fp(&cl->rd_completed, fp);
|
2015-02-10 16:39:46 +08:00
|
|
|
|
2013-01-09 05:07:13 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-09 04:31:46 +08:00
|
|
|
* mei_cl_init - initializes cl.
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
|
|
|
* @cl: host client to be initialized
|
|
|
|
* @dev: mei device
|
|
|
|
*/
|
2017-03-20 21:04:03 +08:00
|
|
|
static void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
|
|
|
memset(cl, 0, sizeof(struct mei_cl));
|
|
|
|
init_waitqueue_head(&cl->wait);
|
|
|
|
init_waitqueue_head(&cl->rx_wait);
|
|
|
|
init_waitqueue_head(&cl->tx_wait);
|
2015-07-26 14:54:19 +08:00
|
|
|
init_waitqueue_head(&cl->ev_wait);
|
2015-02-10 16:39:46 +08:00
|
|
|
INIT_LIST_HEAD(&cl->rd_completed);
|
|
|
|
INIT_LIST_HEAD(&cl->rd_pending);
|
2013-01-09 05:07:13 +08:00
|
|
|
INIT_LIST_HEAD(&cl->link);
|
|
|
|
cl->writing_state = MEI_IDLE;
|
2016-11-17 04:51:27 +08:00
|
|
|
cl->state = MEI_FILE_UNINITIALIZED;
|
2013-01-09 05:07:13 +08:00
|
|
|
cl->dev = dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_allocate - allocates cl structure and sets it up.
|
|
|
|
*
|
|
|
|
* @dev: mei device
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: The allocated file or NULL on failure
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
|
|
|
struct mei_cl *mei_cl_allocate(struct mei_device *dev)
|
|
|
|
{
|
|
|
|
struct mei_cl *cl;
|
|
|
|
|
|
|
|
cl = kmalloc(sizeof(struct mei_cl), GFP_KERNEL);
|
|
|
|
if (!cl)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
mei_cl_init(cl, dev);
|
|
|
|
|
|
|
|
return cl;
|
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:35 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_link - allocate host id in the host map
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2015-02-10 16:39:35 +08:00
|
|
|
* @cl: host client
|
2013-04-05 00:05:05 +08:00
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: 0 on success
|
2013-01-09 05:07:13 +08:00
|
|
|
* -EINVAL on incorrect values
|
2015-02-10 16:39:44 +08:00
|
|
|
* -EMFILE if open count exceeded.
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2016-02-08 05:35:40 +08:00
|
|
|
int mei_cl_link(struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2013-01-09 05:07:14 +08:00
|
|
|
struct mei_device *dev;
|
2016-02-08 05:35:40 +08:00
|
|
|
int id;
|
2013-01-09 05:07:13 +08:00
|
|
|
|
2013-01-09 05:07:22 +08:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
2013-01-09 05:07:13 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
dev = cl->dev;
|
|
|
|
|
2016-02-08 05:35:40 +08:00
|
|
|
id = find_first_zero_bit(dev->host_clients_map, MEI_CLIENTS_MAX);
|
2013-01-09 05:07:22 +08:00
|
|
|
if (id >= MEI_CLIENTS_MAX) {
|
2014-09-29 21:31:42 +08:00
|
|
|
dev_err(dev->dev, "id exceeded %d", MEI_CLIENTS_MAX);
|
2013-09-17 04:44:46 +08:00
|
|
|
return -EMFILE;
|
|
|
|
}
|
|
|
|
|
2017-03-20 21:04:03 +08:00
|
|
|
if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) {
|
2014-09-29 21:31:42 +08:00
|
|
|
dev_err(dev->dev, "open_handle_count exceeded %d",
|
2013-09-17 04:44:46 +08:00
|
|
|
MEI_MAX_OPEN_HANDLE_COUNT);
|
|
|
|
return -EMFILE;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:22 +08:00
|
|
|
dev->open_handle_count++;
|
|
|
|
|
|
|
|
cl->host_client_id = id;
|
|
|
|
list_add_tail(&cl->link, &dev->file_list);
|
|
|
|
|
|
|
|
set_bit(id, dev->host_clients_map);
|
|
|
|
|
|
|
|
cl->state = MEI_FILE_INITIALIZING;
|
|
|
|
|
2013-09-15 23:11:07 +08:00
|
|
|
cl_dbg(dev, cl, "link cl\n");
|
2013-01-09 05:07:22 +08:00
|
|
|
return 0;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
2013-01-09 05:07:22 +08:00
|
|
|
|
2013-01-09 05:07:13 +08:00
|
|
|
/**
|
2015-05-04 14:43:54 +08:00
|
|
|
* mei_cl_unlink - remove host client from the list
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2013-04-05 00:05:05 +08:00
|
|
|
* @cl: host client
|
2014-09-29 21:31:50 +08:00
|
|
|
*
|
|
|
|
* Return: always 0
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2013-01-09 05:07:14 +08:00
|
|
|
int mei_cl_unlink(struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2013-01-09 05:07:14 +08:00
|
|
|
struct mei_device *dev;
|
|
|
|
|
2013-01-09 05:07:22 +08:00
|
|
|
/* don't shout on error exit path */
|
|
|
|
if (!cl)
|
|
|
|
return 0;
|
|
|
|
|
2017-03-20 21:04:03 +08:00
|
|
|
if (WARN_ON(!cl->dev))
|
2013-01-10 23:32:14 +08:00
|
|
|
return 0;
|
2013-01-09 05:07:14 +08:00
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2013-09-17 04:44:45 +08:00
|
|
|
cl_dbg(dev, cl, "unlink client");
|
|
|
|
|
2013-09-17 04:44:47 +08:00
|
|
|
if (dev->open_handle_count > 0)
|
|
|
|
dev->open_handle_count--;
|
|
|
|
|
|
|
|
/* never clear the 0 bit */
|
|
|
|
if (cl->host_client_id)
|
|
|
|
clear_bit(cl->host_client_id, dev->host_clients_map);
|
|
|
|
|
|
|
|
list_del_init(&cl->link);
|
|
|
|
|
2016-11-17 04:51:27 +08:00
|
|
|
cl->state = MEI_FILE_UNINITIALIZED;
|
2016-11-17 04:51:29 +08:00
|
|
|
cl->writing_state = MEI_IDLE;
|
|
|
|
|
|
|
|
WARN_ON(!list_empty(&cl->rd_completed) ||
|
|
|
|
!list_empty(&cl->rd_pending) ||
|
|
|
|
!list_empty(&cl->link));
|
2013-09-17 04:44:47 +08:00
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
return 0;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
2016-02-08 05:35:43 +08:00
|
|
|
void mei_host_client_init(struct mei_device *dev)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2019-04-22 14:51:07 +08:00
|
|
|
mei_set_devstate(dev, MEI_DEV_ENABLED);
|
2014-01-12 06:36:10 +08:00
|
|
|
dev->reset_count = 0;
|
2014-03-19 04:52:04 +08:00
|
|
|
|
2016-02-08 05:35:43 +08:00
|
|
|
schedule_work(&dev->bus_rescan_work);
|
2015-07-23 20:08:47 +08:00
|
|
|
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
dev_dbg(dev->dev, "rpm: autosuspend\n");
|
2016-11-24 19:34:02 +08:00
|
|
|
pm_request_autosuspend(dev->dev);
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
/**
|
2014-09-29 21:31:49 +08:00
|
|
|
* mei_hbuf_acquire - try to acquire host buffer
|
2014-02-19 23:35:47 +08:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: true if host buffer was acquired
|
2014-02-19 23:35:47 +08:00
|
|
|
*/
|
|
|
|
bool mei_hbuf_acquire(struct mei_device *dev)
|
|
|
|
{
|
2014-03-19 04:52:04 +08:00
|
|
|
if (mei_pg_state(dev) == MEI_PG_ON ||
|
2015-06-13 13:51:17 +08:00
|
|
|
mei_pg_in_transition(dev)) {
|
2014-09-29 21:31:42 +08:00
|
|
|
dev_dbg(dev->dev, "device is in pg\n");
|
2014-03-19 04:52:04 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
if (!dev->hbuf_is_ready) {
|
2014-09-29 21:31:42 +08:00
|
|
|
dev_dbg(dev->dev, "hbuf is not ready\n");
|
2014-02-19 23:35:47 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->hbuf_is_ready = false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2013-01-09 05:07:13 +08:00
|
|
|
|
2016-02-08 05:35:35 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_wake_all - wake up readers, writers and event waiters so
|
|
|
|
* they can be interrupted
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
*/
|
|
|
|
static void mei_cl_wake_all(struct mei_cl *cl)
|
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
|
|
|
|
/* synchronized under device mutex */
|
|
|
|
if (waitqueue_active(&cl->rx_wait)) {
|
|
|
|
cl_dbg(dev, cl, "Waking up reading client!\n");
|
|
|
|
wake_up_interruptible(&cl->rx_wait);
|
|
|
|
}
|
|
|
|
/* synchronized under device mutex */
|
|
|
|
if (waitqueue_active(&cl->tx_wait)) {
|
|
|
|
cl_dbg(dev, cl, "Waking up writing client!\n");
|
|
|
|
wake_up_interruptible(&cl->tx_wait);
|
|
|
|
}
|
|
|
|
/* synchronized under device mutex */
|
|
|
|
if (waitqueue_active(&cl->ev_wait)) {
|
|
|
|
cl_dbg(dev, cl, "Waking up waiting for event clients!\n");
|
|
|
|
wake_up_interruptible(&cl->ev_wait);
|
|
|
|
}
|
2016-04-20 23:03:55 +08:00
|
|
|
/* synchronized under device mutex */
|
|
|
|
if (waitqueue_active(&cl->wait)) {
|
|
|
|
cl_dbg(dev, cl, "Waking up ctrl write clients!\n");
|
2016-05-09 12:07:46 +08:00
|
|
|
wake_up(&cl->wait);
|
2016-04-20 23:03:55 +08:00
|
|
|
}
|
2016-02-08 05:35:35 +08:00
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_set_disconnected - set disconnected state and clear
|
|
|
|
* associated states and resources
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
*/
|
2017-01-20 08:17:17 +08:00
|
|
|
static void mei_cl_set_disconnected(struct mei_cl *cl)
|
2015-05-04 14:43:52 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
|
|
|
|
if (cl->state == MEI_FILE_DISCONNECTED ||
|
2016-11-17 04:51:27 +08:00
|
|
|
cl->state <= MEI_FILE_INITIALIZING)
|
2015-05-04 14:43:52 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
cl->state = MEI_FILE_DISCONNECTED;
|
2018-02-26 02:07:05 +08:00
|
|
|
mei_io_tx_list_free_cl(&dev->write_list, cl);
|
|
|
|
mei_io_tx_list_free_cl(&dev->write_waiting_list, cl);
|
2017-01-27 22:32:46 +08:00
|
|
|
mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);
|
2016-02-08 05:35:35 +08:00
|
|
|
mei_cl_wake_all(cl);
|
2016-07-26 06:06:03 +08:00
|
|
|
cl->rx_flow_ctrl_creds = 0;
|
2016-07-26 06:06:04 +08:00
|
|
|
cl->tx_flow_ctrl_creds = 0;
|
2015-05-04 14:43:52 +08:00
|
|
|
cl->timer_count = 0;
|
2015-05-04 14:43:54 +08:00
|
|
|
|
2015-05-04 14:43:55 +08:00
|
|
|
if (!cl->me_cl)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!WARN_ON(cl->me_cl->connect_count == 0))
|
|
|
|
cl->me_cl->connect_count--;
|
|
|
|
|
2015-06-14 02:18:40 +08:00
|
|
|
if (cl->me_cl->connect_count == 0)
|
2016-07-26 06:06:04 +08:00
|
|
|
cl->me_cl->tx_flow_ctrl_creds = 0;
|
2015-06-14 02:18:40 +08:00
|
|
|
|
2015-05-04 14:43:54 +08:00
|
|
|
mei_me_cl_put(cl->me_cl);
|
|
|
|
cl->me_cl = NULL;
|
2015-05-04 14:43:52 +08:00
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:55 +08:00
|
|
|
static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl)
|
|
|
|
{
|
2015-05-04 14:43:56 +08:00
|
|
|
if (!mei_me_cl_get(me_cl))
|
2015-05-04 14:43:55 +08:00
|
|
|
return -ENOENT;
|
|
|
|
|
2015-05-04 14:43:56 +08:00
|
|
|
/* only one connection is allowed for fixed address clients */
|
|
|
|
if (me_cl->props.fixed_address) {
|
|
|
|
if (me_cl->connect_count) {
|
|
|
|
mei_me_cl_put(me_cl);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cl->me_cl = me_cl;
|
2015-05-04 14:43:55 +08:00
|
|
|
cl->state = MEI_FILE_CONNECTING;
|
|
|
|
cl->me_cl->connect_count++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
/*
|
|
|
|
* mei_cl_send_disconnect - send disconnect request
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @cb: callback block
|
|
|
|
*
|
|
|
|
* Return: 0, OK; otherwise, error.
|
|
|
|
*/
|
|
|
|
static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb)
|
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
ret = mei_hbm_cl_disconnect_req(dev, cl);
|
|
|
|
cl->status = ret;
|
|
|
|
if (ret) {
|
|
|
|
cl->state = MEI_FILE_DISCONNECT_REPLY;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list);
|
2015-05-04 14:43:52 +08:00
|
|
|
cl->timer_count = MEI_CONNECT_TIMEOUT;
|
2016-09-25 18:25:31 +08:00
|
|
|
mei_schedule_stall_timer(dev);
|
2015-05-04 14:43:52 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_irq_disconnect - processes close related operation from
|
|
|
|
* interrupt thread context - send disconnect request
|
|
|
|
*
|
|
|
|
* @cl: client
|
|
|
|
* @cb: callback block.
|
|
|
|
* @cmpl_list: complete list.
|
|
|
|
*
|
|
|
|
* Return: 0, OK; otherwise, error.
|
|
|
|
*/
|
|
|
|
int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,
|
2017-01-27 22:32:45 +08:00
|
|
|
struct list_head *cmpl_list)
|
2015-05-04 14:43:52 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
u32 msg_slots;
|
|
|
|
int slots;
|
|
|
|
int ret;
|
|
|
|
|
2018-07-31 14:35:33 +08:00
|
|
|
msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request));
|
2015-05-04 14:43:52 +08:00
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
2018-07-12 22:10:08 +08:00
|
|
|
if (slots < 0)
|
|
|
|
return -EOVERFLOW;
|
2015-05-04 14:43:52 +08:00
|
|
|
|
2018-07-12 22:10:08 +08:00
|
|
|
if ((u32)slots < msg_slots)
|
2015-05-04 14:43:52 +08:00
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
ret = mei_cl_send_disconnect(cl, cb);
|
|
|
|
if (ret)
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, cmpl_list);
|
2015-05-04 14:43:52 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:13 +08:00
|
|
|
/**
|
2015-07-24 02:37:13 +08:00
|
|
|
* __mei_cl_disconnect - disconnect host client from the me one
|
|
|
|
* internal function runtime pm has to be already acquired
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2013-01-09 05:07:14 +08:00
|
|
|
* @cl: host client
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: 0 on success, <0 on failure.
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2015-07-24 02:37:13 +08:00
|
|
|
static int __mei_cl_disconnect(struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2013-01-09 05:07:14 +08:00
|
|
|
struct mei_device *dev;
|
2013-01-09 05:07:13 +08:00
|
|
|
struct mei_cl_cb *cb;
|
2014-07-17 15:53:38 +08:00
|
|
|
int rets;
|
2013-01-09 05:07:13 +08:00
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
cl->state = MEI_FILE_DISCONNECTING;
|
|
|
|
|
2016-07-26 06:06:05 +08:00
|
|
|
cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL);
|
|
|
|
if (!cb) {
|
|
|
|
rets = -ENOMEM;
|
2015-05-04 14:43:52 +08:00
|
|
|
goto out;
|
2016-07-26 06:06:05 +08:00
|
|
|
}
|
2014-08-21 19:29:17 +08:00
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
if (mei_hbuf_acquire(dev)) {
|
2015-05-04 14:43:52 +08:00
|
|
|
rets = mei_cl_send_disconnect(cl, cb);
|
|
|
|
if (rets) {
|
2013-09-15 23:11:07 +08:00
|
|
|
cl_err(dev, cl, "failed to disconnect.\n");
|
2015-05-04 14:43:52 +08:00
|
|
|
goto out;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
mutex_unlock(&dev->device_lock);
|
2016-04-20 23:03:55 +08:00
|
|
|
wait_event_timeout(cl->wait,
|
|
|
|
cl->state == MEI_FILE_DISCONNECT_REPLY ||
|
|
|
|
cl->state == MEI_FILE_DISCONNECTED,
|
2015-05-04 14:43:52 +08:00
|
|
|
mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
|
2013-01-09 05:07:13 +08:00
|
|
|
mutex_lock(&dev->device_lock);
|
2014-07-17 15:53:38 +08:00
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
rets = cl->status;
|
2016-04-20 23:03:55 +08:00
|
|
|
if (cl->state != MEI_FILE_DISCONNECT_REPLY &&
|
|
|
|
cl->state != MEI_FILE_DISCONNECTED) {
|
2014-07-17 15:53:38 +08:00
|
|
|
cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");
|
|
|
|
rets = -ETIME;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
out:
|
|
|
|
/* we disconnect also on error */
|
|
|
|
mei_cl_set_disconnected(cl);
|
|
|
|
if (!rets)
|
|
|
|
cl_dbg(dev, cl, "successfully disconnected from FW client.\n");
|
|
|
|
|
2015-07-24 02:37:13 +08:00
|
|
|
mei_io_cb_free(cb);
|
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_disconnect - disconnect host client from the me one
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* Return: 0 on success, <0 on failure.
|
|
|
|
*/
|
|
|
|
int mei_cl_disconnect(struct mei_cl *cl)
|
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
int rets;
|
|
|
|
|
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
cl_dbg(dev, cl, "disconnecting");
|
|
|
|
|
|
|
|
if (!mei_cl_is_connected(cl))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (mei_cl_is_fixed_address(cl)) {
|
|
|
|
mei_cl_set_disconnected(cl);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-14 20:03:29 +08:00
|
|
|
if (dev->dev_state == MEI_DEV_POWER_DOWN) {
|
|
|
|
cl_dbg(dev, cl, "Device is powering down, don't bother with disconnection\n");
|
|
|
|
mei_cl_set_disconnected(cl);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-24 02:37:13 +08:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
|
|
|
pm_runtime_put_noidle(dev->dev);
|
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
rets = __mei_cl_disconnect(cl);
|
|
|
|
|
2014-03-19 04:52:04 +08:00
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
|
2013-01-09 05:07:13 +08:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2013-01-09 05:07:14 +08:00
|
|
|
* mei_cl_is_other_connecting - checks if other
|
|
|
|
* client with the same me client id is connecting
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
|
|
|
* @cl: private data of the file object
|
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: true if other client is connected, false - otherwise.
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2015-05-04 14:43:53 +08:00
|
|
|
static bool mei_cl_is_other_connecting(struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2013-01-09 05:07:14 +08:00
|
|
|
struct mei_device *dev;
|
2015-05-04 14:43:53 +08:00
|
|
|
struct mei_cl_cb *cb;
|
2013-01-09 05:07:14 +08:00
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2017-01-27 22:32:45 +08:00
|
|
|
list_for_each_entry(cb, &dev->ctrl_rd_list, list) {
|
2015-05-04 14:43:53 +08:00
|
|
|
if (cb->fop_type == MEI_FOP_CONNECT &&
|
2015-05-04 14:43:54 +08:00
|
|
|
mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))
|
2013-01-09 05:07:14 +08:00
|
|
|
return true;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
2013-01-09 05:07:14 +08:00
|
|
|
|
|
|
|
return false;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:53 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_send_connect - send connect request
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @cb: callback block
|
|
|
|
*
|
|
|
|
* Return: 0, OK; otherwise, error.
|
|
|
|
*/
|
|
|
|
static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb)
|
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
ret = mei_hbm_cl_connect_req(dev, cl);
|
|
|
|
cl->status = ret;
|
|
|
|
if (ret) {
|
|
|
|
cl->state = MEI_FILE_DISCONNECT_REPLY;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list);
|
2015-05-04 14:43:53 +08:00
|
|
|
cl->timer_count = MEI_CONNECT_TIMEOUT;
|
2016-09-25 18:25:31 +08:00
|
|
|
mei_schedule_stall_timer(dev);
|
2015-05-04 14:43:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_irq_connect - send connect request in irq_thread context
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @cb: callback block
|
|
|
|
* @cmpl_list: complete list
|
|
|
|
*
|
|
|
|
* Return: 0, OK; otherwise, error.
|
|
|
|
*/
|
|
|
|
int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,
|
2017-01-27 22:32:45 +08:00
|
|
|
struct list_head *cmpl_list)
|
2015-05-04 14:43:53 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
u32 msg_slots;
|
|
|
|
int slots;
|
|
|
|
int rets;
|
|
|
|
|
|
|
|
if (mei_cl_is_other_connecting(cl))
|
|
|
|
return 0;
|
|
|
|
|
2018-07-31 14:35:33 +08:00
|
|
|
msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request));
|
2018-07-12 22:10:08 +08:00
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
|
|
|
if (slots < 0)
|
|
|
|
return -EOVERFLOW;
|
|
|
|
|
|
|
|
if ((u32)slots < msg_slots)
|
2015-05-04 14:43:53 +08:00
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
rets = mei_cl_send_connect(cl, cb);
|
|
|
|
if (rets)
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, cmpl_list);
|
2015-05-04 14:43:53 +08:00
|
|
|
|
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:15 +08:00
|
|
|
/**
|
2014-01-09 04:31:46 +08:00
|
|
|
* mei_cl_connect - connect host client to the me one
|
2013-01-09 05:07:15 +08:00
|
|
|
*
|
|
|
|
* @cl: host client
|
2015-05-04 14:43:54 +08:00
|
|
|
* @me_cl: me client
|
2016-07-26 06:06:05 +08:00
|
|
|
* @fp: pointer to file structure
|
2013-01-09 05:07:15 +08:00
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: 0 on success, <0 on failure.
|
2013-01-09 05:07:15 +08:00
|
|
|
*/
|
2015-05-04 14:43:54 +08:00
|
|
|
int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
|
2016-07-26 06:06:05 +08:00
|
|
|
const struct file *fp)
|
2013-01-09 05:07:15 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
int rets;
|
|
|
|
|
2015-05-04 14:43:56 +08:00
|
|
|
if (WARN_ON(!cl || !cl->dev || !me_cl))
|
2013-01-09 05:07:15 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-05-04 14:43:56 +08:00
|
|
|
rets = mei_cl_set_connecting(cl, me_cl);
|
|
|
|
if (rets)
|
2017-01-27 22:32:39 +08:00
|
|
|
goto nortpm;
|
2015-05-04 14:43:56 +08:00
|
|
|
|
|
|
|
if (mei_cl_is_fixed_address(cl)) {
|
|
|
|
cl->state = MEI_FILE_CONNECTED;
|
2017-01-27 22:32:39 +08:00
|
|
|
rets = 0;
|
|
|
|
goto nortpm;
|
2015-05-04 14:43:56 +08:00
|
|
|
}
|
|
|
|
|
2014-09-29 21:31:42 +08:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_put_noidle(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
2015-05-04 14:43:56 +08:00
|
|
|
goto nortpm;
|
2014-03-19 04:52:04 +08:00
|
|
|
}
|
|
|
|
|
2016-07-26 06:06:05 +08:00
|
|
|
cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp);
|
|
|
|
if (!cb) {
|
|
|
|
rets = -ENOMEM;
|
2013-01-09 05:07:15 +08:00
|
|
|
goto out;
|
2016-07-26 06:06:05 +08:00
|
|
|
}
|
2015-05-04 14:43:53 +08:00
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
/* run hbuf acquire last so we don't have to undo */
|
|
|
|
if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) {
|
2015-05-04 14:43:53 +08:00
|
|
|
rets = mei_cl_send_connect(cl, cb);
|
|
|
|
if (rets)
|
2013-01-09 05:07:15 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
2014-08-21 19:29:18 +08:00
|
|
|
wait_event_timeout(cl->wait,
|
2014-02-17 21:13:20 +08:00
|
|
|
(cl->state == MEI_FILE_CONNECTED ||
|
2016-04-20 23:03:55 +08:00
|
|
|
cl->state == MEI_FILE_DISCONNECTED ||
|
2015-07-24 02:37:13 +08:00
|
|
|
cl->state == MEI_FILE_DISCONNECT_REQUIRED ||
|
2015-05-04 14:43:52 +08:00
|
|
|
cl->state == MEI_FILE_DISCONNECT_REPLY),
|
2014-02-17 21:13:20 +08:00
|
|
|
mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
|
2013-01-09 05:07:15 +08:00
|
|
|
mutex_lock(&dev->device_lock);
|
|
|
|
|
2015-03-27 06:27:58 +08:00
|
|
|
if (!mei_cl_is_connected(cl)) {
|
2015-07-24 02:37:13 +08:00
|
|
|
if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) {
|
2017-01-27 22:32:46 +08:00
|
|
|
mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);
|
2015-07-24 02:37:13 +08:00
|
|
|
/* ignore disconnect return valuue;
|
|
|
|
* in case of failure reset will be invoked
|
|
|
|
*/
|
|
|
|
__mei_cl_disconnect(cl);
|
|
|
|
rets = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-05-04 14:43:53 +08:00
|
|
|
/* timeout or something went really wrong */
|
2014-02-17 21:13:20 +08:00
|
|
|
if (!cl->status)
|
|
|
|
cl->status = -EFAULT;
|
2013-01-09 05:07:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
rets = cl->status;
|
|
|
|
out:
|
2014-03-19 04:52:04 +08:00
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
|
2013-01-09 05:07:15 +08:00
|
|
|
mei_io_cb_free(cb);
|
2015-05-04 14:43:53 +08:00
|
|
|
|
2015-05-04 14:43:56 +08:00
|
|
|
nortpm:
|
2015-05-04 14:43:53 +08:00
|
|
|
if (!mei_cl_is_connected(cl))
|
|
|
|
mei_cl_set_disconnected(cl);
|
|
|
|
|
2013-01-09 05:07:15 +08:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2015-02-10 16:39:44 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_alloc_linked - allocate and link host client
|
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
*
|
|
|
|
* Return: cl on success ERR_PTR on failure
|
|
|
|
*/
|
2016-02-08 05:35:40 +08:00
|
|
|
struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev)
|
2015-02-10 16:39:44 +08:00
|
|
|
{
|
|
|
|
struct mei_cl *cl;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
cl = mei_cl_allocate(dev);
|
|
|
|
if (!cl) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2016-02-08 05:35:40 +08:00
|
|
|
ret = mei_cl_link(cl);
|
2015-02-10 16:39:44 +08:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return cl;
|
|
|
|
err:
|
|
|
|
kfree(cl);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
2013-01-09 05:07:13 +08:00
|
|
|
/**
|
2016-07-26 06:06:04 +08:00
|
|
|
* mei_cl_tx_flow_ctrl_creds - checks flow_control credits for cl.
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2016-02-08 05:35:37 +08:00
|
|
|
* @cl: host client
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2016-07-26 06:06:04 +08:00
|
|
|
* Return: 1 if tx_flow_ctrl_creds >0, 0 - otherwise.
|
2013-01-09 05:07:13 +08:00
|
|
|
*/
|
2016-07-26 06:06:04 +08:00
|
|
|
static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2015-05-04 14:43:54 +08:00
|
|
|
if (WARN_ON(!cl || !cl->me_cl))
|
2013-01-09 05:07:14 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-07-26 06:06:04 +08:00
|
|
|
if (cl->tx_flow_ctrl_creds > 0)
|
2013-01-09 05:07:13 +08:00
|
|
|
return 1;
|
|
|
|
|
2016-06-16 22:58:58 +08:00
|
|
|
if (mei_cl_is_fixed_address(cl))
|
2015-05-04 14:43:56 +08:00
|
|
|
return 1;
|
|
|
|
|
2015-05-04 14:43:54 +08:00
|
|
|
if (mei_cl_is_single_recv_buf(cl)) {
|
2016-07-26 06:06:04 +08:00
|
|
|
if (cl->me_cl->tx_flow_ctrl_creds > 0)
|
2015-05-04 14:43:54 +08:00
|
|
|
return 1;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
2015-05-04 14:43:54 +08:00
|
|
|
return 0;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-26 06:06:04 +08:00
|
|
|
* mei_cl_tx_flow_ctrl_creds_reduce - reduces transmit flow control credits
|
|
|
|
* for a client
|
2013-01-09 05:07:13 +08:00
|
|
|
*
|
2016-07-26 06:06:04 +08:00
|
|
|
* @cl: host client
|
2013-04-05 00:05:05 +08:00
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return:
|
2013-01-09 05:07:13 +08:00
|
|
|
* 0 on success
|
|
|
|
* -EINVAL when ctrl credits are <= 0
|
|
|
|
*/
|
2016-07-26 06:06:04 +08:00
|
|
|
static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl)
|
2013-01-09 05:07:13 +08:00
|
|
|
{
|
2015-05-04 14:43:54 +08:00
|
|
|
if (WARN_ON(!cl || !cl->me_cl))
|
2013-01-09 05:07:14 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2015-05-04 14:43:56 +08:00
|
|
|
if (mei_cl_is_fixed_address(cl))
|
|
|
|
return 0;
|
|
|
|
|
2015-05-04 14:43:54 +08:00
|
|
|
if (mei_cl_is_single_recv_buf(cl)) {
|
2016-07-26 06:06:04 +08:00
|
|
|
if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0))
|
2015-05-04 14:43:54 +08:00
|
|
|
return -EINVAL;
|
2016-07-26 06:06:04 +08:00
|
|
|
cl->me_cl->tx_flow_ctrl_creds--;
|
2014-02-17 21:13:23 +08:00
|
|
|
} else {
|
2016-07-26 06:06:04 +08:00
|
|
|
if (WARN_ON(cl->tx_flow_ctrl_creds <= 0))
|
2015-05-04 14:43:54 +08:00
|
|
|
return -EINVAL;
|
2016-07-26 06:06:04 +08:00
|
|
|
cl->tx_flow_ctrl_creds--;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
2015-05-04 14:43:54 +08:00
|
|
|
return 0;
|
2013-01-09 05:07:13 +08:00
|
|
|
}
|
|
|
|
|
2015-07-26 14:54:18 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_notify_fop2req - convert fop to proper request
|
|
|
|
*
|
|
|
|
* @fop: client notification start response command
|
|
|
|
*
|
|
|
|
* Return: MEI_HBM_NOTIFICATION_START/STOP
|
|
|
|
*/
|
|
|
|
u8 mei_cl_notify_fop2req(enum mei_cb_file_ops fop)
|
|
|
|
{
|
|
|
|
if (fop == MEI_FOP_NOTIFY_START)
|
|
|
|
return MEI_HBM_NOTIFICATION_START;
|
|
|
|
else
|
|
|
|
return MEI_HBM_NOTIFICATION_STOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_notify_req2fop - convert notification request top file operation type
|
|
|
|
*
|
|
|
|
* @req: hbm notification request type
|
|
|
|
*
|
|
|
|
* Return: MEI_FOP_NOTIFY_START/STOP
|
|
|
|
*/
|
|
|
|
enum mei_cb_file_ops mei_cl_notify_req2fop(u8 req)
|
|
|
|
{
|
|
|
|
if (req == MEI_HBM_NOTIFICATION_START)
|
|
|
|
return MEI_FOP_NOTIFY_START;
|
|
|
|
else
|
|
|
|
return MEI_FOP_NOTIFY_STOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_irq_notify - send notification request in irq_thread context
|
|
|
|
*
|
|
|
|
* @cl: client
|
|
|
|
* @cb: callback block.
|
|
|
|
* @cmpl_list: complete list.
|
|
|
|
*
|
|
|
|
* Return: 0 on such and error otherwise.
|
|
|
|
*/
|
|
|
|
int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,
|
2017-01-27 22:32:45 +08:00
|
|
|
struct list_head *cmpl_list)
|
2015-07-26 14:54:18 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
u32 msg_slots;
|
|
|
|
int slots;
|
|
|
|
int ret;
|
|
|
|
bool request;
|
|
|
|
|
2018-07-31 14:35:33 +08:00
|
|
|
msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request));
|
2015-07-26 14:54:18 +08:00
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
2018-07-12 22:10:08 +08:00
|
|
|
if (slots < 0)
|
|
|
|
return -EOVERFLOW;
|
2015-07-26 14:54:18 +08:00
|
|
|
|
2018-07-12 22:10:08 +08:00
|
|
|
if ((u32)slots < msg_slots)
|
2015-07-26 14:54:18 +08:00
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
request = mei_cl_notify_fop2req(cb->fop_type);
|
|
|
|
ret = mei_hbm_cl_notify_req(dev, cl, request);
|
|
|
|
if (ret) {
|
|
|
|
cl->status = ret;
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, cmpl_list);
|
2015-07-26 14:54:18 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list);
|
2015-07-26 14:54:18 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_notify_request - send notification stop/start request
|
|
|
|
*
|
|
|
|
* @cl: host client
|
2016-07-26 06:06:05 +08:00
|
|
|
* @fp: associate request with file
|
2015-07-26 14:54:18 +08:00
|
|
|
* @request: 1 for start or 0 for stop
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* Return: 0 on such and error otherwise.
|
|
|
|
*/
|
2016-02-08 05:35:23 +08:00
|
|
|
int mei_cl_notify_request(struct mei_cl *cl,
|
2016-07-26 06:06:05 +08:00
|
|
|
const struct file *fp, u8 request)
|
2015-07-26 14:54:18 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
enum mei_cb_file_ops fop_type;
|
|
|
|
int rets;
|
|
|
|
|
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
if (!dev->hbm_f_ev_supported) {
|
|
|
|
cl_dbg(dev, cl, "notifications not supported\n");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2017-01-27 22:32:41 +08:00
|
|
|
if (!mei_cl_is_connected(cl))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2015-07-26 14:54:18 +08:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
|
|
|
pm_runtime_put_noidle(dev->dev);
|
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
fop_type = mei_cl_notify_req2fop(request);
|
2016-07-26 06:06:05 +08:00
|
|
|
cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp);
|
2015-07-26 14:54:18 +08:00
|
|
|
if (!cb) {
|
|
|
|
rets = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mei_hbuf_acquire(dev)) {
|
|
|
|
if (mei_hbm_cl_notify_req(dev, cl, request)) {
|
|
|
|
rets = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list);
|
2015-07-26 14:54:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
2016-04-20 23:03:55 +08:00
|
|
|
wait_event_timeout(cl->wait,
|
2018-11-06 18:04:40 +08:00
|
|
|
cl->notify_en == request ||
|
|
|
|
cl->status ||
|
|
|
|
!mei_cl_is_connected(cl),
|
2016-04-20 23:03:55 +08:00
|
|
|
mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
|
2015-07-26 14:54:18 +08:00
|
|
|
mutex_lock(&dev->device_lock);
|
|
|
|
|
2016-04-20 23:03:54 +08:00
|
|
|
if (cl->notify_en != request && !cl->status)
|
|
|
|
cl->status = -EFAULT;
|
2015-07-26 14:54:18 +08:00
|
|
|
|
|
|
|
rets = cl->status;
|
|
|
|
|
|
|
|
out:
|
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
|
|
|
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2015-07-26 14:54:22 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_notify - raise notification
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*/
|
|
|
|
void mei_cl_notify(struct mei_cl *cl)
|
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
|
|
|
|
if (!cl || !cl->dev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
if (!cl->notify_en)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cl_dbg(dev, cl, "notify event");
|
|
|
|
cl->notify_ev = true;
|
2016-02-08 05:35:31 +08:00
|
|
|
if (!mei_cl_bus_notify_event(cl))
|
|
|
|
wake_up_interruptible(&cl->ev_wait);
|
2015-07-26 14:54:22 +08:00
|
|
|
|
|
|
|
if (cl->ev_async)
|
|
|
|
kill_fasync(&cl->ev_async, SIGIO, POLL_PRI);
|
2015-07-26 14:54:23 +08:00
|
|
|
|
2015-07-26 14:54:22 +08:00
|
|
|
}
|
|
|
|
|
2015-07-26 14:54:19 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_notify_get - get or wait for notification event
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @block: this request is blocking
|
|
|
|
* @notify_ev: true if notification event was received
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* Return: 0 on such and error otherwise.
|
|
|
|
*/
|
|
|
|
int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev)
|
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
int rets;
|
|
|
|
|
|
|
|
*notify_ev = false;
|
|
|
|
|
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2017-01-27 22:32:42 +08:00
|
|
|
if (!dev->hbm_f_ev_supported) {
|
|
|
|
cl_dbg(dev, cl, "notifications not supported\n");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2015-07-26 14:54:19 +08:00
|
|
|
if (!mei_cl_is_connected(cl))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (cl->notify_ev)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!block)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
|
|
|
rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev);
|
|
|
|
mutex_lock(&dev->device_lock);
|
|
|
|
|
|
|
|
if (rets < 0)
|
|
|
|
return rets;
|
|
|
|
|
|
|
|
out:
|
|
|
|
*notify_ev = cl->notify_ev;
|
|
|
|
cl->notify_ev = false;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
/**
|
2013-04-05 00:05:05 +08:00
|
|
|
* mei_cl_read_start - the start read client message function.
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
*
|
2013-01-09 05:07:14 +08:00
|
|
|
* @cl: host client
|
2014-09-29 21:31:50 +08:00
|
|
|
* @length: number of bytes to read
|
2015-02-10 16:39:43 +08:00
|
|
|
* @fp: pointer to file structure
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: 0 on success, <0 on failure.
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
*/
|
2016-02-08 05:35:23 +08:00
|
|
|
int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp)
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
{
|
2013-01-09 05:07:14 +08:00
|
|
|
struct mei_device *dev;
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
struct mei_cl_cb *cb;
|
2012-10-11 22:35:08 +08:00
|
|
|
int rets;
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
|
2013-01-09 05:07:14 +08:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2013-07-26 01:15:53 +08:00
|
|
|
if (!mei_cl_is_connected(cl))
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2015-05-04 14:43:54 +08:00
|
|
|
if (!mei_me_cl_is_active(cl->me_cl)) {
|
|
|
|
cl_err(dev, cl, "no such me client\n");
|
2014-02-19 23:35:49 +08:00
|
|
|
return -ENOTTY;
|
2012-10-11 22:35:08 +08:00
|
|
|
}
|
2015-05-04 14:43:56 +08:00
|
|
|
|
2017-03-20 21:04:03 +08:00
|
|
|
if (mei_cl_is_fixed_address(cl))
|
2016-07-26 06:06:02 +08:00
|
|
|
return 0;
|
|
|
|
|
2016-07-26 06:06:03 +08:00
|
|
|
/* HW currently supports only one pending read */
|
|
|
|
if (cl->rx_flow_ctrl_creds)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2016-07-26 06:06:05 +08:00
|
|
|
cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp);
|
2015-05-04 14:43:56 +08:00
|
|
|
if (!cb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-09-29 21:31:42 +08:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_put_noidle(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
2015-05-04 14:43:56 +08:00
|
|
|
goto nortpm;
|
2014-03-19 04:52:04 +08:00
|
|
|
}
|
|
|
|
|
2016-07-26 06:06:03 +08:00
|
|
|
rets = 0;
|
2014-02-19 23:35:47 +08:00
|
|
|
if (mei_hbuf_acquire(dev)) {
|
2014-03-31 22:59:24 +08:00
|
|
|
rets = mei_hbm_cl_flow_control_req(dev, cl);
|
|
|
|
if (rets < 0)
|
2014-03-19 04:52:04 +08:00
|
|
|
goto out;
|
|
|
|
|
2016-07-26 06:06:03 +08:00
|
|
|
list_move_tail(&cb->list, &cl->rd_pending);
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
}
|
2016-07-26 06:06:03 +08:00
|
|
|
cl->rx_flow_ctrl_creds++;
|
2014-02-13 03:27:25 +08:00
|
|
|
|
2014-03-19 04:52:04 +08:00
|
|
|
out:
|
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2015-05-04 14:43:56 +08:00
|
|
|
nortpm:
|
2014-03-19 04:52:04 +08:00
|
|
|
if (rets)
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
|
staging/mei: PCI device and char driver support.
contains module entries and PCI driver and char device
definitions (using file_operations, pci_driver struts).
The HW interface is exposed on PCI interface.
PCI:
The MEI HW resources are memory map 32 bit registers
(Host and ME Status Registers and Data Registers)
and interrupt (shared, with Intel GFX on some chipsets
and USB2 controller on others).
The device is part of the chipsets and cannot be hotplugged.
The MEI device present is determined by BIOS configuration.
Probe:
The driver starts the init MEI flow, that is explained
in the patch "MEI driver init flow" [06/10],
then schedules a timer that handles
timeouts and watchdog heartbeats.
Remove:
The driver closes all connections and stops the watchdog.
The driver expose char device that supports:
open, release, write, read, ioctl, poll.
Open:
Upon open the driver allocates HOST data structure
on behalf of application which will resides in the file's
private data and assign a host ID number which
will identify messages between driver client instance
and MEI client.
The driver also checks readiness of the device. The number
of simultaneously opened instances is limited to 253.
(255 - (amthi + watchdog))
Release:
In release the driver sends a Disconnect Command to
ME feature and clean all the data structs.
IOCTL:
MEI adds new IOCTL: (IOCTL_MEI_CONNECT_CLIENT)
The IOCTL links the current file descriptor to ME feature.
This is done by sending MEI Bus command: 'hbm_client_connect_request'
to the ME and waiting for an answer :'hbm_client_connect_response'.
Upon answer reception the driver updates its and HOST data
structures in file structure to indicate that the file
descriptor is associated to ME feature.
Each ME feature is represented by UUID which is given as
an input parameter to the IOCTL, upon success connect command the
IOCTL will return the ME feature properties.
ME can reject CONNECT commands due to several reasons,
most common are:
Invalid UUID ME or feature does not exists in ME.
No More Connection allowed to this is feature,
usually only one connection is allowed.
Write:
Upon write, the driver splits the user data into several MEI
messages up to 512 bytes each and sends it to the HW.
If the user wants to write data to AMTHI ME feature then the
drivers routes the messages through AMTHI queues.
Read:
In read the driver checks is a connection exists to
current file descriptor and then wait until a data is available.
Message might be received (by interrupt from ME) in multiple chunks.
Only complete message is released to the application.
Poll:
Nothing special here. Waiting for see if we have
data available for reading.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Itzhak Tzeel-Krupp <itzhak.tzeel-krupp@intel.com>
Signed-off-by: Oren Weil <oren.jer.weil@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-05-15 18:43:41 +08:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2018-07-23 18:21:24 +08:00
|
|
|
/**
|
|
|
|
* mei_msg_hdr_init - initialize mei message header
|
|
|
|
*
|
|
|
|
* @mei_hdr: mei message header
|
|
|
|
* @cb: message callback structure
|
|
|
|
*/
|
|
|
|
static void mei_msg_hdr_init(struct mei_msg_hdr *mei_hdr, struct mei_cl_cb *cb)
|
|
|
|
{
|
|
|
|
mei_hdr->host_addr = mei_cl_host_addr(cb->cl);
|
|
|
|
mei_hdr->me_addr = mei_cl_me_id(cb->cl);
|
|
|
|
mei_hdr->length = 0;
|
|
|
|
mei_hdr->reserved = 0;
|
|
|
|
mei_hdr->msg_complete = 0;
|
2018-07-31 14:35:35 +08:00
|
|
|
mei_hdr->dma_ring = 0;
|
2018-07-23 18:21:24 +08:00
|
|
|
mei_hdr->internal = cb->internal;
|
|
|
|
}
|
|
|
|
|
2013-06-23 14:36:59 +08:00
|
|
|
/**
|
2014-02-19 23:35:48 +08:00
|
|
|
* mei_cl_irq_write - write a message to device
|
2013-06-23 14:36:59 +08:00
|
|
|
* from the interrupt thread context
|
|
|
|
*
|
|
|
|
* @cl: client
|
|
|
|
* @cb: callback block.
|
|
|
|
* @cmpl_list: complete list.
|
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: 0, OK; otherwise error.
|
2013-06-23 14:36:59 +08:00
|
|
|
*/
|
2014-02-19 23:35:48 +08:00
|
|
|
int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
|
2017-01-27 22:32:45 +08:00
|
|
|
struct list_head *cmpl_list)
|
2013-06-23 14:36:59 +08:00
|
|
|
{
|
2013-09-17 04:44:44 +08:00
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_msg_data *buf;
|
2013-06-23 14:36:59 +08:00
|
|
|
struct mei_msg_hdr mei_hdr;
|
2018-07-31 14:35:33 +08:00
|
|
|
size_t hdr_len = sizeof(mei_hdr);
|
2013-09-17 04:44:44 +08:00
|
|
|
size_t len;
|
2018-11-22 19:11:40 +08:00
|
|
|
size_t hbuf_len, dr_len;
|
2018-07-23 18:21:23 +08:00
|
|
|
int hbuf_slots;
|
2018-11-22 19:11:40 +08:00
|
|
|
u32 dr_slots;
|
|
|
|
u32 dma_len;
|
2013-09-17 04:44:43 +08:00
|
|
|
int rets;
|
2015-05-07 20:53:58 +08:00
|
|
|
bool first_chunk;
|
2018-11-22 19:11:40 +08:00
|
|
|
const void *data;
|
2013-06-23 14:36:59 +08:00
|
|
|
|
2013-09-17 04:44:44 +08:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-02-10 16:39:42 +08:00
|
|
|
buf = &cb->buf;
|
2013-09-17 04:44:44 +08:00
|
|
|
|
2015-05-07 20:53:58 +08:00
|
|
|
first_chunk = cb->buf_idx == 0;
|
|
|
|
|
2016-07-26 06:06:04 +08:00
|
|
|
rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1;
|
2013-09-17 04:44:44 +08:00
|
|
|
if (rets < 0)
|
2016-12-14 23:56:52 +08:00
|
|
|
goto err;
|
2013-09-17 04:44:44 +08:00
|
|
|
|
|
|
|
if (rets == 0) {
|
2014-03-19 04:52:04 +08:00
|
|
|
cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
|
2013-09-17 04:44:44 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-07-23 18:21:23 +08:00
|
|
|
len = buf->size - cb->buf_idx;
|
2018-11-22 19:11:40 +08:00
|
|
|
data = buf->data + cb->buf_idx;
|
2018-07-23 18:21:23 +08:00
|
|
|
hbuf_slots = mei_hbuf_empty_slots(dev);
|
|
|
|
if (hbuf_slots < 0) {
|
|
|
|
rets = -EOVERFLOW;
|
|
|
|
goto err;
|
|
|
|
}
|
2018-07-31 14:35:33 +08:00
|
|
|
|
2020-02-12 00:05:22 +08:00
|
|
|
hbuf_len = mei_slots2data(hbuf_slots) & MEI_MSG_MAX_LEN_MASK;
|
2018-11-22 19:11:40 +08:00
|
|
|
dr_slots = mei_dma_ring_empty_slots(dev);
|
|
|
|
dr_len = mei_slots2data(dr_slots);
|
2018-07-23 18:21:23 +08:00
|
|
|
|
2018-07-23 18:21:24 +08:00
|
|
|
mei_msg_hdr_init(&mei_hdr, cb);
|
|
|
|
|
2018-07-23 18:21:23 +08:00
|
|
|
/**
|
|
|
|
* Split the message only if we can write the whole host buffer
|
|
|
|
* otherwise wait for next time the host buffer is empty.
|
|
|
|
*/
|
2018-07-31 14:35:33 +08:00
|
|
|
if (len + hdr_len <= hbuf_len) {
|
2013-06-23 14:36:59 +08:00
|
|
|
mei_hdr.length = len;
|
|
|
|
mei_hdr.msg_complete = 1;
|
2018-11-22 19:11:40 +08:00
|
|
|
} else if (dr_slots && hbuf_len >= hdr_len + sizeof(dma_len)) {
|
|
|
|
mei_hdr.dma_ring = 1;
|
|
|
|
if (len > dr_len)
|
|
|
|
len = dr_len;
|
|
|
|
else
|
|
|
|
mei_hdr.msg_complete = 1;
|
|
|
|
|
|
|
|
mei_hdr.length = sizeof(dma_len);
|
|
|
|
dma_len = len;
|
|
|
|
data = &dma_len;
|
2018-07-23 18:21:23 +08:00
|
|
|
} else if ((u32)hbuf_slots == mei_hbuf_depth(dev)) {
|
2018-11-22 19:11:40 +08:00
|
|
|
len = hbuf_len - hdr_len;
|
|
|
|
mei_hdr.length = len;
|
2013-06-23 14:36:59 +08:00
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-22 19:11:40 +08:00
|
|
|
if (mei_hdr.dma_ring)
|
|
|
|
mei_dma_ring_write(dev, buf->data + cb->buf_idx, len);
|
2013-06-23 14:36:59 +08:00
|
|
|
|
2018-11-22 19:11:40 +08:00
|
|
|
rets = mei_write_message(dev, &mei_hdr, hdr_len, data, mei_hdr.length);
|
2016-12-14 23:56:52 +08:00
|
|
|
if (rets)
|
|
|
|
goto err;
|
2013-06-23 14:36:59 +08:00
|
|
|
|
|
|
|
cl->status = 0;
|
2013-06-23 14:37:00 +08:00
|
|
|
cl->writing_state = MEI_WRITING;
|
2018-11-22 19:11:40 +08:00
|
|
|
cb->buf_idx += len;
|
2013-06-23 14:37:00 +08:00
|
|
|
|
2015-05-07 20:53:58 +08:00
|
|
|
if (first_chunk) {
|
2016-12-14 23:56:52 +08:00
|
|
|
if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) {
|
|
|
|
rets = -EIO;
|
|
|
|
goto err;
|
|
|
|
}
|
2013-06-23 14:36:59 +08:00
|
|
|
}
|
|
|
|
|
2015-05-07 20:53:58 +08:00
|
|
|
if (mei_hdr.msg_complete)
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, &dev->write_waiting_list);
|
2015-05-07 20:53:58 +08:00
|
|
|
|
2013-06-23 14:36:59 +08:00
|
|
|
return 0;
|
2016-12-14 23:56:52 +08:00
|
|
|
|
|
|
|
err:
|
|
|
|
cl->status = rets;
|
2017-01-27 22:32:45 +08:00
|
|
|
list_move_tail(&cb->list, cmpl_list);
|
2016-12-14 23:56:52 +08:00
|
|
|
return rets;
|
2013-06-23 14:36:59 +08:00
|
|
|
}
|
|
|
|
|
2013-04-09 02:56:37 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_write - submit a write cb to mei device
|
2014-09-29 21:31:49 +08:00
|
|
|
* assumes device_lock is locked
|
2013-04-09 02:56:37 +08:00
|
|
|
*
|
|
|
|
* @cl: host client
|
2014-09-29 21:31:49 +08:00
|
|
|
* @cb: write callback with filled data
|
2013-04-09 02:56:37 +08:00
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* Return: number of bytes sent on success, <0 on failure.
|
2013-04-09 02:56:37 +08:00
|
|
|
*/
|
2018-07-12 22:10:10 +08:00
|
|
|
ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb)
|
2013-04-09 02:56:37 +08:00
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_msg_data *buf;
|
|
|
|
struct mei_msg_hdr mei_hdr;
|
2018-07-31 14:35:33 +08:00
|
|
|
size_t hdr_len = sizeof(mei_hdr);
|
2018-11-22 19:11:40 +08:00
|
|
|
size_t len, hbuf_len, dr_len;
|
2018-07-23 18:21:23 +08:00
|
|
|
int hbuf_slots;
|
2018-11-22 19:11:40 +08:00
|
|
|
u32 dr_slots;
|
|
|
|
u32 dma_len;
|
2018-07-12 22:10:10 +08:00
|
|
|
ssize_t rets;
|
2016-11-09 00:26:08 +08:00
|
|
|
bool blocking;
|
2018-11-22 19:11:40 +08:00
|
|
|
const void *data;
|
2013-04-09 02:56:37 +08:00
|
|
|
|
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (WARN_ON(!cb))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-02-10 16:39:42 +08:00
|
|
|
buf = &cb->buf;
|
2018-07-12 22:10:10 +08:00
|
|
|
len = buf->size;
|
2013-04-09 02:56:37 +08:00
|
|
|
|
2018-07-12 22:10:10 +08:00
|
|
|
cl_dbg(dev, cl, "len=%zd\n", len);
|
2013-04-09 02:56:37 +08:00
|
|
|
|
2018-11-22 19:11:40 +08:00
|
|
|
blocking = cb->blocking;
|
|
|
|
data = buf->data;
|
|
|
|
|
2014-09-29 21:31:42 +08:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
2014-03-19 04:52:04 +08:00
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_put_noidle(dev->dev);
|
2018-07-12 22:10:10 +08:00
|
|
|
cl_err(dev, cl, "rpm: get failed %zd\n", rets);
|
2016-02-11 05:57:26 +08:00
|
|
|
goto free;
|
2014-03-19 04:52:04 +08:00
|
|
|
}
|
2013-04-09 02:56:37 +08:00
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
cb->buf_idx = 0;
|
|
|
|
cl->writing_state = MEI_IDLE;
|
|
|
|
|
2013-04-09 02:56:37 +08:00
|
|
|
|
2016-07-26 06:06:04 +08:00
|
|
|
rets = mei_cl_tx_flow_ctrl_creds(cl);
|
2013-04-09 02:56:37 +08:00
|
|
|
if (rets < 0)
|
|
|
|
goto err;
|
|
|
|
|
2018-07-23 18:21:24 +08:00
|
|
|
mei_msg_hdr_init(&mei_hdr, cb);
|
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
if (rets == 0) {
|
|
|
|
cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
|
2018-07-12 22:10:10 +08:00
|
|
|
rets = len;
|
2014-02-19 23:35:47 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2018-07-23 18:21:23 +08:00
|
|
|
|
2014-02-19 23:35:47 +08:00
|
|
|
if (!mei_hbuf_acquire(dev)) {
|
|
|
|
cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n");
|
2018-07-12 22:10:10 +08:00
|
|
|
rets = len;
|
2013-04-09 02:56:37 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-07-23 18:21:23 +08:00
|
|
|
hbuf_slots = mei_hbuf_empty_slots(dev);
|
|
|
|
if (hbuf_slots < 0) {
|
|
|
|
rets = -EOVERFLOW;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-02-12 00:05:22 +08:00
|
|
|
hbuf_len = mei_slots2data(hbuf_slots) & MEI_MSG_MAX_LEN_MASK;
|
2018-11-22 19:11:40 +08:00
|
|
|
dr_slots = mei_dma_ring_empty_slots(dev);
|
|
|
|
dr_len = mei_slots2data(dr_slots);
|
2018-07-31 14:35:33 +08:00
|
|
|
|
|
|
|
if (len + hdr_len <= hbuf_len) {
|
2018-07-12 22:10:10 +08:00
|
|
|
mei_hdr.length = len;
|
2013-04-09 02:56:37 +08:00
|
|
|
mei_hdr.msg_complete = 1;
|
2018-11-22 19:11:40 +08:00
|
|
|
} else if (dr_slots && hbuf_len >= hdr_len + sizeof(dma_len)) {
|
|
|
|
mei_hdr.dma_ring = 1;
|
|
|
|
if (len > dr_len)
|
|
|
|
len = dr_len;
|
|
|
|
else
|
|
|
|
mei_hdr.msg_complete = 1;
|
|
|
|
|
|
|
|
mei_hdr.length = sizeof(dma_len);
|
|
|
|
dma_len = len;
|
|
|
|
data = &dma_len;
|
2018-07-23 18:21:23 +08:00
|
|
|
} else {
|
2018-11-22 19:11:40 +08:00
|
|
|
len = hbuf_len - hdr_len;
|
|
|
|
mei_hdr.length = len;
|
2013-04-09 02:56:37 +08:00
|
|
|
}
|
|
|
|
|
2018-11-22 19:11:40 +08:00
|
|
|
if (mei_hdr.dma_ring)
|
|
|
|
mei_dma_ring_write(dev, buf->data, len);
|
|
|
|
|
2018-07-31 14:35:33 +08:00
|
|
|
rets = mei_write_message(dev, &mei_hdr, hdr_len,
|
2018-11-22 19:11:40 +08:00
|
|
|
data, mei_hdr.length);
|
2013-09-17 04:44:43 +08:00
|
|
|
if (rets)
|
2013-04-09 02:56:37 +08:00
|
|
|
goto err;
|
|
|
|
|
2016-07-26 06:06:04 +08:00
|
|
|
rets = mei_cl_tx_flow_ctrl_creds_reduce(cl);
|
2015-05-07 20:53:58 +08:00
|
|
|
if (rets)
|
|
|
|
goto err;
|
|
|
|
|
2013-04-09 02:56:37 +08:00
|
|
|
cl->writing_state = MEI_WRITING;
|
2018-11-22 19:11:40 +08:00
|
|
|
cb->buf_idx = len;
|
|
|
|
/* restore return value */
|
|
|
|
len = buf->size;
|
2013-04-09 02:56:37 +08:00
|
|
|
|
|
|
|
out:
|
2015-05-07 20:53:58 +08:00
|
|
|
if (mei_hdr.msg_complete)
|
2018-02-26 02:07:05 +08:00
|
|
|
mei_tx_cb_enqueue(cb, &dev->write_waiting_list);
|
2015-05-07 20:53:58 +08:00
|
|
|
else
|
2018-02-26 02:07:05 +08:00
|
|
|
mei_tx_cb_enqueue(cb, &dev->write_list);
|
2013-04-09 02:56:37 +08:00
|
|
|
|
2015-07-23 15:43:11 +08:00
|
|
|
cb = NULL;
|
2013-04-09 02:56:37 +08:00
|
|
|
if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
2014-02-19 23:35:49 +08:00
|
|
|
rets = wait_event_interruptible(cl->tx_wait,
|
2016-02-08 05:35:34 +08:00
|
|
|
cl->writing_state == MEI_WRITE_COMPLETE ||
|
|
|
|
(!mei_cl_is_connected(cl)));
|
2013-04-09 02:56:37 +08:00
|
|
|
mutex_lock(&dev->device_lock);
|
2014-02-19 23:35:49 +08:00
|
|
|
/* wait_event_interruptible returns -ERESTARTSYS */
|
|
|
|
if (rets) {
|
|
|
|
if (signal_pending(current))
|
|
|
|
rets = -EINTR;
|
|
|
|
goto err;
|
|
|
|
}
|
2016-02-08 05:35:34 +08:00
|
|
|
if (cl->writing_state != MEI_WRITE_COMPLETE) {
|
|
|
|
rets = -EFAULT;
|
|
|
|
goto err;
|
|
|
|
}
|
2013-04-09 02:56:37 +08:00
|
|
|
}
|
2014-02-19 23:35:49 +08:00
|
|
|
|
mei: fix use-after-free in mei_cl_write
KASAN reports a use-after-free during startup, in mei_cl_write:
BUG: KASAN: use-after-free in mei_cl_write+0x601/0x870 [mei]
(drivers/misc/mei/client.c:1770)
This is caused by commit 98e70866aacb ("mei: add support for variable
length mei headers."), which changed the return value from len, to
buf->size. That ends up using a stale buf pointer, because blocking
call, the cb (callback) is deleted in me_cl_complete() function.
However, fortunately, len remains unchanged throughout the function
(and I don't see anything else that would require re-reading buf->size
either), so the fix is to simply revert the change, and return len, as
before.
Fixes: 98e70866aacb ("mei: add support for variable length mei headers.")
CC: Arnd Bergmann <arnd@arndb.de>
CC: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: John Hubbard <jhubbard@nvidia.com>
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-08-23 14:16:58 +08:00
|
|
|
rets = len;
|
2013-04-09 02:56:37 +08:00
|
|
|
err:
|
2014-03-19 04:52:04 +08:00
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 21:31:42 +08:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2016-02-11 05:57:26 +08:00
|
|
|
free:
|
|
|
|
mei_io_cb_free(cb);
|
2014-03-19 04:52:04 +08:00
|
|
|
|
2013-04-09 02:56:37 +08:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-12 20:34:45 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_complete - processes completed operation for a client
|
|
|
|
*
|
|
|
|
* @cl: private data of the file object.
|
|
|
|
* @cb: callback block.
|
|
|
|
*/
|
|
|
|
void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
|
|
|
|
{
|
2015-05-07 20:53:59 +08:00
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
switch (cb->fop_type) {
|
|
|
|
case MEI_FOP_WRITE:
|
2018-02-26 02:07:05 +08:00
|
|
|
mei_tx_cb_dequeue(cb);
|
2013-05-12 20:34:45 +08:00
|
|
|
cl->writing_state = MEI_WRITE_COMPLETE;
|
2015-05-07 20:53:59 +08:00
|
|
|
if (waitqueue_active(&cl->tx_wait)) {
|
2013-05-12 20:34:45 +08:00
|
|
|
wake_up_interruptible(&cl->tx_wait);
|
2015-05-07 20:53:59 +08:00
|
|
|
} else {
|
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_request_autosuspend(dev->dev);
|
|
|
|
}
|
2015-05-04 14:43:52 +08:00
|
|
|
break;
|
2013-05-12 20:34:45 +08:00
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
case MEI_FOP_READ:
|
2015-02-10 16:39:46 +08:00
|
|
|
list_add_tail(&cb->list, &cl->rd_completed);
|
2016-07-26 06:06:03 +08:00
|
|
|
if (!mei_cl_is_fixed_address(cl) &&
|
|
|
|
!WARN_ON(!cl->rx_flow_ctrl_creds))
|
|
|
|
cl->rx_flow_ctrl_creds--;
|
2016-02-08 05:35:30 +08:00
|
|
|
if (!mei_cl_bus_rx_event(cl))
|
|
|
|
wake_up_interruptible(&cl->rx_wait);
|
2015-05-04 14:43:52 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MEI_FOP_CONNECT:
|
|
|
|
case MEI_FOP_DISCONNECT:
|
2015-07-26 14:54:18 +08:00
|
|
|
case MEI_FOP_NOTIFY_STOP:
|
|
|
|
case MEI_FOP_NOTIFY_START:
|
2015-05-04 14:43:52 +08:00
|
|
|
if (waitqueue_active(&cl->wait))
|
|
|
|
wake_up(&cl->wait);
|
2013-05-12 20:34:45 +08:00
|
|
|
|
2016-04-18 00:16:03 +08:00
|
|
|
break;
|
|
|
|
case MEI_FOP_DISCONNECT_RSP:
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
mei_cl_set_disconnected(cl);
|
2015-05-04 14:43:52 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG_ON(0);
|
2013-05-12 20:34:45 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-09 02:56:37 +08:00
|
|
|
|
2013-02-06 20:06:44 +08:00
|
|
|
/**
|
|
|
|
* mei_cl_all_disconnect - disconnect forcefully all connected clients
|
|
|
|
*
|
2014-09-29 21:31:49 +08:00
|
|
|
* @dev: mei device
|
2013-02-06 20:06:44 +08:00
|
|
|
*/
|
|
|
|
void mei_cl_all_disconnect(struct mei_device *dev)
|
|
|
|
{
|
2014-02-17 21:13:25 +08:00
|
|
|
struct mei_cl *cl;
|
2013-02-06 20:06:44 +08:00
|
|
|
|
2015-05-04 14:43:52 +08:00
|
|
|
list_for_each_entry(cl, &dev->file_list, link)
|
|
|
|
mei_cl_set_disconnected(cl);
|
2013-02-06 20:06:44 +08:00
|
|
|
}
|