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 12:43:41 +02:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Intel Management Engine Interface (Intel MEI) Linux driver
|
2012-02-09 18:25:53 +01:00
|
|
|
* Copyright (c) 2003-2012, Intel Corporation.
|
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 12:43:41 +02:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
2013-01-08 22:07:13 +01:00
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/delay.h>
|
2014-09-29 15:31:46 +02:00
|
|
|
#include <linux/slab.h>
|
2014-03-18 21:52:04 +01: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 12:43:41 +02:00
|
|
|
|
2012-05-09 15:38:59 +02:00
|
|
|
#include <linux/mei.h>
|
2012-12-25 18:06:03 +01:00
|
|
|
|
|
|
|
#include "mei_dev.h"
|
2013-01-08 22:07:12 +01:00
|
|
|
#include "hbm.h"
|
2013-01-08 22:07:14 +01:00
|
|
|
#include "client.h"
|
|
|
|
|
2015-01-10 23:07:16 +01: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 09:39:31 +01:00
|
|
|
if (me_cl && kref_get_unless_zero(&me_cl->refcnt))
|
|
|
|
return me_cl;
|
2015-01-10 23:07:16 +01:00
|
|
|
|
2015-02-10 09:39:31 +01:00
|
|
|
return NULL;
|
2015-01-10 23:07:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-02-10 09:39:31 +01:00
|
|
|
* mei_me_cl_release - free me client
|
2015-01-10 23:07:16 +01: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 09:39:31 +01:00
|
|
|
|
2015-01-10 23:07:16 +01:00
|
|
|
kfree(me_cl);
|
|
|
|
}
|
2015-02-10 09:39:31 +01:00
|
|
|
|
2015-01-10 23:07:16 +01: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-08 22:07:14 +01:00
|
|
|
/**
|
2015-05-04 08:43:54 +02:00
|
|
|
* __mei_me_cl_del - delete me client from the list and decrease
|
2015-02-10 09:39:31 +01: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 08:43:54 +02:00
|
|
|
list_del_init(&me_cl->list);
|
2015-02-10 09:39:31 +01:00
|
|
|
mei_me_cl_put(me_cl);
|
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:54 +02: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 09:39:31 +01: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-10 23:07:16 +01:00
|
|
|
* increases ref count
|
2013-01-08 22:07:14 +01:00
|
|
|
*
|
|
|
|
* @dev: mei device
|
2014-09-29 15:31:49 +02:00
|
|
|
* @uuid: me client uuid
|
2014-02-17 14:13:22 +01:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: me client or NULL if not found
|
2015-02-10 09:39:31 +01:00
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
2013-01-08 22:07:14 +01:00
|
|
|
*/
|
2015-02-10 09:39:31 +01:00
|
|
|
static struct mei_me_client *__mei_me_cl_by_uuid(struct mei_device *dev,
|
2014-08-24 11:08:55 +02:00
|
|
|
const uuid_le *uuid)
|
2013-01-08 22:07:14 +01:00
|
|
|
{
|
2014-08-21 13:29:13 +02:00
|
|
|
struct mei_me_client *me_cl;
|
2015-02-10 09:39:31 +01:00
|
|
|
const uuid_le *pn;
|
2013-01-08 22:07:14 +01:00
|
|
|
|
2015-02-10 09:39:31 +01: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-10 23:07:16 +01:00
|
|
|
return mei_me_cl_get(me_cl);
|
2015-02-10 09:39:31 +01:00
|
|
|
}
|
2013-01-08 22:07:14 +01:00
|
|
|
|
2014-08-24 11:08:55 +02:00
|
|
|
return NULL;
|
2013-01-08 22:07:14 +01:00
|
|
|
}
|
|
|
|
|
2015-02-10 09:39:31 +01: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-08 22:07:14 +01:00
|
|
|
/**
|
2014-09-29 15:31:49 +02:00
|
|
|
* mei_me_cl_by_id - locate me client by client id
|
2015-01-10 23:07:16 +01:00
|
|
|
* increases ref count
|
2013-01-08 22:07:14 +01:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @client_id: me client id
|
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: me client or NULL if not found
|
2015-02-10 09:39:31 +01:00
|
|
|
*
|
|
|
|
* Locking: dev->me_clients_rwsem
|
2013-01-08 22:07:14 +01:00
|
|
|
*/
|
2014-08-24 11:08:55 +02:00
|
|
|
struct mei_me_client *mei_me_cl_by_id(struct mei_device *dev, u8 client_id)
|
2013-01-08 22:07:14 +01:00
|
|
|
{
|
2014-02-17 14:13:22 +01:00
|
|
|
|
2015-02-10 09:39:31 +01: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 13:29:13 +02:00
|
|
|
struct mei_me_client *me_cl;
|
2015-02-10 09:39:31 +01:00
|
|
|
const uuid_le *pn;
|
|
|
|
|
|
|
|
WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
|
2013-01-08 22:07:14 +01:00
|
|
|
|
2015-02-10 09:39:31 +01: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-10 23:07:16 +01:00
|
|
|
return mei_me_cl_get(me_cl);
|
2015-02-10 09:39:31 +01:00
|
|
|
}
|
2015-01-10 23:07:16 +01:00
|
|
|
|
2014-08-24 11:08:55 +02:00
|
|
|
return NULL;
|
2013-01-08 22:07:14 +01: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 12:43:41 +02:00
|
|
|
|
2015-02-10 09:39:31 +01:00
|
|
|
|
2014-09-29 15:31:49 +02:00
|
|
|
/**
|
|
|
|
* mei_me_cl_by_uuid_id - locate me client by client id and uuid
|
2015-01-10 23:07:16 +01:00
|
|
|
* increases ref count
|
2014-09-29 15:31:49 +02:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @uuid: me client uuid
|
|
|
|
* @client_id: me client id
|
|
|
|
*
|
2015-02-10 09:39:31 +01:00
|
|
|
* Return: me client or null if not found
|
2014-09-29 15:31:49 +02:00
|
|
|
*/
|
2014-08-21 13:29:15 +02: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 09:39:31 +01: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-10 23:07:16 +01:00
|
|
|
|
2015-02-10 09:39:31 +01:00
|
|
|
return me_cl;
|
2014-08-21 13:29:15 +02:00
|
|
|
}
|
|
|
|
|
2014-08-21 13:29:14 +02:00
|
|
|
/**
|
2015-01-10 23:07:16 +01:00
|
|
|
* mei_me_cl_rm_by_uuid - remove all me clients matching uuid
|
2014-08-21 13:29:14 +02:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
* @uuid: me client uuid
|
2015-01-10 23:07:16 +01:00
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
2014-08-21 13:29:14 +02:00
|
|
|
*/
|
2015-01-10 23:07:16 +01:00
|
|
|
void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid)
|
2014-08-21 13:29:14 +02:00
|
|
|
{
|
2015-02-10 09:39:31 +01:00
|
|
|
struct mei_me_client *me_cl;
|
2014-08-21 13:29:14 +02:00
|
|
|
|
2015-01-10 23:07:16 +01:00
|
|
|
dev_dbg(dev->dev, "remove %pUl\n", uuid);
|
2015-02-10 09:39:31 +01:00
|
|
|
|
|
|
|
down_write(&dev->me_clients_rwsem);
|
|
|
|
me_cl = __mei_me_cl_by_uuid(dev, uuid);
|
|
|
|
__mei_me_cl_del(dev, me_cl);
|
|
|
|
up_write(&dev->me_clients_rwsem);
|
2015-01-10 23:07:16 +01: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 09:39:31 +01:00
|
|
|
struct mei_me_client *me_cl;
|
2015-01-10 23:07:16 +01:00
|
|
|
|
|
|
|
dev_dbg(dev->dev, "remove %pUl %d\n", uuid, id);
|
2015-02-10 09:39:31 +01: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);
|
|
|
|
up_write(&dev->me_clients_rwsem);
|
2014-08-21 13:29:14 +02:00
|
|
|
}
|
|
|
|
|
2015-01-10 23:07:16 +01: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 09:39:31 +01:00
|
|
|
down_write(&dev->me_clients_rwsem);
|
2015-01-10 23:07:16 +01:00
|
|
|
list_for_each_entry_safe(me_cl, next, &dev->me_clients, list)
|
2015-02-10 09:39:31 +01:00
|
|
|
__mei_me_cl_del(dev, me_cl);
|
|
|
|
up_write(&dev->me_clients_rwsem);
|
2015-01-10 23:07:16 +01:00
|
|
|
}
|
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
/**
|
2014-03-10 14:10:40 +01:00
|
|
|
* mei_cl_cmp_id - tells if the clients are the same
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2014-03-10 14:10:40 +01:00
|
|
|
* @cl1: host client 1
|
|
|
|
* @cl2: host client 2
|
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: true - if the clients has same host and me ids
|
2014-03-10 14:10:40 +01:00
|
|
|
* false - otherwise
|
|
|
|
*/
|
|
|
|
static inline bool mei_cl_cmp_id(const struct mei_cl *cl1,
|
|
|
|
const struct mei_cl *cl2)
|
|
|
|
{
|
|
|
|
return cl1 && cl2 &&
|
|
|
|
(cl1->host_client_id == cl2->host_client_id) &&
|
2015-05-04 08:43:54 +02:00
|
|
|
(mei_cl_me_id(cl1) == mei_cl_me_id(cl2));
|
2014-03-10 14:10:40 +01:00
|
|
|
}
|
|
|
|
|
2015-02-10 09:39:45 +01: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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
*/
|
|
|
|
struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl, enum mei_cb_file_ops type,
|
2016-02-07 22:35:23 +01:00
|
|
|
const struct file *fp)
|
2015-02-10 09:39:45 +01: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-07 22:35:24 +01:00
|
|
|
cb->fp = fp;
|
2015-02-10 09:39:45 +01:00
|
|
|
cb->cl = cl;
|
|
|
|
cb->buf_idx = 0;
|
|
|
|
cb->fop_type = type;
|
|
|
|
return cb;
|
|
|
|
}
|
|
|
|
|
2014-03-10 14:10:40 +01:00
|
|
|
/**
|
2015-02-10 09:39:35 +01:00
|
|
|
* __mei_io_list_flush - removes and frees cbs belonging to cl.
|
2014-03-10 14:10:40 +01:00
|
|
|
*
|
|
|
|
* @list: an instance of our list structure
|
|
|
|
* @cl: host client, can be NULL for flushing the whole list
|
|
|
|
* @free: whether to free the cbs
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2014-03-10 14:10:40 +01:00
|
|
|
static void __mei_io_list_flush(struct mei_cl_cb *list,
|
|
|
|
struct mei_cl *cl, bool free)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2015-02-10 09:39:45 +01:00
|
|
|
struct mei_cl_cb *cb, *next;
|
2013-01-08 22:07:13 +01:00
|
|
|
|
2014-03-10 14:10:40 +01:00
|
|
|
/* enable removing everything if no cl is specified */
|
2013-01-08 22:07:13 +01:00
|
|
|
list_for_each_entry_safe(cb, next, &list->list, list) {
|
2014-10-02 12:39:31 +02:00
|
|
|
if (!cl || mei_cl_cmp_id(cl, cb->cl)) {
|
2015-02-10 09:39:45 +01:00
|
|
|
list_del_init(&cb->list);
|
2014-03-10 14:10:40 +01:00
|
|
|
if (free)
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
}
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-10 14:10:40 +01:00
|
|
|
/**
|
|
|
|
* mei_io_list_flush - removes list entry belonging to cl.
|
|
|
|
*
|
|
|
|
* @list: An instance of our list structure
|
|
|
|
* @cl: host client
|
|
|
|
*/
|
2014-08-14 16:22:20 +02:00
|
|
|
void mei_io_list_flush(struct mei_cl_cb *list, struct mei_cl *cl)
|
2014-03-10 14:10:40 +01:00
|
|
|
{
|
|
|
|
__mei_io_list_flush(list, cl, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_io_list_free - removes cb belonging to cl and free them
|
|
|
|
*
|
|
|
|
* @list: An instance of our list structure
|
|
|
|
* @cl: host client
|
|
|
|
*/
|
|
|
|
static inline void mei_io_list_free(struct mei_cl_cb *list, struct mei_cl *cl)
|
|
|
|
{
|
|
|
|
__mei_io_list_flush(list, cl, true);
|
|
|
|
}
|
|
|
|
|
2012-10-11 16:35:08 +02:00
|
|
|
/**
|
2015-02-10 09:39:42 +01:00
|
|
|
* mei_io_cb_alloc_buf - allocate callback buffer
|
2012-10-11 16:35:08 +02:00
|
|
|
*
|
2013-04-04 18:05:05 +02:00
|
|
|
* @cb: io callback structure
|
|
|
|
* @length: size of the buffer
|
2012-10-11 16:35:08 +02:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: 0 on success
|
2012-10-11 16:35:08 +02:00
|
|
|
* -EINVAL if cb is NULL
|
|
|
|
* -ENOMEM if allocation failed
|
|
|
|
*/
|
2015-02-10 09:39:42 +01:00
|
|
|
int mei_io_cb_alloc_buf(struct mei_cl_cb *cb, size_t length)
|
2012-10-11 16:35:08 +02:00
|
|
|
{
|
|
|
|
if (!cb)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (length == 0)
|
|
|
|
return 0;
|
|
|
|
|
2015-02-10 09:39:42 +01:00
|
|
|
cb->buf.data = kmalloc(length, GFP_KERNEL);
|
|
|
|
if (!cb->buf.data)
|
2012-10-11 16:35:08 +02:00
|
|
|
return -ENOMEM;
|
2015-02-10 09:39:42 +01:00
|
|
|
cb->buf.size = length;
|
2012-10-11 16:35:08 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2013-01-08 22:07:13 +01:00
|
|
|
|
2015-02-10 09:39:43 +01:00
|
|
|
/**
|
|
|
|
* mei_cl_alloc_cb - a convenient wrapper for allocating read cb
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @length: size of the buffer
|
|
|
|
* @type: operation type
|
|
|
|
* @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-02-07 22:35:23 +01:00
|
|
|
enum mei_cb_file_ops type,
|
|
|
|
const struct file *fp)
|
2015-02-10 09:39:43 +01:00
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
|
|
|
|
cb = mei_io_cb_init(cl, type, fp);
|
|
|
|
if (!cb)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (mei_io_cb_alloc_buf(cb, length)) {
|
|
|
|
mei_io_cb_free(cb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cb;
|
|
|
|
}
|
|
|
|
|
2015-02-10 09:39:46 +01: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-07 22:35:24 +01:00
|
|
|
if (!fp || fp == cb->fp)
|
2015-02-10 09:39:46 +01:00
|
|
|
return cb;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_read_cb_flush - free client's read pending and completed cbs
|
|
|
|
* for a specific file
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @fp: file pointer (matching cb file object), may be NULL
|
|
|
|
*/
|
|
|
|
void mei_cl_read_cb_flush(const struct mei_cl *cl, const struct file *fp)
|
|
|
|
{
|
|
|
|
struct mei_cl_cb *cb, *next;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cb, next, &cl->rd_completed, list)
|
2016-02-07 22:35:24 +01:00
|
|
|
if (!fp || fp == cb->fp)
|
2015-02-10 09:39:46 +01:00
|
|
|
mei_io_cb_free(cb);
|
|
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(cb, next, &cl->rd_pending, list)
|
2016-02-07 22:35:24 +01:00
|
|
|
if (!fp || fp == cb->fp)
|
2015-02-10 09:39:46 +01:00
|
|
|
mei_io_cb_free(cb);
|
|
|
|
}
|
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
/**
|
|
|
|
* mei_cl_flush_queues - flushes queue lists belonging to cl.
|
|
|
|
*
|
|
|
|
* @cl: host client
|
2015-02-10 09:39:46 +01:00
|
|
|
* @fp: file pointer (matching cb file object), may be NULL
|
2014-09-29 15:31:50 +02:00
|
|
|
*
|
|
|
|
* Return: 0 on success, -EINVAL if cl or cl->dev is NULL.
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2015-02-10 09:39:46 +01:00
|
|
|
int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2013-09-15 17:11:07 +02:00
|
|
|
struct mei_device *dev;
|
|
|
|
|
2013-01-08 22:07:14 +01:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
2013-01-08 22:07:13 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-09-15 17:11:07 +02:00
|
|
|
dev = cl->dev;
|
|
|
|
|
|
|
|
cl_dbg(dev, cl, "remove list entry belonging to cl\n");
|
2014-03-10 14:10:40 +01:00
|
|
|
mei_io_list_free(&cl->dev->write_list, cl);
|
|
|
|
mei_io_list_free(&cl->dev->write_waiting_list, cl);
|
2013-01-08 22:07:13 +01:00
|
|
|
mei_io_list_flush(&cl->dev->ctrl_wr_list, cl);
|
|
|
|
mei_io_list_flush(&cl->dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_flush(&cl->dev->amthif_cmd_list, cl);
|
2015-02-10 09:39:46 +01:00
|
|
|
|
|
|
|
mei_cl_read_cb_flush(cl, fp);
|
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
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 12:43:41 +02:00
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
/**
|
2014-01-08 21:31:46 +01:00
|
|
|
* mei_cl_init - initializes cl.
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
|
|
|
* @cl: host client to be initialized
|
|
|
|
* @dev: mei device
|
|
|
|
*/
|
|
|
|
void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)
|
|
|
|
{
|
|
|
|
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 08:54:19 +02:00
|
|
|
init_waitqueue_head(&cl->ev_wait);
|
2015-02-10 09:39:46 +01:00
|
|
|
INIT_LIST_HEAD(&cl->rd_completed);
|
|
|
|
INIT_LIST_HEAD(&cl->rd_pending);
|
2013-01-08 22:07:13 +01:00
|
|
|
INIT_LIST_HEAD(&cl->link);
|
|
|
|
cl->writing_state = MEI_IDLE;
|
2015-05-04 08:43:52 +02:00
|
|
|
cl->state = MEI_FILE_INITIALIZING;
|
2013-01-08 22:07:13 +01:00
|
|
|
cl->dev = dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_allocate - allocates cl structure and sets it up.
|
|
|
|
*
|
|
|
|
* @dev: mei device
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: The allocated file or NULL on failure
|
2013-01-08 22:07:13 +01: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 09:39:35 +01:00
|
|
|
/**
|
|
|
|
* mei_cl_link - allocate host id in the host map
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2015-02-10 09:39:35 +01:00
|
|
|
* @cl: host client
|
2013-04-04 18:05:05 +02:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: 0 on success
|
2013-01-08 22:07:13 +01:00
|
|
|
* -EINVAL on incorrect values
|
2015-02-10 09:39:44 +01:00
|
|
|
* -EMFILE if open count exceeded.
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2016-02-07 22:35:40 +01:00
|
|
|
int mei_cl_link(struct mei_cl *cl)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2013-01-08 22:07:14 +01:00
|
|
|
struct mei_device *dev;
|
2013-09-16 22:44:47 +02:00
|
|
|
long open_handle_count;
|
2016-02-07 22:35:40 +01:00
|
|
|
int id;
|
2013-01-08 22:07:13 +01:00
|
|
|
|
2013-01-08 22:07:22 +01:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
2013-01-08 22:07:13 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-01-08 22:07:14 +01:00
|
|
|
dev = cl->dev;
|
|
|
|
|
2016-02-07 22:35:40 +01:00
|
|
|
id = find_first_zero_bit(dev->host_clients_map, MEI_CLIENTS_MAX);
|
2013-01-08 22:07:22 +01:00
|
|
|
if (id >= MEI_CLIENTS_MAX) {
|
2014-09-29 15:31:42 +02:00
|
|
|
dev_err(dev->dev, "id exceeded %d", MEI_CLIENTS_MAX);
|
2013-09-16 22:44:46 +02:00
|
|
|
return -EMFILE;
|
|
|
|
}
|
|
|
|
|
2013-09-16 22:44:47 +02:00
|
|
|
open_handle_count = dev->open_handle_count + dev->iamthif_open_count;
|
|
|
|
if (open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) {
|
2014-09-29 15:31:42 +02:00
|
|
|
dev_err(dev->dev, "open_handle_count exceeded %d",
|
2013-09-16 22:44:46 +02:00
|
|
|
MEI_MAX_OPEN_HANDLE_COUNT);
|
|
|
|
return -EMFILE;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
2013-01-08 22:07:22 +01: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 17:11:07 +02:00
|
|
|
cl_dbg(dev, cl, "link cl\n");
|
2013-01-08 22:07:22 +01:00
|
|
|
return 0;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
2013-01-08 22:07:22 +01:00
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
/**
|
2015-05-04 08:43:54 +02:00
|
|
|
* mei_cl_unlink - remove host client from the list
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2013-04-04 18:05:05 +02:00
|
|
|
* @cl: host client
|
2014-09-29 15:31:50 +02:00
|
|
|
*
|
|
|
|
* Return: always 0
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2013-01-08 22:07:14 +01:00
|
|
|
int mei_cl_unlink(struct mei_cl *cl)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2013-01-08 22:07:14 +01:00
|
|
|
struct mei_device *dev;
|
|
|
|
|
2013-01-08 22:07:22 +01:00
|
|
|
/* don't shout on error exit path */
|
|
|
|
if (!cl)
|
|
|
|
return 0;
|
|
|
|
|
2016-01-07 23:49:21 +01:00
|
|
|
/* amthif might not be initialized */
|
2013-01-10 16:32:14 +01:00
|
|
|
if (!cl->dev)
|
|
|
|
return 0;
|
2013-01-08 22:07:14 +01:00
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2013-09-16 22:44:45 +02:00
|
|
|
cl_dbg(dev, cl, "unlink client");
|
|
|
|
|
2013-09-16 22:44:47 +02: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);
|
|
|
|
|
|
|
|
cl->state = MEI_FILE_INITIALIZING;
|
|
|
|
|
2013-01-08 22:07:14 +01:00
|
|
|
return 0;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
2016-02-07 22:35:43 +01:00
|
|
|
void mei_host_client_init(struct mei_device *dev)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
|
|
|
dev->dev_state = MEI_DEV_ENABLED;
|
2014-01-11 23:36:10 +01:00
|
|
|
dev->reset_count = 0;
|
2014-03-18 21:52:04 +01:00
|
|
|
|
2016-02-07 22:35:43 +01:00
|
|
|
schedule_work(&dev->bus_rescan_work);
|
2015-07-23 14:08:47 +02:00
|
|
|
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
dev_dbg(dev->dev, "rpm: autosuspend\n");
|
|
|
|
pm_runtime_autosuspend(dev->dev);
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
2014-02-19 16:35:47 +01:00
|
|
|
/**
|
2014-09-29 15:31:49 +02:00
|
|
|
* mei_hbuf_acquire - try to acquire host buffer
|
2014-02-19 16:35:47 +01:00
|
|
|
*
|
|
|
|
* @dev: the device structure
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: true if host buffer was acquired
|
2014-02-19 16:35:47 +01:00
|
|
|
*/
|
|
|
|
bool mei_hbuf_acquire(struct mei_device *dev)
|
|
|
|
{
|
2014-03-18 21:52:04 +01:00
|
|
|
if (mei_pg_state(dev) == MEI_PG_ON ||
|
2015-06-13 07:51:17 +02:00
|
|
|
mei_pg_in_transition(dev)) {
|
2014-09-29 15:31:42 +02:00
|
|
|
dev_dbg(dev->dev, "device is in pg\n");
|
2014-03-18 21:52:04 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-02-19 16:35:47 +01:00
|
|
|
if (!dev->hbuf_is_ready) {
|
2014-09-29 15:31:42 +02:00
|
|
|
dev_dbg(dev->dev, "hbuf is not ready\n");
|
2014-02-19 16:35:47 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->hbuf_is_ready = false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2013-01-08 22:07:13 +01:00
|
|
|
|
2016-02-07 22:35:35 +01: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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
/**
|
|
|
|
* mei_cl_set_disconnected - set disconnected state and clear
|
|
|
|
* associated states and resources
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
*/
|
|
|
|
void mei_cl_set_disconnected(struct mei_cl *cl)
|
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
|
|
|
|
if (cl->state == MEI_FILE_DISCONNECTED ||
|
|
|
|
cl->state == MEI_FILE_INITIALIZING)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cl->state = MEI_FILE_DISCONNECTED;
|
2016-02-07 22:35:35 +01:00
|
|
|
mei_io_list_free(&dev->write_list, cl);
|
|
|
|
mei_io_list_free(&dev->write_waiting_list, cl);
|
2015-05-04 08:43:52 +02:00
|
|
|
mei_io_list_flush(&dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_flush(&dev->ctrl_wr_list, cl);
|
2016-02-07 22:35:35 +01:00
|
|
|
mei_cl_wake_all(cl);
|
2015-05-04 08:43:52 +02:00
|
|
|
cl->mei_flow_ctrl_creds = 0;
|
|
|
|
cl->timer_count = 0;
|
2015-05-04 08:43:54 +02:00
|
|
|
|
2015-05-04 08:43:55 +02:00
|
|
|
if (!cl->me_cl)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!WARN_ON(cl->me_cl->connect_count == 0))
|
|
|
|
cl->me_cl->connect_count--;
|
|
|
|
|
2015-06-13 20:18:40 +02:00
|
|
|
if (cl->me_cl->connect_count == 0)
|
|
|
|
cl->me_cl->mei_flow_ctrl_creds = 0;
|
|
|
|
|
2015-05-04 08:43:54 +02:00
|
|
|
mei_me_cl_put(cl->me_cl);
|
|
|
|
cl->me_cl = NULL;
|
2015-05-04 08:43:52 +02:00
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:55 +02:00
|
|
|
static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl)
|
|
|
|
{
|
2015-05-04 08:43:56 +02:00
|
|
|
if (!mei_me_cl_get(me_cl))
|
2015-05-04 08:43:55 +02:00
|
|
|
return -ENOENT;
|
|
|
|
|
2015-05-04 08:43:56 +02: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 08:43:55 +02:00
|
|
|
cl->state = MEI_FILE_CONNECTING;
|
|
|
|
cl->me_cl->connect_count++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:52 +02: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
|
|
|
|
cl->timer_count = MEI_CONNECT_TIMEOUT;
|
|
|
|
|
|
|
|
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,
|
|
|
|
struct mei_cl_cb *cmpl_list)
|
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
u32 msg_slots;
|
|
|
|
int slots;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request));
|
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
|
|
|
|
|
|
|
if (slots < msg_slots)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
ret = mei_cl_send_disconnect(cl, cb);
|
|
|
|
if (ret)
|
|
|
|
list_move_tail(&cb->list, &cmpl_list->list);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
/**
|
2015-07-23 20:37:13 +02:00
|
|
|
* __mei_cl_disconnect - disconnect host client from the me one
|
|
|
|
* internal function runtime pm has to be already acquired
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2013-01-08 22:07:14 +01:00
|
|
|
* @cl: host client
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: 0 on success, <0 on failure.
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2015-07-23 20:37:13 +02:00
|
|
|
static int __mei_cl_disconnect(struct mei_cl *cl)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2013-01-08 22:07:14 +01:00
|
|
|
struct mei_device *dev;
|
2013-01-08 22:07:13 +01:00
|
|
|
struct mei_cl_cb *cb;
|
2014-07-17 09:53:38 +02:00
|
|
|
int rets;
|
2013-01-08 22:07:13 +01:00
|
|
|
|
2013-01-08 22:07:14 +01:00
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
cl->state = MEI_FILE_DISCONNECTING;
|
|
|
|
|
2015-02-10 09:39:43 +01:00
|
|
|
cb = mei_io_cb_init(cl, MEI_FOP_DISCONNECT, NULL);
|
|
|
|
rets = cb ? 0 : -ENOMEM;
|
|
|
|
if (rets)
|
2015-05-04 08:43:52 +02:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
cl_dbg(dev, cl, "add disconnect cb to control write list\n");
|
|
|
|
list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
|
2014-08-21 13:29:17 +02:00
|
|
|
|
2014-02-19 16:35:47 +01:00
|
|
|
if (mei_hbuf_acquire(dev)) {
|
2015-05-04 08:43:52 +02:00
|
|
|
rets = mei_cl_send_disconnect(cl, cb);
|
|
|
|
if (rets) {
|
2013-09-15 17:11:07 +02:00
|
|
|
cl_err(dev, cl, "failed to disconnect.\n");
|
2015-05-04 08:43:52 +02:00
|
|
|
goto out;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
mutex_unlock(&dev->device_lock);
|
|
|
|
wait_event_timeout(cl->wait, cl->state == MEI_FILE_DISCONNECT_REPLY,
|
|
|
|
mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
|
2013-01-08 22:07:13 +01:00
|
|
|
mutex_lock(&dev->device_lock);
|
2014-07-17 09:53:38 +02:00
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
rets = cl->status;
|
|
|
|
if (cl->state != MEI_FILE_DISCONNECT_REPLY) {
|
2014-07-17 09:53:38 +02:00
|
|
|
cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");
|
|
|
|
rets = -ETIME;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:52 +02: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-23 20:37:13 +02: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-18 21:52:04 +01:00
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2013-01-08 22:07:14 +01:00
|
|
|
* mei_cl_is_other_connecting - checks if other
|
|
|
|
* client with the same me client id is connecting
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
|
|
|
* @cl: private data of the file object
|
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: true if other client is connected, false - otherwise.
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2015-05-04 08:43:53 +02:00
|
|
|
static bool mei_cl_is_other_connecting(struct mei_cl *cl)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2013-01-08 22:07:14 +01:00
|
|
|
struct mei_device *dev;
|
2015-05-04 08:43:53 +02:00
|
|
|
struct mei_cl_cb *cb;
|
2013-01-08 22:07:14 +01:00
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-05-04 08:43:53 +02:00
|
|
|
list_for_each_entry(cb, &dev->ctrl_rd_list.list, list) {
|
|
|
|
if (cb->fop_type == MEI_FOP_CONNECT &&
|
2015-05-04 08:43:54 +02:00
|
|
|
mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))
|
2013-01-08 22:07:14 +01:00
|
|
|
return true;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
2013-01-08 22:07:14 +01:00
|
|
|
|
|
|
|
return false;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:53 +02: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
|
|
|
|
cl->timer_count = MEI_CONNECT_TIMEOUT;
|
|
|
|
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,
|
|
|
|
struct mei_cl_cb *cmpl_list)
|
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
u32 msg_slots;
|
|
|
|
int slots;
|
|
|
|
int rets;
|
|
|
|
|
|
|
|
msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request));
|
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
|
|
|
|
|
|
|
if (mei_cl_is_other_connecting(cl))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (slots < msg_slots)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
rets = mei_cl_send_connect(cl, cb);
|
|
|
|
if (rets)
|
|
|
|
list_move_tail(&cb->list, &cmpl_list->list);
|
|
|
|
|
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2013-01-08 22:07:15 +01:00
|
|
|
/**
|
2014-01-08 21:31:46 +01:00
|
|
|
* mei_cl_connect - connect host client to the me one
|
2013-01-08 22:07:15 +01:00
|
|
|
*
|
|
|
|
* @cl: host client
|
2015-05-04 08:43:54 +02:00
|
|
|
* @me_cl: me client
|
2014-09-29 15:31:49 +02:00
|
|
|
* @file: pointer to file structure
|
2013-01-08 22:07:15 +01:00
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: 0 on success, <0 on failure.
|
2013-01-08 22:07:15 +01:00
|
|
|
*/
|
2015-05-04 08:43:54 +02:00
|
|
|
int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
|
2016-02-07 22:35:23 +01:00
|
|
|
const struct file *file)
|
2013-01-08 22:07:15 +01:00
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
int rets;
|
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
if (WARN_ON(!cl || !cl->dev || !me_cl))
|
2013-01-08 22:07:15 +01:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
rets = mei_cl_set_connecting(cl, me_cl);
|
|
|
|
if (rets)
|
|
|
|
return rets;
|
|
|
|
|
|
|
|
if (mei_cl_is_fixed_address(cl)) {
|
|
|
|
cl->state = MEI_FILE_CONNECTED;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-29 15:31:42 +02:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_put_noidle(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
2015-05-04 08:43:56 +02:00
|
|
|
goto nortpm;
|
2014-03-18 21:52:04 +01:00
|
|
|
}
|
|
|
|
|
2015-02-10 09:39:43 +01:00
|
|
|
cb = mei_io_cb_init(cl, MEI_FOP_CONNECT, file);
|
|
|
|
rets = cb ? 0 : -ENOMEM;
|
|
|
|
if (rets)
|
2013-01-08 22:07:15 +01:00
|
|
|
goto out;
|
|
|
|
|
2015-05-04 08:43:53 +02:00
|
|
|
list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
|
|
|
|
|
2014-02-19 16:35:47 +01: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 08:43:53 +02:00
|
|
|
rets = mei_cl_send_connect(cl, cb);
|
|
|
|
if (rets)
|
2013-01-08 22:07:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
2014-08-21 13:29:18 +02:00
|
|
|
wait_event_timeout(cl->wait,
|
2014-02-17 14:13:20 +01:00
|
|
|
(cl->state == MEI_FILE_CONNECTED ||
|
2015-07-23 20:37:13 +02:00
|
|
|
cl->state == MEI_FILE_DISCONNECT_REQUIRED ||
|
2015-05-04 08:43:52 +02:00
|
|
|
cl->state == MEI_FILE_DISCONNECT_REPLY),
|
2014-02-17 14:13:20 +01:00
|
|
|
mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
|
2013-01-08 22:07:15 +01:00
|
|
|
mutex_lock(&dev->device_lock);
|
|
|
|
|
2015-03-26 23:27:58 +01:00
|
|
|
if (!mei_cl_is_connected(cl)) {
|
2015-07-23 20:37:13 +02:00
|
|
|
if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) {
|
|
|
|
mei_io_list_flush(&dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_flush(&dev->ctrl_wr_list, cl);
|
|
|
|
/* ignore disconnect return valuue;
|
|
|
|
* in case of failure reset will be invoked
|
|
|
|
*/
|
|
|
|
__mei_cl_disconnect(cl);
|
|
|
|
rets = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:53 +02:00
|
|
|
/* timeout or something went really wrong */
|
2014-02-17 14:13:20 +01:00
|
|
|
if (!cl->status)
|
|
|
|
cl->status = -EFAULT;
|
2013-01-08 22:07:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
rets = cl->status;
|
|
|
|
out:
|
2014-03-18 21:52:04 +01:00
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
|
2013-01-08 22:07:15 +01:00
|
|
|
mei_io_cb_free(cb);
|
2015-05-04 08:43:53 +02:00
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
nortpm:
|
2015-05-04 08:43:53 +02:00
|
|
|
if (!mei_cl_is_connected(cl))
|
|
|
|
mei_cl_set_disconnected(cl);
|
|
|
|
|
2013-01-08 22:07:15 +01:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2015-02-10 09:39:44 +01:00
|
|
|
/**
|
|
|
|
* mei_cl_alloc_linked - allocate and link host client
|
|
|
|
*
|
|
|
|
* @dev: the device structure
|
|
|
|
*
|
|
|
|
* Return: cl on success ERR_PTR on failure
|
|
|
|
*/
|
2016-02-07 22:35:40 +01:00
|
|
|
struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev)
|
2015-02-10 09:39:44 +01:00
|
|
|
{
|
|
|
|
struct mei_cl *cl;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
cl = mei_cl_allocate(dev);
|
|
|
|
if (!cl) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2016-02-07 22:35:40 +01:00
|
|
|
ret = mei_cl_link(cl);
|
2015-02-10 09:39:44 +01:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return cl;
|
|
|
|
err:
|
|
|
|
kfree(cl);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
/**
|
2013-01-08 22:07:14 +01:00
|
|
|
* mei_cl_flow_ctrl_creds - checks flow_control credits for cl.
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2016-02-07 22:35:37 +01:00
|
|
|
* @cl: host client
|
|
|
|
* @fp: the file pointer associated with the pointer
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: 1 if mei_flow_ctrl_creds >0, 0 - otherwise.
|
2013-01-08 22:07:13 +01:00
|
|
|
*/
|
2016-02-07 22:35:37 +01:00
|
|
|
static int mei_cl_flow_ctrl_creds(struct mei_cl *cl, const struct file *fp)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2015-05-04 08:43:56 +02:00
|
|
|
int rets;
|
|
|
|
|
2015-05-04 08:43:54 +02:00
|
|
|
if (WARN_ON(!cl || !cl->me_cl))
|
2013-01-08 22:07:14 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-01-08 22:07:13 +01:00
|
|
|
if (cl->mei_flow_ctrl_creds > 0)
|
|
|
|
return 1;
|
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
if (mei_cl_is_fixed_address(cl)) {
|
2016-02-07 22:35:37 +01:00
|
|
|
rets = mei_cl_read_start(cl, mei_cl_mtu(cl), fp);
|
2015-05-04 08:43:56 +02:00
|
|
|
if (rets && rets != -EBUSY)
|
|
|
|
return rets;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-05-04 08:43:54 +02:00
|
|
|
if (mei_cl_is_single_recv_buf(cl)) {
|
|
|
|
if (cl->me_cl->mei_flow_ctrl_creds > 0)
|
|
|
|
return 1;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
2015-05-04 08:43:54 +02:00
|
|
|
return 0;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-08 22:07:14 +01:00
|
|
|
* mei_cl_flow_ctrl_reduce - reduces flow_control.
|
2013-01-08 22:07:13 +01:00
|
|
|
*
|
|
|
|
* @cl: private data of the file object
|
2013-04-04 18:05:05 +02:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return:
|
2013-01-08 22:07:13 +01:00
|
|
|
* 0 on success
|
|
|
|
* -EINVAL when ctrl credits are <= 0
|
|
|
|
*/
|
2016-01-07 23:49:21 +01:00
|
|
|
static int mei_cl_flow_ctrl_reduce(struct mei_cl *cl)
|
2013-01-08 22:07:13 +01:00
|
|
|
{
|
2015-05-04 08:43:54 +02:00
|
|
|
if (WARN_ON(!cl || !cl->me_cl))
|
2013-01-08 22:07:14 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
if (mei_cl_is_fixed_address(cl))
|
|
|
|
return 0;
|
|
|
|
|
2015-05-04 08:43:54 +02:00
|
|
|
if (mei_cl_is_single_recv_buf(cl)) {
|
|
|
|
if (WARN_ON(cl->me_cl->mei_flow_ctrl_creds <= 0))
|
|
|
|
return -EINVAL;
|
|
|
|
cl->me_cl->mei_flow_ctrl_creds--;
|
2014-02-17 14:13:23 +01:00
|
|
|
} else {
|
2015-05-04 08:43:54 +02:00
|
|
|
if (WARN_ON(cl->mei_flow_ctrl_creds <= 0))
|
|
|
|
return -EINVAL;
|
2014-02-17 14:13:23 +01:00
|
|
|
cl->mei_flow_ctrl_creds--;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
2015-05-04 08:43:54 +02:00
|
|
|
return 0;
|
2013-01-08 22:07:13 +01:00
|
|
|
}
|
|
|
|
|
2015-07-26 08:54:18 +02: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,
|
|
|
|
struct mei_cl_cb *cmpl_list)
|
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
u32 msg_slots;
|
|
|
|
int slots;
|
|
|
|
int ret;
|
|
|
|
bool request;
|
|
|
|
|
|
|
|
msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request));
|
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
|
|
|
|
|
|
|
if (slots < msg_slots)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
request = mei_cl_notify_fop2req(cb->fop_type);
|
|
|
|
ret = mei_hbm_cl_notify_req(dev, cl, request);
|
|
|
|
if (ret) {
|
|
|
|
cl->status = ret;
|
|
|
|
list_move_tail(&cb->list, &cmpl_list->list);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_move_tail(&cb->list, &dev->ctrl_rd_list.list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mei_cl_notify_request - send notification stop/start request
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
* @file: associate request with file
|
|
|
|
* @request: 1 for start or 0 for stop
|
|
|
|
*
|
|
|
|
* Locking: called under "dev->device_lock" lock
|
|
|
|
*
|
|
|
|
* Return: 0 on such and error otherwise.
|
|
|
|
*/
|
2016-02-07 22:35:23 +01:00
|
|
|
int mei_cl_notify_request(struct mei_cl *cl,
|
|
|
|
const struct file *file, u8 request)
|
2015-07-26 08:54:18 +02: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
cb = mei_io_cb_init(cl, fop_type, file);
|
|
|
|
if (!cb) {
|
|
|
|
rets = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mei_hbuf_acquire(dev)) {
|
|
|
|
if (mei_hbm_cl_notify_req(dev, cl, request)) {
|
|
|
|
rets = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
list_add_tail(&cb->list, &dev->ctrl_rd_list.list);
|
|
|
|
} else {
|
|
|
|
list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
|
|
|
wait_event_timeout(cl->wait, cl->notify_en == request,
|
|
|
|
mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
|
|
|
|
mutex_lock(&dev->device_lock);
|
|
|
|
|
|
|
|
if (cl->notify_en != request) {
|
|
|
|
mei_io_list_flush(&dev->ctrl_rd_list, cl);
|
|
|
|
mei_io_list_flush(&dev->ctrl_wr_list, cl);
|
|
|
|
if (!cl->status)
|
|
|
|
cl->status = -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 08:54:22 +02: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-07 22:35:31 +01:00
|
|
|
if (!mei_cl_bus_notify_event(cl))
|
|
|
|
wake_up_interruptible(&cl->ev_wait);
|
2015-07-26 08:54:22 +02:00
|
|
|
|
|
|
|
if (cl->ev_async)
|
|
|
|
kill_fasync(&cl->ev_async, SIGIO, POLL_PRI);
|
2015-07-26 08:54:23 +02:00
|
|
|
|
2015-07-26 08:54:22 +02:00
|
|
|
}
|
|
|
|
|
2015-07-26 08:54:19 +02: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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-01-07 13:46:36 +01:00
|
|
|
/**
|
|
|
|
* mei_cl_is_read_fc_cb - check if read cb is waiting for flow control
|
|
|
|
* for given host client
|
|
|
|
*
|
|
|
|
* @cl: host client
|
|
|
|
*
|
|
|
|
* Return: true, if found at least one cb.
|
|
|
|
*/
|
|
|
|
static bool mei_cl_is_read_fc_cb(struct mei_cl *cl)
|
|
|
|
{
|
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
struct mei_cl_cb *cb;
|
|
|
|
|
|
|
|
list_for_each_entry(cb, &dev->ctrl_wr_list.list, list)
|
|
|
|
if (cb->fop_type == MEI_FOP_READ && cb->cl == cl)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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 12:43:41 +02:00
|
|
|
/**
|
2013-04-04 18:05:05 +02: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 12:43:41 +02:00
|
|
|
*
|
2013-01-08 22:07:14 +01:00
|
|
|
* @cl: host client
|
2014-09-29 15:31:50 +02:00
|
|
|
* @length: number of bytes to read
|
2015-02-10 09:39:43 +01: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 12:43:41 +02:00
|
|
|
*
|
2014-09-29 15:31:49 +02: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 12:43:41 +02:00
|
|
|
*/
|
2016-02-07 22:35:23 +01: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 12:43:41 +02:00
|
|
|
{
|
2013-01-08 22:07:14 +01: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 12:43:41 +02:00
|
|
|
struct mei_cl_cb *cb;
|
2012-10-11 16:35:08 +02: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 12:43:41 +02:00
|
|
|
|
2013-01-08 22:07:14 +01:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2013-07-25 19:15:53 +02: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 12:43:41 +02:00
|
|
|
return -ENODEV;
|
|
|
|
|
2015-02-10 09:39:46 +01:00
|
|
|
/* HW currently supports only one pending read */
|
2016-01-07 13:46:36 +01:00
|
|
|
if (!list_empty(&cl->rd_pending) || mei_cl_is_read_fc_cb(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 12:43:41 +02:00
|
|
|
return -EBUSY;
|
2015-02-10 09:39:46 +01:00
|
|
|
|
2015-05-04 08:43:54 +02:00
|
|
|
if (!mei_me_cl_is_active(cl->me_cl)) {
|
|
|
|
cl_err(dev, cl, "no such me client\n");
|
2014-02-19 16:35:49 +01:00
|
|
|
return -ENOTTY;
|
2012-10-11 16:35:08 +02:00
|
|
|
}
|
2015-05-04 08:43:56 +02:00
|
|
|
|
2015-01-10 23:07:16 +01:00
|
|
|
/* always allocate at least client max message */
|
2015-05-04 08:43:54 +02:00
|
|
|
length = max_t(size_t, length, mei_cl_mtu(cl));
|
2015-05-04 08:43:56 +02:00
|
|
|
cb = mei_cl_alloc_cb(cl, length, MEI_FOP_READ, fp);
|
|
|
|
if (!cb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (mei_cl_is_fixed_address(cl)) {
|
|
|
|
list_add_tail(&cb->list, &cl->rd_pending);
|
|
|
|
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 12:43:41 +02:00
|
|
|
|
2014-09-29 15:31:42 +02:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_put_noidle(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
2015-05-04 08:43:56 +02:00
|
|
|
goto nortpm;
|
2014-03-18 21:52:04 +01:00
|
|
|
}
|
|
|
|
|
2014-02-19 16:35:47 +01:00
|
|
|
if (mei_hbuf_acquire(dev)) {
|
2014-03-31 16:59:24 +02:00
|
|
|
rets = mei_hbm_cl_flow_control_req(dev, cl);
|
|
|
|
if (rets < 0)
|
2014-03-18 21:52:04 +01:00
|
|
|
goto out;
|
|
|
|
|
2015-02-10 09:39:46 +01:00
|
|
|
list_add_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 12:43:41 +02:00
|
|
|
} else {
|
2015-05-04 08:43:56 +02:00
|
|
|
rets = 0;
|
2012-10-15 12:06:48 +02:00
|
|
|
list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
|
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 12:43:41 +02:00
|
|
|
}
|
2014-02-12 20:27:25 +01:00
|
|
|
|
2014-03-18 21:52:04 +01:00
|
|
|
out:
|
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2015-05-04 08:43:56 +02:00
|
|
|
nortpm:
|
2014-03-18 21:52:04 +01: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 12:43:41 +02:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
2013-06-23 08:36:59 +02:00
|
|
|
/**
|
2014-02-19 16:35:48 +01:00
|
|
|
* mei_cl_irq_write - write a message to device
|
2013-06-23 08:36:59 +02:00
|
|
|
* from the interrupt thread context
|
|
|
|
*
|
|
|
|
* @cl: client
|
|
|
|
* @cb: callback block.
|
|
|
|
* @cmpl_list: complete list.
|
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: 0, OK; otherwise error.
|
2013-06-23 08:36:59 +02:00
|
|
|
*/
|
2014-02-19 16:35:48 +01:00
|
|
|
int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
|
|
|
|
struct mei_cl_cb *cmpl_list)
|
2013-06-23 08:36:59 +02:00
|
|
|
{
|
2013-09-16 22:44:44 +02:00
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_msg_data *buf;
|
2013-06-23 08:36:59 +02:00
|
|
|
struct mei_msg_hdr mei_hdr;
|
2013-09-16 22:44:44 +02:00
|
|
|
size_t len;
|
|
|
|
u32 msg_slots;
|
2014-02-19 16:35:48 +01:00
|
|
|
int slots;
|
2013-09-16 22:44:43 +02:00
|
|
|
int rets;
|
2015-05-07 14:53:58 +02:00
|
|
|
bool first_chunk;
|
2013-06-23 08:36:59 +02:00
|
|
|
|
2013-09-16 22:44:44 +02:00
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-02-10 09:39:42 +01:00
|
|
|
buf = &cb->buf;
|
2013-09-16 22:44:44 +02:00
|
|
|
|
2015-05-07 14:53:58 +02:00
|
|
|
first_chunk = cb->buf_idx == 0;
|
|
|
|
|
2016-02-07 22:35:37 +01:00
|
|
|
rets = first_chunk ? mei_cl_flow_ctrl_creds(cl, cb->fp) : 1;
|
2013-09-16 22:44:44 +02:00
|
|
|
if (rets < 0)
|
|
|
|
return rets;
|
|
|
|
|
|
|
|
if (rets == 0) {
|
2014-03-18 21:52:04 +01:00
|
|
|
cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
|
2013-09-16 22:44:44 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-19 16:35:48 +01:00
|
|
|
slots = mei_hbuf_empty_slots(dev);
|
2013-09-16 22:44:44 +02:00
|
|
|
len = buf->size - cb->buf_idx;
|
|
|
|
msg_slots = mei_data2slots(len);
|
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
mei_hdr.host_addr = mei_cl_host_addr(cl);
|
2015-05-04 08:43:54 +02:00
|
|
|
mei_hdr.me_addr = mei_cl_me_id(cl);
|
2013-06-23 08:36:59 +02:00
|
|
|
mei_hdr.reserved = 0;
|
2013-12-17 14:56:56 +01:00
|
|
|
mei_hdr.internal = cb->internal;
|
2013-06-23 08:36:59 +02:00
|
|
|
|
2014-02-19 16:35:48 +01:00
|
|
|
if (slots >= msg_slots) {
|
2013-06-23 08:36:59 +02:00
|
|
|
mei_hdr.length = len;
|
|
|
|
mei_hdr.msg_complete = 1;
|
|
|
|
/* Split the message only if we can write the whole host buffer */
|
2014-02-19 16:35:48 +01:00
|
|
|
} else if (slots == dev->hbuf_depth) {
|
|
|
|
msg_slots = slots;
|
|
|
|
len = (slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
|
2013-06-23 08:36:59 +02:00
|
|
|
mei_hdr.length = len;
|
|
|
|
mei_hdr.msg_complete = 0;
|
|
|
|
} else {
|
|
|
|
/* wait for next time the host buffer is empty */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-17 17:27:34 +01:00
|
|
|
cl_dbg(dev, cl, "buf: size = %zu idx = %zu\n",
|
2015-02-10 09:39:42 +01:00
|
|
|
cb->buf.size, cb->buf_idx);
|
2013-06-23 08:36:59 +02:00
|
|
|
|
2013-09-16 22:44:44 +02:00
|
|
|
rets = mei_write_message(dev, &mei_hdr, buf->data + cb->buf_idx);
|
2013-09-16 22:44:43 +02:00
|
|
|
if (rets) {
|
|
|
|
cl->status = rets;
|
2013-06-23 08:36:59 +02:00
|
|
|
list_move_tail(&cb->list, &cmpl_list->list);
|
2013-09-16 22:44:43 +02:00
|
|
|
return rets;
|
2013-06-23 08:36:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
cl->status = 0;
|
2013-06-23 08:37:00 +02:00
|
|
|
cl->writing_state = MEI_WRITING;
|
2013-06-23 08:36:59 +02:00
|
|
|
cb->buf_idx += mei_hdr.length;
|
2015-02-10 09:39:40 +01:00
|
|
|
cb->completed = mei_hdr.msg_complete == 1;
|
2013-06-23 08:37:00 +02:00
|
|
|
|
2015-05-07 14:53:58 +02:00
|
|
|
if (first_chunk) {
|
2013-06-23 08:36:59 +02:00
|
|
|
if (mei_cl_flow_ctrl_reduce(cl))
|
2013-09-16 22:44:43 +02:00
|
|
|
return -EIO;
|
2013-06-23 08:36:59 +02:00
|
|
|
}
|
|
|
|
|
2015-05-07 14:53:58 +02:00
|
|
|
if (mei_hdr.msg_complete)
|
|
|
|
list_move_tail(&cb->list, &dev->write_waiting_list.list);
|
|
|
|
|
2013-06-23 08:36:59 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-08 20:56:37 +02:00
|
|
|
/**
|
|
|
|
* mei_cl_write - submit a write cb to mei device
|
2014-09-29 15:31:49 +02:00
|
|
|
* assumes device_lock is locked
|
2013-04-08 20:56:37 +02:00
|
|
|
*
|
|
|
|
* @cl: host client
|
2014-09-29 15:31:49 +02:00
|
|
|
* @cb: write callback with filled data
|
2014-09-29 15:31:50 +02:00
|
|
|
* @blocking: block until completed
|
2013-04-08 20:56:37 +02:00
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* Return: number of bytes sent on success, <0 on failure.
|
2013-04-08 20:56:37 +02:00
|
|
|
*/
|
|
|
|
int mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, bool blocking)
|
|
|
|
{
|
|
|
|
struct mei_device *dev;
|
|
|
|
struct mei_msg_data *buf;
|
|
|
|
struct mei_msg_hdr mei_hdr;
|
2015-07-23 09:43:11 +02:00
|
|
|
int size;
|
2013-04-08 20:56:37 +02:00
|
|
|
int rets;
|
|
|
|
|
|
|
|
|
|
|
|
if (WARN_ON(!cl || !cl->dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (WARN_ON(!cb))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
dev = cl->dev;
|
|
|
|
|
2015-02-10 09:39:42 +01:00
|
|
|
buf = &cb->buf;
|
2015-07-23 09:43:11 +02:00
|
|
|
size = buf->size;
|
2013-04-08 20:56:37 +02:00
|
|
|
|
2015-07-23 09:43:11 +02:00
|
|
|
cl_dbg(dev, cl, "size=%d\n", size);
|
2013-04-08 20:56:37 +02:00
|
|
|
|
2014-09-29 15:31:42 +02:00
|
|
|
rets = pm_runtime_get(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
if (rets < 0 && rets != -EINPROGRESS) {
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_put_noidle(dev->dev);
|
2014-03-18 21:52:04 +01:00
|
|
|
cl_err(dev, cl, "rpm: get failed %d\n", rets);
|
2016-02-10 22:57:26 +01:00
|
|
|
goto free;
|
2014-03-18 21:52:04 +01:00
|
|
|
}
|
2013-04-08 20:56:37 +02:00
|
|
|
|
2014-02-19 16:35:47 +01:00
|
|
|
cb->buf_idx = 0;
|
|
|
|
cl->writing_state = MEI_IDLE;
|
|
|
|
|
2015-05-04 08:43:56 +02:00
|
|
|
mei_hdr.host_addr = mei_cl_host_addr(cl);
|
2015-05-04 08:43:54 +02:00
|
|
|
mei_hdr.me_addr = mei_cl_me_id(cl);
|
2014-02-19 16:35:47 +01:00
|
|
|
mei_hdr.reserved = 0;
|
|
|
|
mei_hdr.msg_complete = 0;
|
|
|
|
mei_hdr.internal = cb->internal;
|
2013-04-08 20:56:37 +02:00
|
|
|
|
2016-02-07 22:35:37 +01:00
|
|
|
rets = mei_cl_flow_ctrl_creds(cl, cb->fp);
|
2013-04-08 20:56:37 +02:00
|
|
|
if (rets < 0)
|
|
|
|
goto err;
|
|
|
|
|
2014-02-19 16:35:47 +01:00
|
|
|
if (rets == 0) {
|
|
|
|
cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
|
2015-07-23 09:43:11 +02:00
|
|
|
rets = size;
|
2014-02-19 16:35:47 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!mei_hbuf_acquire(dev)) {
|
|
|
|
cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n");
|
2015-07-23 09:43:11 +02:00
|
|
|
rets = size;
|
2013-04-08 20:56:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for a maximum length */
|
2015-07-23 09:43:11 +02:00
|
|
|
if (size > mei_hbuf_max_len(dev)) {
|
2013-04-08 20:56:37 +02:00
|
|
|
mei_hdr.length = mei_hbuf_max_len(dev);
|
|
|
|
mei_hdr.msg_complete = 0;
|
|
|
|
} else {
|
2015-07-23 09:43:11 +02:00
|
|
|
mei_hdr.length = size;
|
2013-04-08 20:56:37 +02:00
|
|
|
mei_hdr.msg_complete = 1;
|
|
|
|
}
|
|
|
|
|
2013-09-16 22:44:43 +02:00
|
|
|
rets = mei_write_message(dev, &mei_hdr, buf->data);
|
|
|
|
if (rets)
|
2013-04-08 20:56:37 +02:00
|
|
|
goto err;
|
|
|
|
|
2015-05-07 14:53:58 +02:00
|
|
|
rets = mei_cl_flow_ctrl_reduce(cl);
|
|
|
|
if (rets)
|
|
|
|
goto err;
|
|
|
|
|
2013-04-08 20:56:37 +02:00
|
|
|
cl->writing_state = MEI_WRITING;
|
|
|
|
cb->buf_idx = mei_hdr.length;
|
2015-02-10 09:39:40 +01:00
|
|
|
cb->completed = mei_hdr.msg_complete == 1;
|
2013-04-08 20:56:37 +02:00
|
|
|
|
|
|
|
out:
|
2015-05-07 14:53:58 +02:00
|
|
|
if (mei_hdr.msg_complete)
|
2013-04-08 20:56:37 +02:00
|
|
|
list_add_tail(&cb->list, &dev->write_waiting_list.list);
|
2015-05-07 14:53:58 +02:00
|
|
|
else
|
2013-04-08 20:56:37 +02:00
|
|
|
list_add_tail(&cb->list, &dev->write_list.list);
|
|
|
|
|
2015-07-23 09:43:11 +02:00
|
|
|
cb = NULL;
|
2013-04-08 20:56:37 +02:00
|
|
|
if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {
|
|
|
|
|
|
|
|
mutex_unlock(&dev->device_lock);
|
2014-02-19 16:35:49 +01:00
|
|
|
rets = wait_event_interruptible(cl->tx_wait,
|
2016-02-07 22:35:34 +01:00
|
|
|
cl->writing_state == MEI_WRITE_COMPLETE ||
|
|
|
|
(!mei_cl_is_connected(cl)));
|
2013-04-08 20:56:37 +02:00
|
|
|
mutex_lock(&dev->device_lock);
|
2014-02-19 16:35:49 +01:00
|
|
|
/* wait_event_interruptible returns -ERESTARTSYS */
|
|
|
|
if (rets) {
|
|
|
|
if (signal_pending(current))
|
|
|
|
rets = -EINTR;
|
|
|
|
goto err;
|
|
|
|
}
|
2016-02-07 22:35:34 +01:00
|
|
|
if (cl->writing_state != MEI_WRITE_COMPLETE) {
|
|
|
|
rets = -EFAULT;
|
|
|
|
goto err;
|
|
|
|
}
|
2013-04-08 20:56:37 +02:00
|
|
|
}
|
2014-02-19 16:35:49 +01:00
|
|
|
|
2015-07-23 09:43:11 +02:00
|
|
|
rets = size;
|
2013-04-08 20:56:37 +02:00
|
|
|
err:
|
2014-03-18 21:52:04 +01:00
|
|
|
cl_dbg(dev, cl, "rpm: autosuspend\n");
|
2014-09-29 15:31:42 +02:00
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_runtime_put_autosuspend(dev->dev);
|
2016-02-10 22:57:26 +01:00
|
|
|
free:
|
|
|
|
mei_io_cb_free(cb);
|
2014-03-18 21:52:04 +01:00
|
|
|
|
2013-04-08 20:56:37 +02:00
|
|
|
return rets;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-12 14:34:45 +02: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 14:53:59 +02:00
|
|
|
struct mei_device *dev = cl->dev;
|
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
switch (cb->fop_type) {
|
|
|
|
case MEI_FOP_WRITE:
|
2013-05-12 14:34:45 +02:00
|
|
|
mei_io_cb_free(cb);
|
|
|
|
cl->writing_state = MEI_WRITE_COMPLETE;
|
2015-05-07 14:53:59 +02:00
|
|
|
if (waitqueue_active(&cl->tx_wait)) {
|
2013-05-12 14:34:45 +02:00
|
|
|
wake_up_interruptible(&cl->tx_wait);
|
2015-05-07 14:53:59 +02:00
|
|
|
} else {
|
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
pm_request_autosuspend(dev->dev);
|
|
|
|
}
|
2015-05-04 08:43:52 +02:00
|
|
|
break;
|
2013-05-12 14:34:45 +02:00
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
case MEI_FOP_READ:
|
2015-02-10 09:39:46 +01:00
|
|
|
list_add_tail(&cb->list, &cl->rd_completed);
|
2016-02-07 22:35:30 +01:00
|
|
|
if (!mei_cl_bus_rx_event(cl))
|
|
|
|
wake_up_interruptible(&cl->rx_wait);
|
2015-05-04 08:43:52 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MEI_FOP_CONNECT:
|
|
|
|
case MEI_FOP_DISCONNECT:
|
2015-07-26 08:54:18 +02:00
|
|
|
case MEI_FOP_NOTIFY_STOP:
|
|
|
|
case MEI_FOP_NOTIFY_START:
|
2015-05-04 08:43:52 +02:00
|
|
|
if (waitqueue_active(&cl->wait))
|
|
|
|
wake_up(&cl->wait);
|
2013-05-12 14:34:45 +02:00
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG_ON(0);
|
2013-05-12 14:34:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-08 20:56:37 +02:00
|
|
|
|
2013-02-06 13:06:44 +01:00
|
|
|
/**
|
|
|
|
* mei_cl_all_disconnect - disconnect forcefully all connected clients
|
|
|
|
*
|
2014-09-29 15:31:49 +02:00
|
|
|
* @dev: mei device
|
2013-02-06 13:06:44 +01:00
|
|
|
*/
|
|
|
|
void mei_cl_all_disconnect(struct mei_device *dev)
|
|
|
|
{
|
2014-02-17 14:13:25 +01:00
|
|
|
struct mei_cl *cl;
|
2013-02-06 13:06:44 +01:00
|
|
|
|
2015-05-04 08:43:52 +02:00
|
|
|
list_for_each_entry(cl, &dev->file_list, link)
|
|
|
|
mei_cl_set_disconnected(cl);
|
2013-02-06 13:06:44 +01:00
|
|
|
}
|