drivers/staging/greybus/connection.c

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