X-Git-Url: http://git.cascardo.info/?a=blobdiff_plain;f=drivers%2Fstaging%2Fgreybus%2Fconnection.c;h=3be767b9a0de19effd9a072886a13fde9ae81606;hb=55742d2a071a569bf20f90d37b1b5b8a25a3f882;hp=d87a346d1ce327d925299e9a2dc62b917dec681f;hpb=2566fae6a5eb29e52502a38fd816c6e994547625;p=cascardo%2Flinux.git

diff --git a/drivers/staging/greybus/connection.c b/drivers/staging/greybus/connection.c
index d87a346d1ce3..3be767b9a0de 100644
--- a/drivers/staging/greybus/connection.c
+++ b/drivers/staging/greybus/connection.c
@@ -11,22 +11,43 @@
 
 #include "greybus.h"
 
+
+static void gb_connection_kref_release(struct kref *kref);
+
+
 static DEFINE_SPINLOCK(gb_connections_lock);
+static DEFINE_MUTEX(gb_connection_mutex);
 
-/* This is only used at initialization time; no locking is required. */
+
+/* Caller holds gb_connection_mutex. */
 static struct gb_connection *
 gb_connection_intf_find(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->bundle->intf == intf &&
+	list_for_each_entry(connection, &hd->connections, hd_links) {
+		if (connection->intf == intf &&
 				connection->intf_cport_id == cport_id)
 			return connection;
+	}
+
 	return NULL;
 }
 
+static void gb_connection_get(struct gb_connection *connection)
+{
+	kref_get(&connection->kref);
+}
+
+static void gb_connection_put(struct gb_connection *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)
 {
@@ -35,8 +56,10 @@ gb_connection_hd_find(struct gb_host_device *hd, u16 cport_id)
 
 	spin_lock_irqsave(&gb_connections_lock, flags);
 	list_for_each_entry(connection, &hd->connections, hd_links)
-		if (connection->hd_cport_id == cport_id)
+		if (connection->hd_cport_id == cport_id) {
+			gb_connection_get(connection);
 			goto found;
+		}
 	connection = NULL;
 found:
 	spin_unlock_irqrestore(&gb_connections_lock, flags);
@@ -60,47 +83,43 @@ void greybus_data_rcvd(struct gb_host_device *hd, u16 cport_id,
 		return;
 	}
 	gb_connection_recv(connection, data, length);
+	gb_connection_put(connection);
 }
 EXPORT_SYMBOL_GPL(greybus_data_rcvd);
 
-static DEFINE_MUTEX(connection_mutex);
-
 static void gb_connection_kref_release(struct kref *kref)
 {
 	struct gb_connection *connection;
 
 	connection = container_of(kref, struct gb_connection, kref);
-	destroy_workqueue(connection->wq);
+
 	kfree(connection);
-	mutex_unlock(&connection_mutex);
 }
 
-int svc_update_connection(struct gb_interface *intf,
-			  struct gb_connection *connection)
+static void gb_connection_init_name(struct gb_connection *connection)
 {
-	struct gb_bundle *bundle;
-
-	bundle = gb_bundle_create(intf, GB_SVC_BUNDLE_ID, GREYBUS_CLASS_SVC);
-	if (!bundle)
-		return -EINVAL;
+	u16 hd_cport_id = connection->hd_cport_id;
+	u16 cport_id = 0;
+	u8 intf_id = 0;
 
-	connection->bundle = bundle;
-
-	spin_lock_irq(&gb_connections_lock);
-	list_add(&connection->bundle_links, &bundle->connections);
-	spin_unlock_irq(&gb_connections_lock);
+	if (connection->intf) {
+		intf_id = connection->intf->interface_id;
+		cport_id = connection->intf_cport_id;
+	}
 
-	return 0;
+	snprintf(connection->name, sizeof(connection->name),
+			"%u/%u:%u", hd_cport_id, intf_id, cport_id);
 }
 
 /*
- * gb_connection_create() - create a Greybus connection
+ * _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
- * @protocol_id:	protocol id
+ * @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
@@ -109,74 +128,70 @@ int svc_update_connection(struct gb_interface *intf,
  * A connection also maintains the state of operations sent over the
  * connection.
  *
- * Return: A pointer to the new connection if successful, or NULL otherwise.
+ * 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,
+_gb_connection_create(struct gb_host_device *hd, int hd_cport_id,
 				struct gb_interface *intf,
 				struct gb_bundle *bundle, int cport_id,
-				u8 protocol_id)
+				gb_request_handler_t handler,
+				unsigned long flags)
 {
 	struct gb_connection *connection;
-	struct ida *id_map = &hd->cport_id_map;
-	int ida_start, ida_end;
-	int retval;
-	u8 major = 0;
-	u8 minor = 1;
+	int ret;
 
-	/*
-	 * If a manifest tries to reuse a cport, reject it.  We
-	 * initialize connections serially so we don't need to worry
-	 * about holding the connection lock.
-	 */
-	if (bundle && gb_connection_intf_find(bundle->intf, cport_id)) {
-		dev_err(&bundle->dev, "cport 0x%04hx already connected\n",
-				cport_id);
-		return NULL;
-	}
+	mutex_lock(&gb_connection_mutex);
 
