mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-23 12:14:43 +07:00
8465def499
The Greybus core code has been stable for a long time, and has been shipping for many years in millions of phones. With the advent of a recent Google Summer of Code project, and a number of new devices in the works from various companies, it is time to get the core greybus code out of staging as it really is going to be with us for a while. Cc: Johan Hovold <johan@kernel.org> Cc: linux-kernel@vger.kernel.org Cc: greybus-dev@lists.linaro.org Acked-by: Viresh Kumar <viresh.kumar@linaro.org> Acked-by: Alex Elder <elder@kernel.org> Link: https://lore.kernel.org/r/20190825055429.18547-9-gregkh@linuxfoundation.org Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
943 lines
23 KiB
C
943 lines
23 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Greybus connections
|
|
*
|
|
* Copyright 2014 Google Inc.
|
|
* Copyright 2014 Linaro Ltd.
|
|
*/
|
|
|
|
#include <linux/workqueue.h>
|
|
#include <linux/greybus.h>
|
|
|
|
#include "greybus_trace.h"
|
|
|
|
#define GB_CONNECTION_CPORT_QUIESCE_TIMEOUT 1000
|
|
|
|
static void gb_connection_kref_release(struct kref *kref);
|
|
|
|
static DEFINE_SPINLOCK(gb_connections_lock);
|
|
static DEFINE_MUTEX(gb_connection_mutex);
|
|
|
|
/* Caller holds gb_connection_mutex. */
|
|
static bool gb_connection_cport_in_use(struct gb_interface *intf, u16 cport_id)
|
|
{
|
|
struct gb_host_device *hd = intf->hd;
|
|
struct gb_connection *connection;
|
|
|
|
list_for_each_entry(connection, &hd->connections, hd_links) {
|
|
if (connection->intf == intf &&
|
|
connection->intf_cport_id == cport_id)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void gb_connection_get(struct gb_connection *connection)
|
|
{
|
|
kref_get(&connection->kref);
|
|
|
|
trace_gb_connection_get(connection);
|
|
}
|
|
|
|
static void gb_connection_put(struct gb_connection *connection)
|
|
{
|
|
trace_gb_connection_put(connection);
|
|
|
|
kref_put(&connection->kref, gb_connection_kref_release);
|
|
}
|
|
|
|
/*
|
|
* Returns a reference-counted pointer to the connection if found.
|
|
*/
|
|
static struct gb_connection *
|
|
gb_connection_hd_find(struct gb_host_device *hd, u16 cport_id)
|
|
{
|
|
struct gb_connection *connection;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&gb_connections_lock, flags);
|
|
list_for_each_entry(connection, &hd->connections, hd_links)
|
|
if (connection->hd_cport_id == cport_id) {
|
|
gb_connection_get(connection);
|
|
goto found;
|
|
}
|
|
connection = NULL;
|
|
found:
|
|
spin_unlock_irqrestore(&gb_connections_lock, flags);
|
|
|
|
return connection;
|
|
}
|
|
|
|
/*
|
|
* Callback from the host driver to let us know that data has been
|
|
* received on the bundle.
|
|
*/
|
|
void greybus_data_rcvd(struct gb_host_device *hd, u16 cport_id,
|
|
u8 *data, size_t length)
|
|
{
|
|
struct gb_connection *connection;
|
|
|
|
trace_gb_hd_in(hd);
|
|
|
|
connection = gb_connection_hd_find(hd, cport_id);
|
|
if (!connection) {
|
|
dev_err(&hd->dev,
|
|
"nonexistent connection (%zu bytes dropped)\n", length);
|
|
return;
|
|
}
|
|
gb_connection_recv(connection, data, length);
|
|
gb_connection_put(connection);
|
|
}
|
|
EXPORT_SYMBOL_GPL(greybus_data_rcvd);
|
|
|
|
static void gb_connection_kref_release(struct kref *kref)
|
|
{
|
|
struct gb_connection *connection;
|
|
|
|
connection = container_of(kref, struct gb_connection, kref);
|
|
|
|
trace_gb_connection_release(connection);
|
|
|
|
kfree(connection);
|
|
}
|
|
|
|
static void gb_connection_init_name(struct gb_connection *connection)
|
|
{
|
|
u16 hd_cport_id = connection->hd_cport_id;
|
|
u16 cport_id = 0;
|
|
u8 intf_id = 0;
|
|
|
|
if (connection->intf) {
|
|
intf_id = connection->intf->interface_id;
|
|
cport_id = connection->intf_cport_id;
|
|
}
|
|
|
|
snprintf(connection->name, sizeof(connection->name),
|
|
"%u/%u:%u", hd_cport_id, intf_id, cport_id);
|
|
}
|
|
|
|
/*
|
|
* _gb_connection_create() - create a Greybus connection
|
|
* @hd: host device of the connection
|
|
* @hd_cport_id: host-device cport id, or -1 for dynamic allocation
|
|
* @intf: remote interface, or NULL for static connections
|
|
* @bundle: remote-interface bundle (may be NULL)
|
|
* @cport_id: remote-interface cport id, or 0 for static connections
|
|
* @handler: request handler (may be NULL)
|
|
* @flags: connection flags
|
|
*
|
|
* Create a Greybus connection, representing the bidirectional link
|
|
* between a CPort on a (local) Greybus host device and a CPort on
|
|
* another Greybus interface.
|
|
*
|
|
* A connection also maintains the state of operations sent over the
|
|
* connection.
|
|
*
|
|
* Serialised against concurrent create and destroy using the
|
|
* gb_connection_mutex.
|
|
*
|
|
* Return: A pointer to the new connection if successful, or an ERR_PTR
|
|
* otherwise.
|
|
*/
|
|
static struct gb_connection *
|
|
_gb_connection_create(struct gb_host_device *hd, int hd_cport_id,
|
|
struct gb_interface *intf,
|
|
struct gb_bundle *bundle, int cport_id,
|
|
gb_request_handler_t handler,
|
|
unsigned long flags)
|
|
{
|
|
struct gb_connection *connection;
|
|
int ret;
|
|
|
|
mutex_lock(&gb_connection_mutex);
|
|
|
|
if (intf && gb_connection_cport_in_use(intf, cport_id)) {
|
|
dev_err(&intf->dev, "cport %u already in use\n", cport_id);
|
|
ret = -EBUSY;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = gb_hd_cport_allocate(hd, hd_cport_id, flags);
|
|
if (ret < 0) {
|
|
dev_err(&hd->dev, "failed to allocate cport: %d\n", ret);
|
|
goto err_unlock;
|
|
}
|
|
hd_cport_id = ret;
|
|
|
|
connection = kzalloc(sizeof(*connection), GFP_KERNEL);
|
|
if (!connection) {
|
|
ret = -ENOMEM;
|
|
goto err_hd_cport_release;
|
|
}
|
|
|
|
connection->hd_cport_id = hd_cport_id;
|
|
connection->intf_cport_id = cport_id;
|
|
connection->hd = hd;
|
|
connection->intf = intf;
|
|
connection->bundle = bundle;
|
|
connection->handler = handler;
|
|
connection->flags = flags;
|
|
if (intf && (intf->quirks & GB_INTERFACE_QUIRK_NO_CPORT_FEATURES))
|
|
connection->flags |= GB_CONNECTION_FLAG_NO_FLOWCTRL;
|
|
connection->state = GB_CONNECTION_STATE_DISABLED;
|
|
|
|
atomic_set(&connection->op_cycle, 0);
|
|
mutex_init(&connection->mutex);
|
|
spin_lock_init(&connection->lock);
|
|
INIT_LIST_HEAD(&connection->operations);
|
|
|
|
connection->wq = alloc_workqueue("%s:%d", WQ_UNBOUND, 1,
|
|
dev_name(&hd->dev), hd_cport_id);
|
|
if (!connection->wq) {
|
|
ret = -ENOMEM;
|
|
goto err_free_connection;
|
|
}
|
|
|
|
kref_init(&connection->kref);
|
|
|
|
gb_connection_init_name(connection);
|
|
|
|
spin_lock_irq(&gb_connections_lock);
|
|
list_add(&connection->hd_links, &hd->connections);
|
|
|
|
if (bundle)
|
|
list_add(&connection->bundle_links, &bundle->connections);
|
|
else
|
|
INIT_LIST_HEAD(&connection->bundle_links);
|
|
|
|
spin_unlock_irq(&gb_connections_lock);
|
|
|
|
mutex_unlock(&gb_connection_mutex);
|
|
|
|
trace_gb_connection_create(connection);
|
|
|
|
return connection;
|
|
|
|
err_free_connection:
|
|
kfree(connection);
|
|
err_hd_cport_release:
|
|
gb_hd_cport_release(hd, hd_cport_id);
|
|
err_unlock:
|
|
mutex_unlock(&gb_connection_mutex);
|
|
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
struct gb_connection *
|
|
gb_connection_create_static(struct gb_host_device *hd, u16 hd_cport_id,
|
|
gb_request_handler_t handler)
|
|
{
|
|
return _gb_connection_create(hd, hd_cport_id, NULL, NULL, 0, handler,
|
|
GB_CONNECTION_FLAG_HIGH_PRIO);
|
|
}
|
|
|
|
struct gb_connection *
|
|
gb_connection_create_control(struct gb_interface *intf)
|
|
{
|
|
return _gb_connection_create(intf->hd, -1, intf, NULL, 0, NULL,
|
|
GB_CONNECTION_FLAG_CONTROL |
|
|
GB_CONNECTION_FLAG_HIGH_PRIO);
|
|
}
|
|
|
|
struct gb_connection *
|
|
gb_connection_create(struct gb_bundle *bundle, u16 cport_id,
|
|
gb_request_handler_t handler)
|
|
{
|
|
struct gb_interface *intf = bundle->intf;
|
|
|
|
return _gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
|
|
handler, 0);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_create);
|
|
|
|
struct gb_connection *
|
|
gb_connection_create_flags(struct gb_bundle *bundle, u16 cport_id,
|
|
gb_request_handler_t handler,
|
|
unsigned long flags)
|
|
{
|
|
struct gb_interface *intf = bundle->intf;
|
|
|
|
if (WARN_ON_ONCE(flags & GB_CONNECTION_FLAG_CORE_MASK))
|
|
flags &= ~GB_CONNECTION_FLAG_CORE_MASK;
|
|
|
|
return _gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
|
|
handler, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_create_flags);
|
|
|
|
struct gb_connection *
|
|
gb_connection_create_offloaded(struct gb_bundle *bundle, u16 cport_id,
|
|
unsigned long flags)
|
|
{
|
|
flags |= GB_CONNECTION_FLAG_OFFLOADED;
|
|
|
|
return gb_connection_create_flags(bundle, cport_id, NULL, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_create_offloaded);
|
|
|
|
static int gb_connection_hd_cport_enable(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->cport_enable)
|
|
return 0;
|
|
|
|
ret = hd->driver->cport_enable(hd, connection->hd_cport_id,
|
|
connection->flags);
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to enable host cport: %d\n",
|
|
connection->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void gb_connection_hd_cport_disable(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->cport_disable)
|
|
return;
|
|
|
|
ret = hd->driver->cport_disable(hd, connection->hd_cport_id);
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to disable host cport: %d\n",
|
|
connection->name, ret);
|
|
}
|
|
}
|
|
|
|
static int gb_connection_hd_cport_connected(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->cport_connected)
|
|
return 0;
|
|
|
|
ret = hd->driver->cport_connected(hd, connection->hd_cport_id);
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to set connected state: %d\n",
|
|
connection->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gb_connection_hd_cport_flush(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->cport_flush)
|
|
return 0;
|
|
|
|
ret = hd->driver->cport_flush(hd, connection->hd_cport_id);
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to flush host cport: %d\n",
|
|
connection->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gb_connection_hd_cport_quiesce(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
size_t peer_space;
|
|
int ret;
|
|
|
|
if (!hd->driver->cport_quiesce)
|
|
return 0;
|
|
|
|
peer_space = sizeof(struct gb_operation_msg_hdr) +
|
|
sizeof(struct gb_cport_shutdown_request);
|
|
|
|
if (connection->mode_switch)
|
|
peer_space += sizeof(struct gb_operation_msg_hdr);
|
|
|
|
if (!hd->driver->cport_quiesce)
|
|
return 0;
|
|
|
|
ret = hd->driver->cport_quiesce(hd, connection->hd_cport_id,
|
|
peer_space,
|
|
GB_CONNECTION_CPORT_QUIESCE_TIMEOUT);
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to quiesce host cport: %d\n",
|
|
connection->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gb_connection_hd_cport_clear(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->cport_clear)
|
|
return 0;
|
|
|
|
ret = hd->driver->cport_clear(hd, connection->hd_cport_id);
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to clear host cport: %d\n",
|
|
connection->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Request the SVC to create a connection from AP's cport to interface's
|
|
* cport.
|
|
*/
|
|
static int
|
|
gb_connection_svc_connection_create(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
struct gb_interface *intf;
|
|
u8 cport_flags;
|
|
int ret;
|
|
|
|
if (gb_connection_is_static(connection))
|
|
return 0;
|
|
|
|
intf = connection->intf;
|
|
|
|
/*
|
|
* Enable either E2EFC or CSD, unless no flow control is requested.
|
|
*/
|
|
cport_flags = GB_SVC_CPORT_FLAG_CSV_N;
|
|
if (gb_connection_flow_control_disabled(connection)) {
|
|
cport_flags |= GB_SVC_CPORT_FLAG_CSD_N;
|
|
} else if (gb_connection_e2efc_enabled(connection)) {
|
|
cport_flags |= GB_SVC_CPORT_FLAG_CSD_N |
|
|
GB_SVC_CPORT_FLAG_E2EFC;
|
|
}
|
|
|
|
ret = gb_svc_connection_create(hd->svc,
|
|
hd->svc->ap_intf_id,
|
|
connection->hd_cport_id,
|
|
intf->interface_id,
|
|
connection->intf_cport_id,
|
|
cport_flags);
|
|
if (ret) {
|
|
dev_err(&connection->hd->dev,
|
|
"%s: failed to create svc connection: %d\n",
|
|
connection->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
gb_connection_svc_connection_destroy(struct gb_connection *connection)
|
|
{
|
|
if (gb_connection_is_static(connection))
|
|
return;
|
|
|
|
gb_svc_connection_destroy(connection->hd->svc,
|
|
connection->hd->svc->ap_intf_id,
|
|
connection->hd_cport_id,
|
|
connection->intf->interface_id,
|
|
connection->intf_cport_id);
|
|
}
|
|
|
|
/* Inform Interface about active CPorts */
|
|
static int gb_connection_control_connected(struct gb_connection *connection)
|
|
{
|
|
struct gb_control *control;
|
|
u16 cport_id = connection->intf_cport_id;
|
|
int ret;
|
|
|
|
if (gb_connection_is_static(connection))
|
|
return 0;
|
|
|
|
if (gb_connection_is_control(connection))
|
|
return 0;
|
|
|
|
control = connection->intf->control;
|
|
|
|
ret = gb_control_connected_operation(control, cport_id);
|
|
if (ret) {
|
|
dev_err(&connection->bundle->dev,
|
|
"failed to connect cport: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
gb_connection_control_disconnecting(struct gb_connection *connection)
|
|
{
|
|
struct gb_control *control;
|
|
u16 cport_id = connection->intf_cport_id;
|
|
int ret;
|
|
|
|
if (gb_connection_is_static(connection))
|
|
return;
|
|
|
|
control = connection->intf->control;
|
|
|
|
ret = gb_control_disconnecting_operation(control, cport_id);
|
|
if (ret) {
|
|
dev_err(&connection->hd->dev,
|
|
"%s: failed to send disconnecting: %d\n",
|
|
connection->name, ret);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gb_connection_control_disconnected(struct gb_connection *connection)
|
|
{
|
|
struct gb_control *control;
|
|
u16 cport_id = connection->intf_cport_id;
|
|
int ret;
|
|
|
|
if (gb_connection_is_static(connection))
|
|
return;
|
|
|
|
control = connection->intf->control;
|
|
|
|
if (gb_connection_is_control(connection)) {
|
|
if (connection->mode_switch) {
|
|
ret = gb_control_mode_switch_operation(control);
|
|
if (ret) {
|
|
/*
|
|
* Allow mode switch to time out waiting for
|
|
* mailbox event.
|
|
*/
|
|
return;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
ret = gb_control_disconnected_operation(control, cport_id);
|
|
if (ret) {
|
|
dev_warn(&connection->bundle->dev,
|
|
"failed to disconnect cport: %d\n", ret);
|
|
}
|
|
}
|
|
|
|
static int gb_connection_shutdown_operation(struct gb_connection *connection,
|
|
u8 phase)
|
|
{
|
|
struct gb_cport_shutdown_request *req;
|
|
struct gb_operation *operation;
|
|
int ret;
|
|
|
|
operation = gb_operation_create_core(connection,
|
|
GB_REQUEST_TYPE_CPORT_SHUTDOWN,
|
|
sizeof(*req), 0, 0,
|
|
GFP_KERNEL);
|
|
if (!operation)
|
|
return -ENOMEM;
|
|
|
|
req = operation->request->payload;
|
|
req->phase = phase;
|
|
|
|
ret = gb_operation_request_send_sync(operation);
|
|
|
|
gb_operation_put(operation);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int gb_connection_cport_shutdown(struct gb_connection *connection,
|
|
u8 phase)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
const struct gb_hd_driver *drv = hd->driver;
|
|
int ret;
|
|
|
|
if (gb_connection_is_static(connection))
|
|
return 0;
|
|
|
|
if (gb_connection_is_offloaded(connection)) {
|
|
if (!drv->cport_shutdown)
|
|
return 0;
|
|
|
|
ret = drv->cport_shutdown(hd, connection->hd_cport_id, phase,
|
|
GB_OPERATION_TIMEOUT_DEFAULT);
|
|
} else {
|
|
ret = gb_connection_shutdown_operation(connection, phase);
|
|
}
|
|
|
|
if (ret) {
|
|
dev_err(&hd->dev, "%s: failed to send cport shutdown (phase %d): %d\n",
|
|
connection->name, phase, ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
gb_connection_cport_shutdown_phase_1(struct gb_connection *connection)
|
|
{
|
|
return gb_connection_cport_shutdown(connection, 1);
|
|
}
|
|
|
|
static int
|
|
gb_connection_cport_shutdown_phase_2(struct gb_connection *connection)
|
|
{
|
|
return gb_connection_cport_shutdown(connection, 2);
|
|
}
|
|
|
|
/*
|
|
* Cancel all active operations on a connection.
|
|
*
|
|
* Locking: Called with connection lock held and state set to DISABLED or
|
|
* DISCONNECTING.
|
|
*/
|
|
static void gb_connection_cancel_operations(struct gb_connection *connection,
|
|
int errno)
|
|
__must_hold(&connection->lock)
|
|
{
|
|
struct gb_operation *operation;
|
|
|
|
while (!list_empty(&connection->operations)) {
|
|
operation = list_last_entry(&connection->operations,
|
|
struct gb_operation, links);
|
|
gb_operation_get(operation);
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
if (gb_operation_is_incoming(operation))
|
|
gb_operation_cancel_incoming(operation, errno);
|
|
else
|
|
gb_operation_cancel(operation, errno);
|
|
|
|
gb_operation_put(operation);
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Cancel all active incoming operations on a connection.
|
|
*
|
|
* Locking: Called with connection lock held and state set to ENABLED_TX.
|
|
*/
|
|
static void
|
|
gb_connection_flush_incoming_operations(struct gb_connection *connection,
|
|
int errno)
|
|
__must_hold(&connection->lock)
|
|
{
|
|
struct gb_operation *operation;
|
|
bool incoming;
|
|
|
|
while (!list_empty(&connection->operations)) {
|
|
incoming = false;
|
|
list_for_each_entry(operation, &connection->operations,
|
|
links) {
|
|
if (gb_operation_is_incoming(operation)) {
|
|
gb_operation_get(operation);
|
|
incoming = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!incoming)
|
|
break;
|
|
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
/* FIXME: flush, not cancel? */
|
|
gb_operation_cancel_incoming(operation, errno);
|
|
gb_operation_put(operation);
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* _gb_connection_enable() - enable a connection
|
|
* @connection: connection to enable
|
|
* @rx: whether to enable incoming requests
|
|
*
|
|
* Connection-enable helper for DISABLED->ENABLED, DISABLED->ENABLED_TX, and
|
|
* ENABLED_TX->ENABLED state transitions.
|
|
*
|
|
* Locking: Caller holds connection->mutex.
|
|
*/
|
|
static int _gb_connection_enable(struct gb_connection *connection, bool rx)
|
|
{
|
|
int ret;
|
|
|
|
/* Handle ENABLED_TX -> ENABLED transitions. */
|
|
if (connection->state == GB_CONNECTION_STATE_ENABLED_TX) {
|
|
if (!(connection->handler && rx))
|
|
return 0;
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
connection->state = GB_CONNECTION_STATE_ENABLED;
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
ret = gb_connection_hd_cport_enable(connection);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = gb_connection_svc_connection_create(connection);
|
|
if (ret)
|
|
goto err_hd_cport_clear;
|
|
|
|
ret = gb_connection_hd_cport_connected(connection);
|
|
if (ret)
|
|
goto err_svc_connection_destroy;
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
if (connection->handler && rx)
|
|
connection->state = GB_CONNECTION_STATE_ENABLED;
|
|
else
|
|
connection->state = GB_CONNECTION_STATE_ENABLED_TX;
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
ret = gb_connection_control_connected(connection);
|
|
if (ret)
|
|
goto err_control_disconnecting;
|
|
|
|
return 0;
|
|
|
|
err_control_disconnecting:
|
|
spin_lock_irq(&connection->lock);
|
|
connection->state = GB_CONNECTION_STATE_DISCONNECTING;
|
|
gb_connection_cancel_operations(connection, -ESHUTDOWN);
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
/* Transmit queue should already be empty. */
|
|
gb_connection_hd_cport_flush(connection);
|
|
|
|
gb_connection_control_disconnecting(connection);
|
|
gb_connection_cport_shutdown_phase_1(connection);
|
|
gb_connection_hd_cport_quiesce(connection);
|
|
gb_connection_cport_shutdown_phase_2(connection);
|
|
gb_connection_control_disconnected(connection);
|
|
connection->state = GB_CONNECTION_STATE_DISABLED;
|
|
err_svc_connection_destroy:
|
|
gb_connection_svc_connection_destroy(connection);
|
|
err_hd_cport_clear:
|
|
gb_connection_hd_cport_clear(connection);
|
|
|
|
gb_connection_hd_cport_disable(connection);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int gb_connection_enable(struct gb_connection *connection)
|
|
{
|
|
int ret = 0;
|
|
|
|
mutex_lock(&connection->mutex);
|
|
|
|
if (connection->state == GB_CONNECTION_STATE_ENABLED)
|
|
goto out_unlock;
|
|
|
|
ret = _gb_connection_enable(connection, true);
|
|
if (!ret)
|
|
trace_gb_connection_enable(connection);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&connection->mutex);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_enable);
|
|
|
|
int gb_connection_enable_tx(struct gb_connection *connection)
|
|
{
|
|
int ret = 0;
|
|
|
|
mutex_lock(&connection->mutex);
|
|
|
|
if (connection->state == GB_CONNECTION_STATE_ENABLED) {
|
|
ret = -EINVAL;
|
|
goto out_unlock;
|
|
}
|
|
|
|
if (connection->state == GB_CONNECTION_STATE_ENABLED_TX)
|
|
goto out_unlock;
|
|
|
|
ret = _gb_connection_enable(connection, false);
|
|
if (!ret)
|
|
trace_gb_connection_enable(connection);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&connection->mutex);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_enable_tx);
|
|
|
|
void gb_connection_disable_rx(struct gb_connection *connection)
|
|
{
|
|
mutex_lock(&connection->mutex);
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
if (connection->state != GB_CONNECTION_STATE_ENABLED) {
|
|
spin_unlock_irq(&connection->lock);
|
|
goto out_unlock;
|
|
}
|
|
connection->state = GB_CONNECTION_STATE_ENABLED_TX;
|
|
gb_connection_flush_incoming_operations(connection, -ESHUTDOWN);
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
trace_gb_connection_disable(connection);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&connection->mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_disable_rx);
|
|
|
|
void gb_connection_mode_switch_prepare(struct gb_connection *connection)
|
|
{
|
|
connection->mode_switch = true;
|
|
}
|
|
|
|
void gb_connection_mode_switch_complete(struct gb_connection *connection)
|
|
{
|
|
gb_connection_svc_connection_destroy(connection);
|
|
gb_connection_hd_cport_clear(connection);
|
|
|
|
gb_connection_hd_cport_disable(connection);
|
|
|
|
connection->mode_switch = false;
|
|
}
|
|
|
|
void gb_connection_disable(struct gb_connection *connection)
|
|
{
|
|
mutex_lock(&connection->mutex);
|
|
|
|
if (connection->state == GB_CONNECTION_STATE_DISABLED)
|
|
goto out_unlock;
|
|
|
|
trace_gb_connection_disable(connection);
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
connection->state = GB_CONNECTION_STATE_DISCONNECTING;
|
|
gb_connection_cancel_operations(connection, -ESHUTDOWN);
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
gb_connection_hd_cport_flush(connection);
|
|
|
|
gb_connection_control_disconnecting(connection);
|
|
gb_connection_cport_shutdown_phase_1(connection);
|
|
gb_connection_hd_cport_quiesce(connection);
|
|
gb_connection_cport_shutdown_phase_2(connection);
|
|
gb_connection_control_disconnected(connection);
|
|
|
|
connection->state = GB_CONNECTION_STATE_DISABLED;
|
|
|
|
/* control-connection tear down is deferred when mode switching */
|
|
if (!connection->mode_switch) {
|
|
gb_connection_svc_connection_destroy(connection);
|
|
gb_connection_hd_cport_clear(connection);
|
|
|
|
gb_connection_hd_cport_disable(connection);
|
|
}
|
|
|
|
out_unlock:
|
|
mutex_unlock(&connection->mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_disable);
|
|
|
|
/* Disable a connection without communicating with the remote end. */
|
|
void gb_connection_disable_forced(struct gb_connection *connection)
|
|
{
|
|
mutex_lock(&connection->mutex);
|
|
|
|
if (connection->state == GB_CONNECTION_STATE_DISABLED)
|
|
goto out_unlock;
|
|
|
|
trace_gb_connection_disable(connection);
|
|
|
|
spin_lock_irq(&connection->lock);
|
|
connection->state = GB_CONNECTION_STATE_DISABLED;
|
|
gb_connection_cancel_operations(connection, -ESHUTDOWN);
|
|
spin_unlock_irq(&connection->lock);
|
|
|
|
gb_connection_hd_cport_flush(connection);
|
|
|
|
gb_connection_svc_connection_destroy(connection);
|
|
gb_connection_hd_cport_clear(connection);
|
|
|
|
gb_connection_hd_cport_disable(connection);
|
|
out_unlock:
|
|
mutex_unlock(&connection->mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_disable_forced);
|
|
|
|
/* Caller must have disabled the connection before destroying it. */
|
|
void gb_connection_destroy(struct gb_connection *connection)
|
|
{
|
|
if (!connection)
|
|
return;
|
|
|
|
if (WARN_ON(connection->state != GB_CONNECTION_STATE_DISABLED))
|
|
gb_connection_disable(connection);
|
|
|
|
mutex_lock(&gb_connection_mutex);
|
|
|
|
spin_lock_irq(&gb_connections_lock);
|
|
list_del(&connection->bundle_links);
|
|
list_del(&connection->hd_links);
|
|
spin_unlock_irq(&gb_connections_lock);
|
|
|
|
destroy_workqueue(connection->wq);
|
|
|
|
gb_hd_cport_release(connection->hd, connection->hd_cport_id);
|
|
connection->hd_cport_id = CPORT_ID_BAD;
|
|
|
|
mutex_unlock(&gb_connection_mutex);
|
|
|
|
gb_connection_put(connection);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_destroy);
|
|
|
|
void gb_connection_latency_tag_enable(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->latency_tag_enable)
|
|
return;
|
|
|
|
ret = hd->driver->latency_tag_enable(hd, connection->hd_cport_id);
|
|
if (ret) {
|
|
dev_err(&connection->hd->dev,
|
|
"%s: failed to enable latency tag: %d\n",
|
|
connection->name, ret);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_latency_tag_enable);
|
|
|
|
void gb_connection_latency_tag_disable(struct gb_connection *connection)
|
|
{
|
|
struct gb_host_device *hd = connection->hd;
|
|
int ret;
|
|
|
|
if (!hd->driver->latency_tag_disable)
|
|
return;
|
|
|
|
ret = hd->driver->latency_tag_disable(hd, connection->hd_cport_id);
|
|
if (ret) {
|
|
dev_err(&connection->hd->dev,
|
|
"%s: failed to disable latency tag: %d\n",
|
|
connection->name, ret);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_connection_latency_tag_disable);
|