drivers/staging/greybus/connection.c

   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
  11 #include "greybus.h"
  12 #include "greybus_trace.h"
  13
  14 #define GB_CONNECTION_CPORT_QUIESCE_TIMEOUT     1000
  15
  16 static void gb_connection_kref_release(struct kref *kref);
  17
  18 static DEFINE_SPINLOCK(gb_connections_lock);
  19 static DEFINE_MUTEX(gb_connection_mutex);
  20
  21 /* Caller holds gb_connection_mutex. */
  22 static 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
  36 static void gb_connection_get(struct gb_connection *connection)
  37 {
  38         kref_get(&connection->kref);
  39
  40         trace_gb_connection_get(connection);
  41 }
  42
  43 static 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  */
  53 static struct gb_connection *
  54 gb_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;
  66 found:
  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  */
  76 void 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 }
  92 EXPORT_SYMBOL_GPL(greybus_data_rcvd);
  93
  94 static 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
 105 static 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  */
 143 static 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(sizeof(*connection), GFP_KERNEL);
 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_workqueue("%s:%d", WQ_UNBOUND, 1,
 191                                          dev_name(&hd->dev), 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
 217 err_free_connection:
 218         kfree(connection);
 219 err_hd_cport_release:
 220         gb_hd_cport_release(hd, hd_cport_id);
 221 err_unlock:
 222         mutex_unlock(&gb_connection_mutex);
 223
 224         return ERR_PTR(ret);
 225 }
 226
 227 struct gb_connection *
 228 gb_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
 235 struct gb_connection *
 236 gb_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
 243 struct gb_connection *
 244 gb_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 }
 252 EXPORT_SYMBOL_GPL(gb_connection_create);
 253
 254 struct gb_connection *
 255 gb_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 }
 267 EXPORT_SYMBOL_GPL(gb_connection_create_flags);
 268
 269 struct gb_connection *
 270 gb_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 }
 277 EXPORT_SYMBOL_GPL(gb_connection_create_offloaded);
 278
 279 static 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
 298 static 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
 313 static 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
 331 static 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
 349 static 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         if (!hd->driver->cport_quiesce)
 365                 return 0;
 366
 367         ret = hd->driver->cport_quiesce(hd, connection->hd_cport_id,
 368                                         peer_space,
 369                                         GB_CONNECTION_CPORT_QUIESCE_TIMEOUT);
 370         if (ret) {
 371                 dev_err(&hd->dev, "%s: failed to quiesce host cport: %d\n",
 372                         connection->name, ret);
 373                 return ret;
 374         }
 375
 376         return 0;
 377 }
 378
 379 static int gb_connection_hd_cport_clear(struct gb_connection *connection)
 380 {
 381         struct gb_host_device *hd = connection->hd;
 382         int ret;
 383
 384         if (!hd->driver->cport_clear)
 385                 return 0;
 386
 387         ret = hd->driver->cport_clear(hd, connection->hd_cport_id);
 388         if (ret) {
 389                 dev_err(&hd->dev, "%s: failed to clear host cport: %d\n",
 390                         connection->name, ret);
 391                 return ret;
 392         }
 393
 394         return 0;
 395 }
 396
 397 /*
 398  * Request the SVC to create a connection from AP's cport to interface's
 399  * cport.
 400  */
 401 static int
 402 gb_connection_svc_connection_create(struct gb_connection *connection)
 403 {
 404         struct gb_host_device *hd = connection->hd;
 405         struct gb_interface *intf;
 406         u8 cport_flags;
 407         int ret;
 408
 409         if (gb_connection_is_static(connection))
 410                 return 0;
 411
 412         intf = connection->intf;
 413
 414         /*
 415          * Enable either E2EFC or CSD, unless no flow control is requested.
 416          */
 417         cport_flags = GB_SVC_CPORT_FLAG_CSV_N;
 418         if (gb_connection_flow_control_disabled(connection)) {
 419                 cport_flags |= GB_SVC_CPORT_FLAG_CSD_N;
 420         } else if (gb_connection_e2efc_enabled(connection)) {
 421                 cport_flags |= GB_SVC_CPORT_FLAG_CSD_N |
 422                                 GB_SVC_CPORT_FLAG_E2EFC;
 423         }
 424
 425         ret = gb_svc_connection_create(hd->svc,
 426                                        hd->svc->ap_intf_id,
 427                                        connection->hd_cport_id,
 428                                        intf->interface_id,
 429                                        connection->intf_cport_id,
 430                                        cport_flags);
 431         if (ret) {
 432                 dev_err(&connection->hd->dev,
 433                         "%s: failed to create svc connection: %d\n",
 434                         connection->name, ret);
 435                 return ret;
 436         }
 437
 438         return 0;
 439 }
 440
 441 static void
 442 gb_connection_svc_connection_destroy(struct gb_connection *connection)
 443 {
 444         if (gb_connection_is_static(connection))
 445                 return;
 446
 447         gb_svc_connection_destroy(connection->hd->svc,
 448                                   connection->hd->svc->ap_intf_id,
 449                                   connection->hd_cport_id,
 450                                   connection->intf->interface_id,
 451                                   connection->intf_cport_id);
 452 }
 453
 454 /* Inform Interface about active CPorts */
 455 static int gb_connection_control_connected(struct gb_connection *connection)
 456 {
 457         struct gb_control *control;
 458         u16 cport_id = connection->intf_cport_id;
 459         int ret;
 460
 461         if (gb_connection_is_static(connection))
 462                 return 0;
 463
 464         if (gb_connection_is_control(connection))
 465                 return 0;
 466
 467         control = connection->intf->control;
 468
 469         ret = gb_control_connected_operation(control, cport_id);
 470         if (ret) {
 471                 dev_err(&connection->bundle->dev,
 472                         "failed to connect cport: %d\n", ret);
 473                 return ret;
 474         }
 475
 476         return 0;
 477 }
 478
 479 static void
 480 gb_connection_control_disconnecting(struct gb_connection *connection)
 481 {
 482         struct gb_control *control;
 483         u16 cport_id = connection->intf_cport_id;
 484         int ret;
 485
 486         if (gb_connection_is_static(connection))
 487                 return;
 488
 489         control = connection->intf->control;
 490
 491         ret = gb_control_disconnecting_operation(control, cport_id);
 492         if (ret) {
 493                 dev_err(&connection->hd->dev,
 494                         "%s: failed to send disconnecting: %d\n",
 495                         connection->name, ret);
 496         }
 497 }
 498
 499 static void
 500 gb_connection_control_disconnected(struct gb_connection *connection)
 501 {
 502         struct gb_control *control;
 503         u16 cport_id = connection->intf_cport_id;
 504         int ret;
 505
 506         if (gb_connection_is_static(connection))
 507                 return;
 508
 509         control = connection->intf->control;
 510
 511         if (gb_connection_is_control(connection)) {
 512                 if (connection->mode_switch) {
 513                         ret = gb_control_mode_switch_operation(control);
 514                         if (ret) {
 515                                 /*
 516                                  * Allow mode switch to time out waiting for
 517                                  * mailbox event.
 518                                  */
 519                                 return;
 520                         }
 521                 }
 522
 523                 return;
 524         }
 525
 526         ret = gb_control_disconnected_operation(control, cport_id);
 527         if (ret) {
 528                 dev_warn(&connection->bundle->dev,
 529                          "failed to disconnect cport: %d\n", ret);
 530         }
 531 }
 532
 533 static int gb_connection_shutdown_operation(struct gb_connection *connection,
 534                                             u8 phase)
 535 {
 536         struct gb_cport_shutdown_request *req;
 537         struct gb_operation *operation;
 538         int ret;
 539
 540         operation = gb_operation_create_core(connection,
 541                                              GB_REQUEST_TYPE_CPORT_SHUTDOWN,
 542                                              sizeof(*req), 0, 0,
 543                                              GFP_KERNEL);
 544         if (!operation)
 545                 return -ENOMEM;
 546
 547         req = operation->request->payload;
 548         req->phase = phase;
 549
 550         ret = gb_operation_request_send_sync(operation);
 551
 552         gb_operation_put(operation);
 553
 554         return ret;
 555 }
 556
 557 static int gb_connection_cport_shutdown(struct gb_connection *connection,
 558                                         u8 phase)
 559 {
 560         struct gb_host_device *hd = connection->hd;
 561         const struct gb_hd_driver *drv = hd->driver;
 562         int ret;
 563
 564         if (gb_connection_is_static(connection))
 565                 return 0;
 566
 567         if (gb_connection_is_offloaded(connection)) {
 568                 if (!drv->cport_shutdown)
 569                         return 0;
 570
 571                 ret = drv->cport_shutdown(hd, connection->hd_cport_id, phase,
 572                                           GB_OPERATION_TIMEOUT_DEFAULT);
 573         } else {
 574                 ret = gb_connection_shutdown_operation(connection, phase);
 575         }
 576
 577         if (ret) {
 578                 dev_err(&hd->dev, "%s: failed to send cport shutdown (phase %d): %d\n",
 579                         connection->name, phase, ret);
 580                 return ret;
 581         }
 582
 583         return 0;
 584 }
 585
 586 static int
 587 gb_connection_cport_shutdown_phase_1(struct gb_connection *connection)
 588 {
 589         return gb_connection_cport_shutdown(connection, 1);
 590 }
 591
 592 static int
 593 gb_connection_cport_shutdown_phase_2(struct gb_connection *connection)
 594 {
 595         return gb_connection_cport_shutdown(connection, 2);
 596 }
 597
 598 /*
 599  * Cancel all active operations on a connection.
 600  *
 601  * Locking: Called with connection lock held and state set to DISABLED or
 602  * DISCONNECTING.
 603  */
 604 static void gb_connection_cancel_operations(struct gb_connection *connection,
 605                                             int errno)
 606         __must_hold(&connection->lock)
 607 {
 608         struct gb_operation *operation;
 609
 610         while (!list_empty(&connection->operations)) {
 611                 operation = list_last_entry(&connection->operations,
 612                                             struct gb_operation, links);
 613                 gb_operation_get(operation);
 614                 spin_unlock_irq(&connection->lock);
 615
 616                 if (gb_operation_is_incoming(operation))
 617                         gb_operation_cancel_incoming(operation, errno);
 618                 else
 619                         gb_operation_cancel(operation, errno);
 620
 621                 gb_operation_put(operation);
 622
 623                 spin_lock_irq(&connection->lock);
 624         }
 625 }
 626
 627 /*
 628  * Cancel all active incoming operations on a connection.
 629  *
 630  * Locking: Called with connection lock held and state set to ENABLED_TX.
 631  */
 632 static void
 633 gb_connection_flush_incoming_operations(struct gb_connection *connection,
 634                                         int errno)
 635         __must_hold(&connection->lock)
 636 {
 637         struct gb_operation *operation;
 638         bool incoming;
 639
 640         while (!list_empty(&connection->operations)) {
 641                 incoming = false;
 642                 list_for_each_entry(operation, &connection->operations,
 643                                     links) {
 644                         if (gb_operation_is_incoming(operation)) {
 645                                 gb_operation_get(operation);
 646                                 incoming = true;
 647                                 break;
 648                         }
 649                 }
 650
 651                 if (!incoming)
 652                         break;
 653
 654                 spin_unlock_irq(&connection->lock);
 655
 656                 /* FIXME: flush, not cancel? */
 657                 gb_operation_cancel_incoming(operation, errno);
 658                 gb_operation_put(operation);
 659
 660                 spin_lock_irq(&connection->lock);
 661         }
 662 }
 663
 664 /*
 665  * _gb_connection_enable() - enable a connection
 666  * @connection:         connection to enable
 667  * @rx:                 whether to enable incoming requests
 668  *
 669  * Connection-enable helper for DISABLED->ENABLED, DISABLED->ENABLED_TX, and
 670  * ENABLED_TX->ENABLED state transitions.
 671  *
 672  * Locking: Caller holds connection->mutex.
 673  */
 674 static int _gb_connection_enable(struct gb_connection *connection, bool rx)
 675 {
 676         int ret;
 677
 678         /* Handle ENABLED_TX -> ENABLED transitions. */
 679         if (connection->state == GB_CONNECTION_STATE_ENABLED_TX) {
 680                 if (!(connection->handler && rx))
 681                         return 0;
 682
 683                 spin_lock_irq(&connection->lock);
 684                 connection->state = GB_CONNECTION_STATE_ENABLED;
 685                 spin_unlock_irq(&connection->lock);
 686
 687                 return 0;
 688         }
 689
 690         ret = gb_connection_hd_cport_enable(connection);
 691         if (ret)
 692                 return ret;
 693
 694         ret = gb_connection_svc_connection_create(connection);
 695         if (ret)
 696                 goto err_hd_cport_clear;
 697
 698         ret = gb_connection_hd_cport_connected(connection);
 699         if (ret)
 700                 goto err_svc_connection_destroy;
 701
 702         spin_lock_irq(&connection->lock);
 703         if (connection->handler && rx)
 704                 connection->state = GB_CONNECTION_STATE_ENABLED;
 705         else
 706                 connection->state = GB_CONNECTION_STATE_ENABLED_TX;
 707         spin_unlock_irq(&connection->lock);
 708
 709         ret = gb_connection_control_connected(connection);
 710         if (ret)
 711                 goto err_control_disconnecting;
 712
 713         return 0;
 714
 715 err_control_disconnecting:
 716         spin_lock_irq(&connection->lock);
 717         connection->state = GB_CONNECTION_STATE_DISCONNECTING;
 718         gb_connection_cancel_operations(connection, -ESHUTDOWN);
 719         spin_unlock_irq(&connection->lock);
 720
 721         /* Transmit queue should already be empty. */
 722         gb_connection_hd_cport_flush(connection);
 723
 724         gb_connection_control_disconnecting(connection);
 725         gb_connection_cport_shutdown_phase_1(connection);
 726         gb_connection_hd_cport_quiesce(connection);
 727         gb_connection_cport_shutdown_phase_2(connection);
 728         gb_connection_control_disconnected(connection);
 729         connection->state = GB_CONNECTION_STATE_DISABLED;
 730 err_svc_connection_destroy:
 731         gb_connection_svc_connection_destroy(connection);
 732 err_hd_cport_clear:
 733         gb_connection_hd_cport_clear(connection);
 734
 735         gb_connection_hd_cport_disable(connection);
 736
 737         return ret;
 738 }
 739
 740 int gb_connection_enable(struct gb_connection *connection)
 741 {
 742         int ret = 0;
 743
 744         mutex_lock(&connection->mutex);
 745
 746         if (connection->state == GB_CONNECTION_STATE_ENABLED)
 747                 goto out_unlock;
 748
 749         ret = _gb_connection_enable(connection, true);
 750         if (!ret)
 751                 trace_gb_connection_enable(connection);
 752
 753 out_unlock:
 754         mutex_unlock(&connection->mutex);
 755
 756         return ret;
 757 }
 758 EXPORT_SYMBOL_GPL(gb_connection_enable);
 759
 760 int gb_connection_enable_tx(struct gb_connection *connection)
 761 {
 762         int ret = 0;
 763
 764         mutex_lock(&connection->mutex);
 765
 766         if (connection->state == GB_CONNECTION_STATE_ENABLED) {
 767                 ret = -EINVAL;
 768                 goto out_unlock;
 769         }
 770
 771         if (connection->state == GB_CONNECTION_STATE_ENABLED_TX)
 772                 goto out_unlock;
 773
 774         ret = _gb_connection_enable(connection, false);
 775         if (!ret)
 776                 trace_gb_connection_enable(connection);
 777
 778 out_unlock:
 779         mutex_unlock(&connection->mutex);
 780
 781         return ret;
 782 }
 783 EXPORT_SYMBOL_GPL(gb_connection_enable_tx);
 784
 785 void gb_connection_disable_rx(struct gb_connection *connection)
 786 {
 787         mutex_lock(&connection->mutex);
 788
 789         spin_lock_irq(&connection->lock);
 790         if (connection->state != GB_CONNECTION_STATE_ENABLED) {
 791                 spin_unlock_irq(&connection->lock);
 792                 goto out_unlock;
 793         }
 794         connection->state = GB_CONNECTION_STATE_ENABLED_TX;
 795         gb_connection_flush_incoming_operations(connection, -ESHUTDOWN);
 796         spin_unlock_irq(&connection->lock);
 797
 798         trace_gb_connection_disable(connection);
 799
 800 out_unlock:
 801         mutex_unlock(&connection->mutex);
 802 }
 803 EXPORT_SYMBOL_GPL(gb_connection_disable_rx);
 804
 805 void gb_connection_mode_switch_prepare(struct gb_connection *connection)
 806 {
 807         connection->mode_switch = true;
 808 }
 809
 810 void gb_connection_mode_switch_complete(struct gb_connection *connection)
 811 {
 812         gb_connection_svc_connection_destroy(connection);
 813         gb_connection_hd_cport_clear(connection);
 814
 815         gb_connection_hd_cport_disable(connection);
 816
 817         connection->mode_switch = false;
 818 }
 819
 820 void gb_connection_disable(struct gb_connection *connection)
 821 {
 822         mutex_lock(&connection->mutex);
 823
 824         if (connection->state == GB_CONNECTION_STATE_DISABLED)
 825                 goto out_unlock;
 826
 827         trace_gb_connection_disable(connection);
 828
 829         spin_lock_irq(&connection->lock);
 830         connection->state = GB_CONNECTION_STATE_DISCONNECTING;
 831         gb_connection_cancel_operations(connection, -ESHUTDOWN);
 832         spin_unlock_irq(&connection->lock);
 833
 834         gb_connection_hd_cport_flush(connection);
 835
 836         gb_connection_control_disconnecting(connection);
 837         gb_connection_cport_shutdown_phase_1(connection);
 838         gb_connection_hd_cport_quiesce(connection);
 839         gb_connection_cport_shutdown_phase_2(connection);
 840         gb_connection_control_disconnected(connection);
 841
 842         connection->state = GB_CONNECTION_STATE_DISABLED;
 843
 844         /* control-connection tear down is deferred when mode switching */
 845         if (!connection->mode_switch) {
 846                 gb_connection_svc_connection_destroy(connection);
 847                 gb_connection_hd_cport_clear(connection);
 848
 849                 gb_connection_hd_cport_disable(connection);
 850         }
 851
 852 out_unlock:
 853         mutex_unlock(&connection->mutex);
 854 }
 855 EXPORT_SYMBOL_GPL(gb_connection_disable);
 856
 857 /* Disable a connection without communicating with the remote end. */
 858 void gb_connection_disable_forced(struct gb_connection *connection)
 859 {
 860         mutex_lock(&connection->mutex);
 861
 862         if (connection->state == GB_CONNECTION_STATE_DISABLED)
 863                 goto out_unlock;
 864
 865         trace_gb_connection_disable(connection);
 866
 867         spin_lock_irq(&connection->lock);
 868         connection->state = GB_CONNECTION_STATE_DISABLED;
 869         gb_connection_cancel_operations(connection, -ESHUTDOWN);
 870         spin_unlock_irq(&connection->lock);
 871
 872         gb_connection_hd_cport_flush(connection);
 873
 874         gb_connection_svc_connection_destroy(connection);
 875         gb_connection_hd_cport_clear(connection);
 876
 877         gb_connection_hd_cport_disable(connection);
 878 out_unlock:
 879         mutex_unlock(&connection->mutex);
 880 }
 881 EXPORT_SYMBOL_GPL(gb_connection_disable_forced);
 882
 883 /* Caller must have disabled the connection before destroying it. */
 884 void gb_connection_destroy(struct gb_connection *connection)
 885 {
 886         if (!connection)
 887                 return;
 888
 889         if (WARN_ON(connection->state != GB_CONNECTION_STATE_DISABLED))
 890                 gb_connection_disable(connection);
 891
 892         mutex_lock(&gb_connection_mutex);
 893
 894         spin_lock_irq(&gb_connections_lock);
 895         list_del(&connection->bundle_links);
 896         list_del(&connection->hd_links);
 897         spin_unlock_irq(&gb_connections_lock);
 898
 899         destroy_workqueue(connection->wq);
 900
 901         gb_hd_cport_release(connection->hd, connection->hd_cport_id);
 902         connection->hd_cport_id = CPORT_ID_BAD;
 903
 904         mutex_unlock(&gb_connection_mutex);
 905
 906         gb_connection_put(connection);
 907 }
 908 EXPORT_SYMBOL_GPL(gb_connection_destroy);
 909
 910 void gb_connection_latency_tag_enable(struct gb_connection *connection)
 911 {
 912         struct gb_host_device *hd = connection->hd;
 913         int ret;
 914
 915         if (!hd->driver->latency_tag_enable)
 916                 return;
 917
 918         ret = hd->driver->latency_tag_enable(hd, connection->hd_cport_id);
 919         if (ret) {
 920                 dev_err(&connection->hd->dev,
 921                         "%s: failed to enable latency tag: %d\n",
 922                         connection->name, ret);
 923         }
 924 }
 925 EXPORT_SYMBOL_GPL(gb_connection_latency_tag_enable);
 926
 927 void gb_connection_latency_tag_disable(struct gb_connection *connection)
 928 {
 929         struct gb_host_device *hd = connection->hd;
 930         int ret;
 931
 932         if (!hd->driver->latency_tag_disable)
 933                 return;
 934
 935         ret = hd->driver->latency_tag_disable(hd, connection->hd_cport_id);
 936         if (ret) {
 937                 dev_err(&connection->hd->dev,
 938                         "%s: failed to disable latency tag: %d\n",
 939                         connection->name, ret);
 940         }
 941 }
 942 EXPORT_SYMBOL_GPL(gb_connection_latency_tag_disable);