-	if (hd_cport_id < 0) {
-		ida_start = 0;
-		ida_end = hd->num_cports;
-	} else if (hd_cport_id < hd->num_cports) {
-		ida_start = hd_cport_id;
-		ida_end = hd_cport_id + 1;
-	} else {
-		dev_err(&hd->dev, "cport %d not available\n", hd_cport_id);
-		return NULL;
+	if (intf && gb_connection_intf_find(intf, cport_id)) {
+		dev_err(&intf->dev, "cport %u already in use\n", cport_id);
+		ret = -EBUSY;
+		goto err_unlock;
 	}
 
-	hd_cport_id = ida_simple_get(id_map, ida_start, ida_end, GFP_KERNEL);
-	if (hd_cport_id < 0)
-		return NULL;
+	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)
-		goto err_remove_ida;
+	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->protocol_id = protocol_id;
-	connection->major = major;
-	connection->minor = minor;
-
 	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)
+	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);
 
@@ -187,40 +202,70 @@ gb_connection_create(struct gb_host_device *hd, int hd_cport_id,
 
 	spin_unlock_irq(&gb_connections_lock);
 
-	retval = gb_connection_bind_protocol(connection);
-	if (retval) {
-		dev_err(&hd->dev, "%d: failed to bind protocol: %d\n",
-			cport_id, retval);
-		gb_connection_destroy(connection);
-		return NULL;
-	}
+	mutex_unlock(&gb_connection_mutex);
 
 	return connection;
 
 err_free_connection:
 	kfree(connection);
-err_remove_ida:
-	ida_simple_remove(id_map, hd_cport_id);
+err_hd_cport_release:
+	gb_hd_cport_release(hd, hd_cport_id);
+err_unlock:
+	mutex_unlock(&gb_connection_mutex);
 
-	return NULL;
+	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,
+					0);
+}
+
+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);
+}
+
+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_static(struct gb_host_device *hd,
-					u16 hd_cport_id, u8 protocol_id)
+gb_connection_create_flags(struct gb_bundle *bundle, u16 cport_id,
+					gb_request_handler_t handler,
+					unsigned long flags)
 {
-	return gb_connection_create(hd, hd_cport_id, NULL, NULL, 0,
-								protocol_id);
+	struct gb_interface *intf = bundle->intf;
+
+	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_dynamic(struct gb_interface *intf,
-					struct gb_bundle *bundle,
-					u16 cport_id, u8 protocol_id)
+gb_connection_create_offloaded(struct gb_bundle *bundle, u16 cport_id,
+					unsigned long flags)
 {
-	return gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
-								protocol_id);
+	struct gb_interface *intf = bundle->intf;
+
+	flags |= GB_CONNECTION_FLAG_OFFLOADED;
+
+	return _gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
+					NULL, flags);
 }
+EXPORT_SYMBOL_GPL(gb_connection_create_offloaded);
 
 static int gb_connection_hd_cport_enable(struct gb_connection *connection)
 {
@@ -233,7 +278,8 @@ static int gb_connection_hd_cport_enable(struct gb_connection *connection)
 	ret = hd->driver->cport_enable(hd, connection->hd_cport_id);
 	if (ret) {
 		dev_err(&hd->dev,
-			"failed to enable host cport: %d\n", ret);
+				"%s: failed to enable host cport: %d\n",
+				connection->name, ret);
 		return ret;
 	}
 
