projects/linux·blob master · refs

939 lines · 22.6 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Greybus connections
4 *
5 * Copyright 2014 Google Inc.
6 * Copyright 2014 Linaro Ltd.
7 */
8
9#include <linux/workqueue.h>
10#include <linux/greybus.h>
11
12#include "greybus_trace.h"
13
14#define GB_CONNECTION_CPORT_QUIESCE_TIMEOUT 1000
15
16static void gb_connection_kref_release(struct kref *kref);
17
18static DEFINE_SPINLOCK(gb_connections_lock);
19static DEFINE_MUTEX(gb_connection_mutex);
20
21/* Caller holds gb_connection_mutex. */
22static bool gb_connection_cport_in_use(struct gb_interface *intf, u16 cport_id)
23{
24 struct gb_host_device *hd = intf->hd;
25 struct gb_connection *connection;
26
27 list_for_each_entry(connection, &hd->connections, hd_links) {
28 if (connection->intf == intf &&
29 connection->intf_cport_id == cport_id)
30 return true;
31 }
32
33 return false;
34}
35
36static void gb_connection_get(struct gb_connection *connection)
37{
38 kref_get(&connection->kref);
39
40 trace_gb_connection_get(connection);
41}
42
43static void gb_connection_put(struct gb_connection *connection)
44{
45 trace_gb_connection_put(connection);
46
47 kref_put(&connection->kref, gb_connection_kref_release);
48}
49
50/*
51 * Returns a reference-counted pointer to the connection if found.
52 */
53static struct gb_connection *
54gb_connection_hd_find(struct gb_host_device *hd, u16 cport_id)
55{
56 struct gb_connection *connection;
57 unsigned long flags;
58
59 spin_lock_irqsave(&gb_connections_lock, flags);
60 list_for_each_entry(connection, &hd->connections, hd_links)
61 if (connection->hd_cport_id == cport_id) {
62 gb_connection_get(connection);
63 goto found;
64 }
65 connection = NULL;
66found:
67 spin_unlock_irqrestore(&gb_connections_lock, flags);
68
69 return connection;
70}
71
72/*
73 * Callback from the host driver to let us know that data has been
74 * received on the bundle.
75 */
76void greybus_data_rcvd(struct gb_host_device *hd, u16 cport_id,
77 u8 *data, size_t length)
78{
79 struct gb_connection *connection;
80
81 trace_gb_hd_in(hd);
82
83 connection = gb_connection_hd_find(hd, cport_id);
84 if (!connection) {
85 dev_err(&hd->dev,
86 "nonexistent connection (%zu bytes dropped)\n", length);
87 return;
88 }
89 gb_connection_recv(connection, data, length);
90 gb_connection_put(connection);
91}
92EXPORT_SYMBOL_GPL(greybus_data_rcvd);
93
94static void gb_connection_kref_release(struct kref *kref)
95{
96 struct gb_connection *connection;
97
98 connection = container_of(kref, struct gb_connection, kref);
99
100 trace_gb_connection_release(connection);
101
102 kfree(connection);
103}
104
105static void gb_connection_init_name(struct gb_connection *connection)
106{
107 u16 hd_cport_id = connection->hd_cport_id;
108 u16 cport_id = 0;
109 u8 intf_id = 0;
110
111 if (connection->intf) {
112 intf_id = connection->intf->interface_id;
113 cport_id = connection->intf_cport_id;
114 }
115
116 snprintf(connection->name, sizeof(connection->name),
117 "%u/%u:%u", hd_cport_id, intf_id, cport_id);
118}
119
120/*
121 * _gb_connection_create() - create a Greybus connection
122 * @hd: host device of the connection
123 * @hd_cport_id: host-device cport id, or -1 for dynamic allocation
124 * @intf: remote interface, or NULL for static connections
125 * @bundle: remote-interface bundle (may be NULL)
126 * @cport_id: remote-interface cport id, or 0 for static connections
127 * @handler: request handler (may be NULL)
128 * @flags: connection flags
129 *
130 * Create a Greybus connection, representing the bidirectional link
131 * between a CPort on a (local) Greybus host device and a CPort on
132 * another Greybus interface.
133 *
134 * A connection also maintains the state of operations sent over the
135 * connection.
136 *
137 * Serialised against concurrent create and destroy using the
138 * gb_connection_mutex.
139 *
140 * Return: A pointer to the new connection if successful, or an ERR_PTR
141 * otherwise.
142 */
143static struct gb_connection *
144_gb_connection_create(struct gb_host_device *hd, int hd_cport_id,
145 struct gb_interface *intf,
146 struct gb_bundle *bundle, int cport_id,
147 gb_request_handler_t handler,
148 unsigned long flags)
149{
150 struct gb_connection *connection;
151 int ret;
152
153 mutex_lock(&gb_connection_mutex);
154
155 if (intf && gb_connection_cport_in_use(intf, cport_id)) {
156 dev_err(&intf->dev, "cport %u already in use\n", cport_id);
157 ret = -EBUSY;
158 goto err_unlock;
159 }
160
161 ret = gb_hd_cport_allocate(hd, hd_cport_id, flags);
162 if (ret < 0) {
163 dev_err(&hd->dev, "failed to allocate cport: %d\n", ret);
164 goto err_unlock;
165 }
166 hd_cport_id = ret;
167
168 connection = kzalloc_obj(*connection);
169 if (!connection) {
170 ret = -ENOMEM;
171 goto err_hd_cport_release;
172 }
173
174 connection->hd_cport_id = hd_cport_id;
175 connection->intf_cport_id = cport_id;
176 connection->hd = hd;
177 connection->intf = intf;
178 connection->bundle = bundle;
179 connection->handler = handler;
180 connection->flags = flags;
181 if (intf && (intf->quirks & GB_INTERFACE_QUIRK_NO_CPORT_FEATURES))
182 connection->flags |= GB_CONNECTION_FLAG_NO_FLOWCTRL;
183 connection->state = GB_CONNECTION_STATE_DISABLED;
184
185 atomic_set(&connection->op_cycle, 0);
186 mutex_init(&connection->mutex);
187 spin_lock_init(&connection->lock);
188 INIT_LIST_HEAD(&connection->operations);
189
190 connection->wq = alloc_ordered_workqueue("%s:%d", 0, dev_name(&hd->dev),
191 hd_cport_id);
192 if (!connection->wq) {
193 ret = -ENOMEM;
194 goto err_free_connection;
195 }
196
197 kref_init(&connection->kref);
198
199 gb_connection_init_name(connection);
200
201 spin_lock_irq(&gb_connections_lock);
202 list_add(&connection->hd_links, &hd->connections);
203
204 if (bundle)
205 list_add(&connection->bundle_links, &bundle->connections);
206 else
207 INIT_LIST_HEAD(&connection->bundle_links);
208
209 spin_unlock_irq(&gb_connections_lock);
210
211 mutex_unlock(&gb_connection_mutex);
212
213 trace_gb_connection_create(connection);
214
215 return connection;
216
217err_free_connection:
218 kfree(connection);
219err_hd_cport_release:
220 gb_hd_cport_release(hd, hd_cport_id);
221err_unlock:
222 mutex_unlock(&gb_connection_mutex);
223
224 return ERR_PTR(ret);
225}
226
227struct gb_connection *
228gb_connection_create_static(struct gb_host_device *hd, u16 hd_cport_id,
229 gb_request_handler_t handler)
230{
231 return _gb_connection_create(hd, hd_cport_id, NULL, NULL, 0, handler,
232 GB_CONNECTION_FLAG_HIGH_PRIO);
233}
234
235struct gb_connection *
236gb_connection_create_control(struct gb_interface *intf)
237{
238 return _gb_connection_create(intf->hd, -1, intf, NULL, 0, NULL,
239 GB_CONNECTION_FLAG_CONTROL |
240 GB_CONNECTION_FLAG_HIGH_PRIO);
241}
242
243struct gb_connection *
244gb_connection_create(struct gb_bundle *bundle, u16 cport_id,
245 gb_request_handler_t handler)
246{
247 struct gb_interface *intf = bundle->intf;
248
249 return _gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
250 handler, 0);
251}
252EXPORT_SYMBOL_GPL(gb_connection_create);
253
254struct gb_connection *
255gb_connection_create_flags(struct gb_bundle *bundle, u16 cport_id,
256 gb_request_handler_t handler,
257 unsigned long flags)
258{
259 struct gb_interface *intf = bundle->intf;
260
261 if (WARN_ON_ONCE(flags & GB_CONNECTION_FLAG_CORE_MASK))
262 flags &= ~GB_CONNECTION_FLAG_CORE_MASK;
263
264 return _gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
265 handler, flags);
266}
267EXPORT_SYMBOL_GPL(gb_connection_create_flags);
268
269struct gb_connection *
270gb_connection_create_offloaded(struct gb_bundle *bundle, u16 cport_id,
271 unsigned long flags)
272{
273 flags |= GB_CONNECTION_FLAG_OFFLOADED;
274
275 return gb_connection_create_flags(bundle, cport_id, NULL, flags);
276}
277EXPORT_SYMBOL_GPL(gb_connection_create_offloaded);
278
279static int gb_connection_hd_cport_enable(struct gb_connection *connection)
280{
281 struct gb_host_device *hd = connection->hd;
282 int ret;
283
284 if (!hd->driver->cport_enable)
285 return 0;
286
287 ret = hd->driver->cport_enable(hd, connection->hd_cport_id,
288 connection->flags);
289 if (ret) {
290 dev_err(&hd->dev, "%s: failed to enable host cport: %d\n",
291 connection->name, ret);
292 return ret;
293 }
294
295 return 0;
296}
297
298static void gb_connection_hd_cport_disable(struct gb_connection *connection)
299{
300 struct gb_host_device *hd = connection->hd;
301 int ret;
302
303 if (!hd->driver->cport_disable)
304 return;
305
306 ret = hd->driver->cport_disable(hd, connection->hd_cport_id);
307 if (ret) {
308 dev_err(&hd->dev, "%s: failed to disable host cport: %d\n",
309 connection->name, ret);
310 }
311}
312
313static int gb_connection_hd_cport_connected(struct gb_connection *connection)
314{
315 struct gb_host_device *hd = connection->hd;
316 int ret;
317
318 if (!hd->driver->cport_connected)
319 return 0;
320
321 ret = hd->driver->cport_connected(hd, connection->hd_cport_id);
322 if (ret) {
323 dev_err(&hd->dev, "%s: failed to set connected state: %d\n",
324 connection->name, ret);
325 return ret;
326 }
327
328 return 0;
329}
330
331static int gb_connection_hd_cport_flush(struct gb_connection *connection)
332{
333 struct gb_host_device *hd = connection->hd;
334 int ret;
335
336 if (!hd->driver->cport_flush)
337 return 0;
338
339 ret = hd->driver->cport_flush(hd, connection->hd_cport_id);
340 if (ret) {
341 dev_err(&hd->dev, "%s: failed to flush host cport: %d\n",
342 connection->name, ret);
343 return ret;
344 }
345
346 return 0;
347}
348
349static int gb_connection_hd_cport_quiesce(struct gb_connection *connection)
350{
351 struct gb_host_device *hd = connection->hd;
352 size_t peer_space;
353 int ret;
354
355 if (!hd->driver->cport_quiesce)
356 return 0;
357
358 peer_space = sizeof(struct gb_operation_msg_hdr) +
359 sizeof(struct gb_cport_shutdown_request);
360
361 if (connection->mode_switch)
362 peer_space += sizeof(struct gb_operation_msg_hdr);
363
364 ret = hd->driver->cport_quiesce(hd, connection->hd_cport_id,
365 peer_space,
366 GB_CONNECTION_CPORT_QUIESCE_TIMEOUT);
367 if (ret) {
368 dev_err(&hd->dev, "%s: failed to quiesce host cport: %d\n",
369 connection->name, ret);
370 return ret;
371 }
372
373 return 0;
374}
375
376static int gb_connection_hd_cport_clear(struct gb_connection *connection)
377{
378 struct gb_host_device *hd = connection->hd;
379 int ret;
380
381 if (!hd->driver->cport_clear)
382 return 0;
383
384 ret = hd->driver->cport_clear(hd, connection->hd_cport_id);
385 if (ret) {
386 dev_err(&hd->dev, "%s: failed to clear host cport: %d\n",
387 connection->name, ret);
388 return ret;
389 }
390
391 return 0;
392}
393
394/*
395 * Request the SVC to create a connection from AP's cport to interface's
396 * cport.
397 */
398static int
399gb_connection_svc_connection_create(struct gb_connection *connection)
400{
401 struct gb_host_device *hd = connection->hd;
402 struct gb_interface *intf;
403 u8 cport_flags;
404 int ret;
405
406 if (gb_connection_is_static(connection))
407 return 0;
408
409 intf = connection->intf;
410
411 /*
412 * Enable either E2EFC or CSD, unless no flow control is requested.
413 */
414 cport_flags = GB_SVC_CPORT_FLAG_CSV_N;
415 if (gb_connection_flow_control_disabled(connection)) {
416 cport_flags |= GB_SVC_CPORT_FLAG_CSD_N;
417 } else if (gb_connection_e2efc_enabled(connection)) {
418 cport_flags |= GB_SVC_CPORT_FLAG_CSD_N |
419 GB_SVC_CPORT_FLAG_E2EFC;
420 }
421
422 ret = gb_svc_connection_create(hd->svc,
423 hd->svc->ap_intf_id,
424 connection->hd_cport_id,
425 intf->interface_id,
426 connection->intf_cport_id,
427 cport_flags);
428 if (ret) {
429 dev_err(&connection->hd->dev,
430 "%s: failed to create svc connection: %d\n",
431 connection->name, ret);
432 return ret;
433 }
434
435 return 0;
436}
437
438static void
439gb_connection_svc_connection_destroy(struct gb_connection *connection)
440{
441 if (gb_connection_is_static(connection))
442 return;
443
444 gb_svc_connection_destroy(connection->hd->svc,
445 connection->hd->svc->ap_intf_id,
446 connection->hd_cport_id,
447 connection->intf->interface_id,
448 connection->intf_cport_id);
449}
450
451/* Inform Interface about active CPorts */
452static int gb_connection_control_connected(struct gb_connection *connection)
453{
454 struct gb_control *control;
455 u16 cport_id = connection->intf_cport_id;
456 int ret;
457
458 if (gb_connection_is_static(connection))
459 return 0;
460
461 if (gb_connection_is_control(connection))
462 return 0;
463
464 control = connection->intf->control;
465
466 ret = gb_control_connected_operation(control, cport_id);
467 if (ret) {
468 dev_err(&connection->bundle->dev,
469 "failed to connect cport: %d\n", ret);
470 return ret;
471 }
472
473 return 0;
474}
475
476static void
477gb_connection_control_disconnecting(struct gb_connection *connection)
478{
479 struct gb_control *control;
480 u16 cport_id = connection->intf_cport_id;
481 int ret;
482
483 if (gb_connection_is_static(connection))
484 return;
485
486 control = connection->intf->control;
487
488 ret = gb_control_disconnecting_operation(control, cport_id);
489 if (ret) {
490 dev_err(&connection->hd->dev,
491 "%s: failed to send disconnecting: %d\n",
492 connection->name, ret);
493 }
494}
495
496static void
497gb_connection_control_disconnected(struct gb_connection *connection)
498{
499 struct gb_control *control;
500 u16 cport_id = connection->intf_cport_id;
501 int ret;
502
503 if (gb_connection_is_static(connection))
504 return;
505
506 control = connection->intf->control;
507
508 if (gb_connection_is_control(connection)) {
509 if (connection->mode_switch) {
510 ret = gb_control_mode_switch_operation(control);
511 if (ret) {
512 /*
513 * Allow mode switch to time out waiting for
514 * mailbox event.
515 */
516 return;
517 }
518 }
519
520 return;
521 }
522
523 ret = gb_control_disconnected_operation(control, cport_id);
524 if (ret) {
525 dev_warn(&connection->bundle->dev,
526 "failed to disconnect cport: %d\n", ret);
527 }
528}
529
530static int gb_connection_shutdown_operation(struct gb_connection *connection,
531 u8 phase)
532{
533 struct gb_cport_shutdown_request *req;
534 struct gb_operation *operation;
535 int ret;
536
537 operation = gb_operation_create_core(connection,
538 GB_REQUEST_TYPE_CPORT_SHUTDOWN,
539 sizeof(*req), 0, 0,
540 GFP_KERNEL);
541 if (!operation)
542 return -ENOMEM;
543
544 req = operation->request->payload;
545 req->phase = phase;
546
547 ret = gb_operation_request_send_sync(operation);
548
549 gb_operation_put(operation);
550
551 return ret;
552}
553
554static int gb_connection_cport_shutdown(struct gb_connection *connection,
555 u8 phase)
556{
557 struct gb_host_device *hd = connection->hd;
558 const struct gb_hd_driver *drv = hd->driver;
559 int ret;
560
561 if (gb_connection_is_static(connection))
562 return 0;
563
564 if (gb_connection_is_offloaded(connection)) {
565 if (!drv->cport_shutdown)
566 return 0;
567
568 ret = drv->cport_shutdown(hd, connection->hd_cport_id, phase,
569 GB_OPERATION_TIMEOUT_DEFAULT);
570 } else {
571 ret = gb_connection_shutdown_operation(connection, phase);
572 }
573
574 if (ret) {
575 dev_err(&hd->dev, "%s: failed to send cport shutdown (phase %d): %d\n",
576 connection->name, phase, ret);
577 return ret;
578 }
579
580 return 0;
581}
582
583static int
584gb_connection_cport_shutdown_phase_1(struct gb_connection *connection)
585{
586 return gb_connection_cport_shutdown(connection, 1);
587}
588
589static int
590gb_connection_cport_shutdown_phase_2(struct gb_connection *connection)
591{
592 return gb_connection_cport_shutdown(connection, 2);
593}
594
595/*
596 * Cancel all active operations on a connection.
597 *
598 * Locking: Called with connection lock held and state set to DISABLED or
599 * DISCONNECTING.
600 */
601static void gb_connection_cancel_operations(struct gb_connection *connection,
602 int errno)
603 __must_hold(&connection->lock)
604{
605 struct gb_operation *operation;
606
607 while (!list_empty(&connection->operations)) {
608 operation = list_last_entry(&connection->operations,
609 struct gb_operation, links);
610 gb_operation_get(operation);
611 spin_unlock_irq(&connection->lock);
612
613 if (gb_operation_is_incoming(operation))
614 gb_operation_cancel_incoming(operation, errno);
615 else
616 gb_operation_cancel(operation, errno);
617
618 gb_operation_put(operation);
619
620 spin_lock_irq(&connection->lock);
621 }
622}
623
624/*
625 * Cancel all active incoming operations on a connection.
626 *
627 * Locking: Called with connection lock held and state set to ENABLED_TX.
628 */
629static void
630gb_connection_flush_incoming_operations(struct gb_connection *connection,
631 int errno)
632 __must_hold(&connection->lock)
633{
634 struct gb_operation *operation;
635 bool incoming;
636
637 while (!list_empty(&connection->operations)) {
638 incoming = false;
639 list_for_each_entry(operation, &connection->operations,
640 links) {
641 if (gb_operation_is_incoming(operation)) {
642 gb_operation_get(operation);
643 incoming = true;
644 break;
645 }
646 }
647
648 if (!incoming)
649 break;
650
651 spin_unlock_irq(&connection->lock);
652
653 /* FIXME: flush, not cancel? */
654 gb_operation_cancel_incoming(operation, errno);
655 gb_operation_put(operation);
656
657 spin_lock_irq(&connection->lock);
658 }
659}
660
661/*
662 * _gb_connection_enable() - enable a connection
663 * @connection: connection to enable
664 * @rx: whether to enable incoming requests
665 *
666 * Connection-enable helper for DISABLED->ENABLED, DISABLED->ENABLED_TX, and
667 * ENABLED_TX->ENABLED state transitions.
668 *
669 * Locking: Caller holds connection->mutex.
670 */
671static int _gb_connection_enable(struct gb_connection *connection, bool rx)
672{
673 int ret;
674
675 /* Handle ENABLED_TX -> ENABLED transitions. */
676 if (connection->state == GB_CONNECTION_STATE_ENABLED_TX) {
677 if (!(connection->handler && rx))
678 return 0;
679
680 spin_lock_irq(&connection->lock);
681 connection->state = GB_CONNECTION_STATE_ENABLED;
682 spin_unlock_irq(&connection->lock);
683
684 return 0;
685 }
686
687 ret = gb_connection_hd_cport_enable(connection);
688 if (ret)
689 return ret;
690
691 ret = gb_connection_svc_connection_create(connection);
692 if (ret)
693 goto err_hd_cport_clear;
694
695 ret = gb_connection_hd_cport_connected(connection);
696 if (ret)
697 goto err_svc_connection_destroy;
698
699 spin_lock_irq(&connection->lock);
700 if (connection->handler && rx)
701 connection->state = GB_CONNECTION_STATE_ENABLED;
702 else
703 connection->state = GB_CONNECTION_STATE_ENABLED_TX;
704 spin_unlock_irq(&connection->lock);
705
706 ret = gb_connection_control_connected(connection);
707 if (ret)
708 goto err_control_disconnecting;
709
710 return 0;
711
712err_control_disconnecting:
713 spin_lock_irq(&connection->lock);
714 connection->state = GB_CONNECTION_STATE_DISCONNECTING;
715 gb_connection_cancel_operations(connection, -ESHUTDOWN);
716 spin_unlock_irq(&connection->lock);
717
718 /* Transmit queue should already be empty. */
719 gb_connection_hd_cport_flush(connection);
720
721 gb_connection_control_disconnecting(connection);
722 gb_connection_cport_shutdown_phase_1(connection);
723 gb_connection_hd_cport_quiesce(connection);
724 gb_connection_cport_shutdown_phase_2(connection);
725 gb_connection_control_disconnected(connection);
726 connection->state = GB_CONNECTION_STATE_DISABLED;
727err_svc_connection_destroy:
728 gb_connection_svc_connection_destroy(connection);
729err_hd_cport_clear:
730 gb_connection_hd_cport_clear(connection);
731
732 gb_connection_hd_cport_disable(connection);
733
734 return ret;
735}
736
737int gb_connection_enable(struct gb_connection *connection)
738{
739 int ret = 0;
740
741 mutex_lock(&connection->mutex);
742
743 if (connection->state == GB_CONNECTION_STATE_ENABLED)
744 goto out_unlock;
745
746 ret = _gb_connection_enable(connection, true);
747 if (!ret)
748 trace_gb_connection_enable(connection);
749
750out_unlock:
751 mutex_unlock(&connection->mutex);
752
753 return ret;
754}
755EXPORT_SYMBOL_GPL(gb_connection_enable);
756
757int gb_connection_enable_tx(struct gb_connection *connection)
758{
759 int ret = 0;
760
761 mutex_lock(&connection->mutex);
762
763 if (connection->state == GB_CONNECTION_STATE_ENABLED) {
764 ret = -EINVAL;
765 goto out_unlock;
766 }
767
768 if (connection->state == GB_CONNECTION_STATE_ENABLED_TX)
769 goto out_unlock;
770
771 ret = _gb_connection_enable(connection, false);
772 if (!ret)
773 trace_gb_connection_enable(connection);
774
775out_unlock:
776 mutex_unlock(&connection->mutex);
777
778 return ret;
779}
780EXPORT_SYMBOL_GPL(gb_connection_enable_tx);
781
782void gb_connection_disable_rx(struct gb_connection *connection)
783{
784 mutex_lock(&connection->mutex);
785
786 spin_lock_irq(&connection->lock);
787 if (connection->state != GB_CONNECTION_STATE_ENABLED) {
788 spin_unlock_irq(&connection->lock);
789 goto out_unlock;
790 }
791 connection->state = GB_CONNECTION_STATE_ENABLED_TX;
792 gb_connection_flush_incoming_operations(connection, -ESHUTDOWN);
793 spin_unlock_irq(&connection->lock);
794
795 trace_gb_connection_disable(connection);
796
797out_unlock:
798 mutex_unlock(&connection->mutex);
799}
800EXPORT_SYMBOL_GPL(gb_connection_disable_rx);
801
802void gb_connection_mode_switch_prepare(struct gb_connection *connection)
803{
804 connection->mode_switch = true;
805}
806
807void gb_connection_mode_switch_complete(struct gb_connection *connection)
808{
809 gb_connection_svc_connection_destroy(connection);
810 gb_connection_hd_cport_clear(connection);
811
812 gb_connection_hd_cport_disable(connection);
813
814 connection->mode_switch = false;
815}
816
817void gb_connection_disable(struct gb_connection *connection)
818{
819 mutex_lock(&connection->mutex);
820
821 if (connection->state == GB_CONNECTION_STATE_DISABLED)
822 goto out_unlock;
823
824 trace_gb_connection_disable(connection);
825
826 spin_lock_irq(&connection->lock);
827 connection->state = GB_CONNECTION_STATE_DISCONNECTING;
828 gb_connection_cancel_operations(connection, -ESHUTDOWN);
829 spin_unlock_irq(&connection->lock);
830
831 gb_connection_hd_cport_flush(connection);
832
833 gb_connection_control_disconnecting(connection);
834 gb_connection_cport_shutdown_phase_1(connection);
835 gb_connection_hd_cport_quiesce(connection);
836 gb_connection_cport_shutdown_phase_2(connection);
837 gb_connection_control_disconnected(connection);
838
839 connection->state = GB_CONNECTION_STATE_DISABLED;
840
841 /* control-connection tear down is deferred when mode switching */
842 if (!connection->mode_switch) {
843 gb_connection_svc_connection_destroy(connection);
844 gb_connection_hd_cport_clear(connection);
845
846 gb_connection_hd_cport_disable(connection);
847 }
848
849out_unlock:
850 mutex_unlock(&connection->mutex);
851}
852EXPORT_SYMBOL_GPL(gb_connection_disable);
853
854/* Disable a connection without communicating with the remote end. */
855void gb_connection_disable_forced(struct gb_connection *connection)
856{
857 mutex_lock(&connection->mutex);
858
859 if (connection->state == GB_CONNECTION_STATE_DISABLED)
860 goto out_unlock;
861
862 trace_gb_connection_disable(connection);
863
864 spin_lock_irq(&connection->lock);
865 connection->state = GB_CONNECTION_STATE_DISABLED;
866 gb_connection_cancel_operations(connection, -ESHUTDOWN);
867 spin_unlock_irq(&connection->lock);
868
869 gb_connection_hd_cport_flush(connection);
870
871 gb_connection_svc_connection_destroy(connection);
872 gb_connection_hd_cport_clear(connection);
873
874 gb_connection_hd_cport_disable(connection);
875out_unlock:
876 mutex_unlock(&connection->mutex);
877}
878EXPORT_SYMBOL_GPL(gb_connection_disable_forced);
879
880/* Caller must have disabled the connection before destroying it. */
881void gb_connection_destroy(struct gb_connection *connection)
882{
883 if (!connection)
884 return;
885
886 if (WARN_ON(connection->state != GB_CONNECTION_STATE_DISABLED))
887 gb_connection_disable(connection);
888
889 mutex_lock(&gb_connection_mutex);
890
891 spin_lock_irq(&gb_connections_lock);
892 list_del(&connection->bundle_links);
893 list_del(&connection->hd_links);
894 spin_unlock_irq(&gb_connections_lock);
895
896 destroy_workqueue(connection->wq);
897
898 gb_hd_cport_release(connection->hd, connection->hd_cport_id);
899 connection->hd_cport_id = CPORT_ID_BAD;
900
901 mutex_unlock(&gb_connection_mutex);
902
903 gb_connection_put(connection);
904}
905EXPORT_SYMBOL_GPL(gb_connection_destroy);
906
907void gb_connection_latency_tag_enable(struct gb_connection *connection)
908{
909 struct gb_host_device *hd = connection->hd;
910 int ret;
911
912 if (!hd->driver->latency_tag_enable)
913 return;
914
915 ret = hd->driver->latency_tag_enable(hd, connection->hd_cport_id);
916 if (ret) {
917 dev_err(&connection->hd->dev,
918 "%s: failed to enable latency tag: %d\n",
919 connection->name, ret);
920 }
921}
922EXPORT_SYMBOL_GPL(gb_connection_latency_tag_enable);
923
924void gb_connection_latency_tag_disable(struct gb_connection *connection)
925{
926 struct gb_host_device *hd = connection->hd;
927 int ret;
928
929 if (!hd->driver->latency_tag_disable)
930 return;
931
932 ret = hd->driver->latency_tag_disable(hd, connection->hd_cport_id);
933 if (ret) {
934 dev_err(&connection->hd->dev,
935 "%s: failed to disable latency tag: %d\n",
936 connection->name, ret);
937 }
938}
939EXPORT_SYMBOL_GPL(gb_connection_latency_tag_disable);