@@ -243,40 +289,65 @@ static int gb_connection_hd_cport_enable(struct gb_connection *connection)
 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;
 
-	hd->driver->cport_disable(hd, connection->hd_cport_id);
+	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);
+	}
 }
 
-/*
- * Cancel all active operations on a connection.
- *
- * Should only be called during connection tear down.
- */
-static void gb_connection_cancel_operations(struct gb_connection *connection,
-						int errno)
+static int gb_connection_hd_cport_flush(struct gb_connection *connection)
 {
-	struct gb_operation *operation;
+	struct gb_host_device *hd = connection->hd;
+	int ret;
 
-	spin_lock_irq(&connection->lock);
-	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 (!hd->driver->cport_flush)
+		return 0;
 
-		if (gb_operation_is_incoming(operation))
-			gb_operation_cancel_incoming(operation, errno);
-		else
-			gb_operation_cancel(operation, errno);
+	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;
+	}
 
-		gb_operation_put(operation);
+	return 0;
+}
 
-		spin_lock_irq(&connection->lock);
+static int
+gb_connection_hd_cport_features_enable(struct gb_connection *connection)
+{
+	struct gb_host_device *hd = connection->hd;
+	int ret;
+
+	if (!hd->driver->cport_features_enable)
+		return 0;
+
+	ret = hd->driver->cport_features_enable(hd, connection->hd_cport_id);
+	if (ret) {
+		dev_err(&hd->dev, "%s: failed to enable CPort features: %d\n",
+			connection->name, ret);
+		return ret;
 	}
-	spin_unlock_irq(&connection->lock);
+
+	return 0;
+}
+
+static void
+gb_connection_hd_cport_features_disable(struct gb_connection *connection)
+{
+	struct gb_host_device *hd = connection->hd;
+
+	if (!hd->driver->cport_features_disable)
+		return;
+
+	hd->driver->cport_features_disable(hd, connection->hd_cport_id);
 }
 
 /*
@@ -287,23 +358,36 @@ static int
 gb_connection_svc_connection_create(struct gb_connection *connection)
 {
 	struct gb_host_device *hd = connection->hd;
-	struct gb_protocol *protocol = connection->protocol;
 	struct gb_interface *intf;
+	u8 cport_flags;
 	int ret;
 
-	if (protocol->flags & GB_PROTOCOL_SKIP_SVC_CONNECTION)
+	if (gb_connection_is_static(connection))
 		return 0;
 
-	intf = connection->bundle->intf;
+	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,
-			intf->boot_over_unipro);
+			cport_flags);
 	if (ret) {
-		dev_err(&connection->bundle->dev,
-			"failed to create svc connection: %d\n", ret);
+		dev_err(&connection->hd->dev,
+			"%s: failed to create svc connection: %d\n",
+			connection->name, ret);
 		return ret;
 	}
 
@@ -313,28 +397,55 @@ gb_connection_svc_connection_create(struct gb_connection *connection)
 static void
 gb_connection_svc_connection_destroy(struct gb_connection *connection)
 {
-	if (connection->protocol->flags & GB_PROTOCOL_SKIP_SVC_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->bundle->intf->interface_id,
+				  connection->intf->interface_id,
 				  connection->intf_cport_id);
 }
 
+static void
+gb_connection_svc_connection_quiescing(struct gb_connection *connection)
+{
+	struct gb_host_device *hd = connection->hd;
+
+	if (gb_connection_is_static(connection))
+		return;
+
+	gb_svc_connection_quiescing(hd->svc,
+					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_protocol *protocol = connection->protocol;
 	struct gb_control *control;
 	u16 cport_id = connection->intf_cport_id;
 	int ret;
 
-	if (protocol->flags & GB_PROTOCOL_SKIP_CONTROL_CONNECTED)
+	if (gb_connection_is_static(connection))
+		return 0;
+
+	/*
+	 * HACK: Suppress connected request for the offloaded camera
+	 * connection as it is currently not supported by firmware. Note that
+	 * the corresponding non-fatal disconnected event is still sent.
+	 */
+	if (gb_connection_is_offloaded(connection) &&
+			connection->flags & GB_CONNECTION_FLAG_CDSI1) {
+		return 0;
+	}
+
+	if (gb_connection_is_control(connection))
 		return 0;
 
-	control = connection->bundle->intf->control;
+	control = connection->intf->control;
 
 	ret = gb_control_connected_operation(control, cport_id);
 	if (ret) {
@@ -346,19 +457,53 @@ static int gb_connection_control_connected(struct gb_connection *connection)
 	return 0;
 }
 
-/* Inform Interface about inactive CPorts */
+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_protocol *protocol = connection->protocol;
 	struct gb_control *control;
 	u16 cport_id = connection->intf_cport_id;
 	int ret;
 
-	if (protocol->flags & GB_PROTOCOL_SKIP_CONTROL_DISCONNECTED)
+	if (gb_connection_is_static(connection))
 		return;
 
-	control = connection->bundle->intf->control;
+	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) {
@@ -367,33 +512,143 @@ gb_connection_control_disconnected(struct gb_connection *connection)
 	}
 }
 
-/*
- * Request protocol version supported by the module. We don't need to do
- * this for SVC as that is initiated by the SVC.
- */
-static int gb_connection_protocol_get_version(struct gb_connection *connection)
+static int gb_connection_ping_operation(struct gb_connection *connection)
 {
-	struct gb_protocol *protocol = connection->protocol;
+	struct gb_operation *operation;
 	int ret;
 
-	if (protocol->flags & GB_PROTOCOL_SKIP_VERSION)
+	operation = gb_operation_create_core(connection,
+						GB_REQUEST_TYPE_PING,
+						0, 0, 0,
+						GFP_KERNEL);
+	if (!operation)
+		return -ENOMEM;
+
+	ret = gb_operation_request_send_sync(operation);
+
+	gb_operation_put(operation);
+
+	return ret;
+}
+
+static int gb_connection_ping(struct gb_connection *connection)
+{
+	struct gb_host_device *hd = connection->hd;
+	int ret;
+
+	if (gb_connection_is_static(connection))
 		return 0;
 
-	ret = gb_protocol_get_version(connection);
+	if (gb_connection_is_offloaded(connection)) {
+		if (!hd->driver->cport_ping)
+			return 0;
+
+		ret = hd->driver->cport_ping(hd, connection->intf_cport_id);
+	} else {
+		ret = gb_connection_ping_operation(connection);
+	}
+
 	if (ret) {
-		dev_err(&connection->bundle->dev,
-			"failed to get protocol version: %d\n", ret);
+		dev_err(&hd->dev, "%s: failed to send ping: %d\n",
+				connection->name, ret);
 		return ret;
 	}
 
 	return 0;
 }
 
-static int gb_connection_init(struct gb_connection *connection)
+/*
+ * 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)
 {
-	struct gb_protocol *protocol = connection->protocol;
 	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;
@@ -402,32 +657,41 @@ static int gb_connection_init(struct gb_connection *connection)
 	if (ret)
 		goto err_hd_cport_disable;
 
-	ret = gb_connection_control_connected(connection);
+	ret = gb_connection_hd_cport_features_enable(connection);
 	if (ret)
-		goto err_svc_destroy;
+		goto err_svc_connection_destroy;
 
-	/* Need to enable the connection to initialize it */
 	spin_lock_irq(&connection->lock);
-	connection->state = GB_CONNECTION_STATE_ENABLED;
+	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_protocol_get_version(connection);
-	if (ret)
-		goto err_disconnect;
-
-	ret = protocol->connection_init(connection);
+	ret = gb_connection_control_connected(connection);
 	if (ret)
-		goto err_disconnect;
+		goto err_control_disconnecting;
 
 	return 0;
 
-err_disconnect:
+err_control_disconnecting:
+	gb_connection_control_disconnecting(connection);
+
 	spin_lock_irq(&connection->lock);
-	connection->state = GB_CONNECTION_STATE_ERROR;
+	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_ping(connection);
+	gb_connection_hd_cport_features_disable(connection);
+	gb_connection_svc_connection_quiescing(connection);
+	gb_connection_ping(connection);
 	gb_connection_control_disconnected(connection);
-err_svc_destroy:
+	connection->state = GB_CONNECTION_STATE_DISABLED;
+err_svc_connection_destroy:
 	gb_connection_svc_connection_destroy(connection);
 err_hd_cport_disable:
 	gb_connection_hd_cport_disable(connection);
@@ -435,55 +699,160 @@ err_hd_cport_disable:
 	return ret;
 }
 
-static void gb_connection_exit(struct gb_connection *connection)
+int gb_connection_enable(struct gb_connection *connection)
 {
-	if (!connection->protocol)
-		return;
+	int ret = 0;
+
+	mutex_lock(&connection->mutex);
+
+	if (connection->state == GB_CONNECTION_STATE_ENABLED)
+		goto out_unlock;
+
+	ret = _gb_connection_enable(connection, true);
+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);
+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);
-		return;
+		goto out_unlock;
 	}
-	connection->state = GB_CONNECTION_STATE_DESTROYING;
+	connection->state = GB_CONNECTION_STATE_ENABLED_TX;
+	gb_connection_flush_incoming_operations(connection, -ESHUTDOWN);
 	spin_unlock_irq(&connection->lock);
 
+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_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;
+
+	gb_connection_control_disconnecting(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_ping(connection);
+	gb_connection_hd_cport_features_disable(connection);
+	gb_connection_svc_connection_quiescing(connection);
+	gb_connection_ping(connection);
 
-	connection->protocol->connection_exit(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_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;
+
+	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_hd_cport_features_disable(connection);
 	gb_connection_svc_connection_destroy(connection);
 	gb_connection_hd_cport_disable(connection);
+
+out_unlock:
+	mutex_unlock(&connection->mutex);
 }
+EXPORT_SYMBOL_GPL(gb_connection_disable_forced);
 
-/*
- * Tear down a previously set up connection.
- */
+/* Caller must have disabled the connection before destroying it. */
 void gb_connection_destroy(struct gb_connection *connection)
 {
-	struct ida *id_map;
-
-	if (WARN_ON(!connection))
+	if (!connection)
 		return;
 
-	gb_connection_exit(connection);
+	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);
 
-	if (connection->protocol)
-		gb_protocol_put(connection->protocol);
-	connection->protocol = NULL;
+	destroy_workqueue(connection->wq);
 
-	id_map = &connection->hd->cport_id_map;
-	ida_simple_remove(id_map, connection->hd_cport_id);
+	gb_hd_cport_release(connection->hd, connection->hd_cport_id);
 	connection->hd_cport_id = CPORT_ID_BAD;
 
-	kref_put_mutex(&connection->kref, gb_connection_kref_release,
-		       &connection_mutex);
+	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)
 {
@@ -495,8 +864,9 @@ void gb_connection_latency_tag_enable(struct gb_connection *connection)
 
 	ret = hd->driver->latency_tag_enable(hd, connection->hd_cport_id);
 	if (ret) {
-		dev_err(&connection->bundle->dev,
-			"failed to enable latency tag: %d\n", 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);
@@ -511,47 +881,9 @@ void gb_connection_latency_tag_disable(struct gb_connection *connection)
 
 	ret = hd->driver->latency_tag_disable(hd, connection->hd_cport_id);
 	if (ret) {
-		dev_err(&connection->bundle->dev,
-			"failed to disable latency tag: %d\n", 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);
-
-int gb_connection_bind_protocol(struct gb_connection *connection)
-{
-	struct gb_protocol *protocol;
-	int ret;
-
-	/* If we already have a protocol bound here, just return */
-	if (connection->protocol)
-		return 0;
-
-	protocol = gb_protocol_get(connection->protocol_id,
-				   connection->major,
-				   connection->minor);
-	if (!protocol) {
-		dev_warn(&connection->hd->dev,
-				"protocol 0x%02hhx version %hhu.%hhu not found\n",
-				connection->protocol_id,
-				connection->major, connection->minor);
-		return 0;
-	}
-	connection->protocol = protocol;
-
-	/*
-	 * If we have a valid device_id for the interface block, then we have an
-	 * active device, so bring up the connection at the same time.
-	 */
-	if ((!connection->bundle &&
-	     protocol->flags & GB_PROTOCOL_NO_BUNDLE) ||
-	    connection->bundle->intf->device_id != GB_DEVICE_ID_BAD) {
-		ret = gb_connection_init(connection);
-		if (ret) {
-			gb_protocol_put(protocol);
-			connection->protocol = NULL;
-			return ret;
-		}
-	}
-
-	return 0;
-}