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
  14
  15 static int gb_connection_bind_protocol(struct gb_connection *connection);
  16 static void gb_connection_unbind_protocol(struct gb_connection *connection);
  17
  18
  19 static DEFINE_SPINLOCK(gb_connections_lock);
  20
  21 /* This is only used at initialization time; no locking is required. */
  22 static struct gb_connection *
  23 gb_connection_intf_find(struct gb_interface *intf, u16 cport_id)
  24 {
  25         struct gb_host_device *hd = intf->hd;
  26         struct gb_connection *connection;
  27
  28         list_for_each_entry(connection, &hd->connections, hd_links) {
  29                 if (connection->intf == intf &&
  30                                 connection->intf_cport_id == cport_id)
  31                         return connection;
  32         }
  33
  34         return NULL;
  35 }
  36
  37 static struct gb_connection *
  38 gb_connection_hd_find(struct gb_host_device *hd, u16 cport_id)
  39 {
  40         struct gb_connection *connection;
  41         unsigned long flags;
  42
  43         spin_lock_irqsave(&gb_connections_lock, flags);
  44         list_for_each_entry(connection, &hd->connections, hd_links)
  45                 if (connection->hd_cport_id == cport_id)
  46                         goto found;
  47         connection = NULL;
  48 found:
  49         spin_unlock_irqrestore(&gb_connections_lock, flags);
  50
  51         return connection;
  52 }
  53
  54 /*
  55  * Callback from the host driver to let us know that data has been
  56  * received on the bundle.
  57  */
  58 void greybus_data_rcvd(struct gb_host_device *hd, u16 cport_id,
  59                         u8 *data, size_t length)
  60 {
  61         struct gb_connection *connection;
  62
  63         connection = gb_connection_hd_find(hd, cport_id);
  64         if (!connection) {
  65                 dev_err(&hd->dev,
  66                         "nonexistent connection (%zu bytes dropped)\n", length);
  67                 return;
  68         }
  69         gb_connection_recv(connection, data, length);
  70 }
  71 EXPORT_SYMBOL_GPL(greybus_data_rcvd);
  72
  73 static DEFINE_MUTEX(connection_mutex);
  74
  75 static void gb_connection_kref_release(struct kref *kref)
  76 {
  77         struct gb_connection *connection;
  78
  79         connection = container_of(kref, struct gb_connection, kref);
  80         destroy_workqueue(connection->wq);
  81         kfree(connection);
  82         mutex_unlock(&connection_mutex);
  83 }
  84
  85 static void gb_connection_init_name(struct gb_connection *connection)
  86 {
  87         u16 hd_cport_id = connection->hd_cport_id;
  88         u16 cport_id = 0;
  89         u8 intf_id = 0;
  90
  91         if (connection->intf) {
  92                 intf_id = connection->intf->interface_id;
  93                 cport_id = connection->intf_cport_id;
  94         }
  95
  96         snprintf(connection->name, sizeof(connection->name),
  97                         "%u/%u:%u", hd_cport_id, intf_id, cport_id);
  98 }
  99
 100 /*
 101  * gb_connection_create() - create a Greybus connection
 102  * @hd:                 host device of the connection
 103  * @hd_cport_id:        host-device cport id, or -1 for dynamic allocation
 104  * @intf:               remote interface, or NULL for static connections
 105  * @bundle:             remote-interface bundle (may be NULL)
 106  * @cport_id:           remote-interface cport id, or 0 for static connections
 107  * @protocol_id:        protocol id
 108  *
 109  * Create a Greybus connection, representing the bidirectional link
 110  * between a CPort on a (local) Greybus host device and a CPort on
 111  * another Greybus interface.
 112  *
 113  * A connection also maintains the state of operations sent over the
 114  * connection.
 115  *
 116  * Return: A pointer to the new connection if successful, or NULL otherwise.
 117  */
 118 static struct gb_connection *
 119 gb_connection_create(struct gb_host_device *hd, int hd_cport_id,
 120                                 struct gb_interface *intf,
 121                                 struct gb_bundle *bundle, int cport_id,
 122                                 u8 protocol_id)
 123 {
 124         struct gb_connection *connection;
 125         struct ida *id_map = &hd->cport_id_map;
 126         int ida_start, ida_end;
 127         u8 major = 0;
 128         u8 minor = 1;
 129
 130         /*
 131          * If a manifest tries to reuse a cport, reject it.  We
 132          * initialize connections serially so we don't need to worry
 133          * about holding the connection lock.
 134          */
 135         if (bundle && gb_connection_intf_find(bundle->intf, cport_id)) {
 136                 dev_err(&bundle->dev, "cport 0x%04x already connected\n",
 137                                 cport_id);
 138                 return NULL;
 139         }
 140
 141         if (hd_cport_id < 0) {
 142                 ida_start = 0;
 143                 ida_end = hd->num_cports;
 144         } else if (hd_cport_id < hd->num_cports) {
 145                 ida_start = hd_cport_id;
 146                 ida_end = hd_cport_id + 1;
 147         } else {
 148                 dev_err(&hd->dev, "cport %d not available\n", hd_cport_id);
 149                 return NULL;
 150         }
 151
 152         hd_cport_id = ida_simple_get(id_map, ida_start, ida_end, GFP_KERNEL);
 153         if (hd_cport_id < 0)
 154                 return NULL;
 155
 156         connection = kzalloc(sizeof(*connection), GFP_KERNEL);
 157         if (!connection)
 158                 goto err_remove_ida;
 159
 160         connection->hd_cport_id = hd_cport_id;
 161         connection->intf_cport_id = cport_id;
 162         connection->hd = hd;
 163         connection->intf = intf;
 164
 165         connection->protocol_id = protocol_id;
 166         connection->major = major;
 167         connection->minor = minor;
 168
 169         connection->bundle = bundle;
 170         connection->state = GB_CONNECTION_STATE_DISABLED;
 171
 172         atomic_set(&connection->op_cycle, 0);
 173         spin_lock_init(&connection->lock);
 174         INIT_LIST_HEAD(&connection->operations);
 175
 176         connection->wq = alloc_workqueue("%s:%d", WQ_UNBOUND, 1,
 177                                          dev_name(&hd->dev), hd_cport_id);
 178         if (!connection->wq)
 179                 goto err_free_connection;
 180
 181         kref_init(&connection->kref);
 182
 183         gb_connection_init_name(connection);
 184
 185         spin_lock_irq(&gb_connections_lock);
 186         list_add(&connection->hd_links, &hd->connections);
 187
 188         if (bundle)
 189                 list_add(&connection->bundle_links, &bundle->connections);
 190         else
 191                 INIT_LIST_HEAD(&connection->bundle_links);
 192
 193         spin_unlock_irq(&gb_connections_lock);
 194
 195         return connection;
 196
 197 err_free_connection:
 198         kfree(connection);
 199 err_remove_ida:
 200         ida_simple_remove(id_map, hd_cport_id);
 201
 202         return NULL;
 203 }
 204
 205 struct gb_connection *
 206 gb_connection_create_static(struct gb_host_device *hd,
 207                                         u16 hd_cport_id, u8 protocol_id)
 208 {
 209         return gb_connection_create(hd, hd_cport_id, NULL, NULL, 0,
 210                                                                 protocol_id);
 211 }
 212
 213 struct gb_connection *
 214 gb_connection_create_dynamic(struct gb_interface *intf,
 215                                         struct gb_bundle *bundle,
 216                                         u16 cport_id, u8 protocol_id)
 217 {
 218         return gb_connection_create(intf->hd, -1, intf, bundle, cport_id,
 219                                                                 protocol_id);
 220 }
 221
 222 static int gb_connection_hd_cport_enable(struct gb_connection *connection)
 223 {
 224         struct gb_host_device *hd = connection->hd;
 225         int ret;
 226
 227         if (!hd->driver->cport_enable)
 228                 return 0;
 229
 230         ret = hd->driver->cport_enable(hd, connection->hd_cport_id);
 231         if (ret) {
 232                 dev_err(&hd->dev,
 233                         "failed to enable host cport: %d\n", ret);
 234                 return ret;
 235         }
 236
 237         return 0;
 238 }
 239
 240 static void gb_connection_hd_cport_disable(struct gb_connection *connection)
 241 {
 242         struct gb_host_device *hd = connection->hd;
 243
 244         if (!hd->driver->cport_disable)
 245                 return;
 246
 247         hd->driver->cport_disable(hd, connection->hd_cport_id);
 248 }
 249
 250 /*
 251  * Cancel all active operations on a connection.
 252  *
 253  * Should only be called during connection tear down.
 254  */
 255 static void gb_connection_cancel_operations(struct gb_connection *connection,
 256                                                 int errno)
 257 {
 258         struct gb_operation *operation;
 259
 260         spin_lock_irq(&connection->lock);
 261         while (!list_empty(&connection->operations)) {
 262                 operation = list_last_entry(&connection->operations,
 263                                                 struct gb_operation, links);
 264                 gb_operation_get(operation);
 265                 spin_unlock_irq(&connection->lock);
 266
 267                 if (gb_operation_is_incoming(operation))
 268                         gb_operation_cancel_incoming(operation, errno);
 269                 else
 270                         gb_operation_cancel(operation, errno);
 271
 272                 gb_operation_put(operation);
 273
 274                 spin_lock_irq(&connection->lock);
 275         }
 276         spin_unlock_irq(&connection->lock);
 277 }
 278
 279 /*
 280  * Request the SVC to create a connection from AP's cport to interface's
 281  * cport.
 282  */
 283 static int
 284 gb_connection_svc_connection_create(struct gb_connection *connection)
 285 {
 286         struct gb_host_device *hd = connection->hd;
 287         struct gb_interface *intf;
 288         int ret;
 289
 290         if (gb_connection_is_static(connection))
 291                 return 0;
 292
 293         intf = connection->intf;
 294         ret = gb_svc_connection_create(hd->svc,
 295                         hd->svc->ap_intf_id,
 296                         connection->hd_cport_id,
 297                         intf->interface_id,
 298                         connection->intf_cport_id,
 299                         intf->boot_over_unipro);
 300         if (ret) {
 301                 dev_err(&connection->hd->dev,
 302                         "%s: failed to create svc connection: %d\n",
 303                         connection->name, ret);
 304                 return ret;
 305         }
 306
 307         return 0;
 308 }
 309
 310 static void
 311 gb_connection_svc_connection_destroy(struct gb_connection *connection)
 312 {
 313         if (gb_connection_is_static(connection))
 314                 return;
 315
 316         gb_svc_connection_destroy(connection->hd->svc,
 317                                   connection->hd->svc->ap_intf_id,
 318                                   connection->hd_cport_id,
 319                                   connection->intf->interface_id,
 320                                   connection->intf_cport_id);
 321 }
 322
 323 /* Inform Interface about active CPorts */
 324 static int gb_connection_control_connected(struct gb_connection *connection)
 325 {
 326         struct gb_protocol *protocol = connection->protocol;
 327         struct gb_control *control;
 328         u16 cport_id = connection->intf_cport_id;
 329         int ret;
 330
 331         if (protocol->flags & GB_PROTOCOL_SKIP_CONTROL_CONNECTED)
 332                 return 0;
 333
 334         control = connection->bundle->intf->control;
 335
 336         ret = gb_control_connected_operation(control, cport_id);
 337         if (ret) {
 338                 dev_err(&connection->bundle->dev,
 339                         "failed to connect cport: %d\n", ret);
 340                 return ret;
 341         }
 342
 343         return 0;
 344 }
 345
 346 /* Inform Interface about inactive CPorts */
 347 static void
 348 gb_connection_control_disconnected(struct gb_connection *connection)
 349 {
 350         struct gb_protocol *protocol = connection->protocol;
 351         struct gb_control *control;
 352         u16 cport_id = connection->intf_cport_id;
 353         int ret;
 354
 355         if (protocol->flags & GB_PROTOCOL_SKIP_CONTROL_DISCONNECTED)
 356                 return;
 357
 358         control = connection->bundle->intf->control;
 359
 360         ret = gb_control_disconnected_operation(control, cport_id);
 361         if (ret) {
 362                 dev_warn(&connection->bundle->dev,
 363                          "failed to disconnect cport: %d\n", ret);
 364         }
 365 }
 366
 367 /*
 368  * Request protocol version supported by the module. We don't need to do
 369  * this for SVC as that is initiated by the SVC.
 370  */
 371 static int gb_connection_protocol_get_version(struct gb_connection *connection)
 372 {
 373         struct gb_protocol *protocol = connection->protocol;
 374         int ret;
 375
 376         if (protocol->flags & GB_PROTOCOL_SKIP_VERSION)
 377                 return 0;
 378
 379         ret = gb_protocol_get_version(connection);
 380         if (ret) {
 381                 dev_err(&connection->bundle->dev,
 382                         "failed to get protocol version: %d\n", ret);
 383                 return ret;
 384         }
 385
 386         return 0;
 387 }
 388
 389 int gb_connection_init(struct gb_connection *connection)
 390 {
 391         int ret;
 392
 393         ret = gb_connection_bind_protocol(connection);
 394         if (ret)
 395                 return ret;
 396
 397         ret = gb_connection_hd_cport_enable(connection);
 398         if (ret)
 399                 goto err_unbind_protocol;
 400
 401         ret = gb_connection_svc_connection_create(connection);
 402         if (ret)
 403                 goto err_hd_cport_disable;
 404
 405         ret = gb_connection_control_connected(connection);
 406         if (ret)
 407                 goto err_svc_destroy;
 408
 409         /* Need to enable the connection to initialize it */
 410         spin_lock_irq(&connection->lock);
 411         connection->state = GB_CONNECTION_STATE_ENABLED;
 412         spin_unlock_irq(&connection->lock);
 413
 414         ret = gb_connection_protocol_get_version(connection);
 415         if (ret)
 416                 goto err_disconnect;
 417
 418         ret = connection->protocol->connection_init(connection);
 419         if (ret)
 420                 goto err_disconnect;
 421
 422         return 0;
 423
 424 err_disconnect:
 425         spin_lock_irq(&connection->lock);
 426         connection->state = GB_CONNECTION_STATE_ERROR;
 427         spin_unlock_irq(&connection->lock);
 428
 429         gb_connection_control_disconnected(connection);
 430 err_svc_destroy:
 431         gb_connection_svc_connection_destroy(connection);
 432 err_hd_cport_disable:
 433         gb_connection_hd_cport_disable(connection);
 434 err_unbind_protocol:
 435         gb_connection_unbind_protocol(connection);
 436
 437         return ret;
 438 }
 439
 440 static void gb_connection_exit(struct gb_connection *connection)
 441 {
 442         spin_lock_irq(&connection->lock);
 443         if (connection->state != GB_CONNECTION_STATE_ENABLED) {
 444                 spin_unlock_irq(&connection->lock);
 445                 return;
 446         }
 447         connection->state = GB_CONNECTION_STATE_DESTROYING;
 448         spin_unlock_irq(&connection->lock);
 449
 450         gb_connection_cancel_operations(connection, -ESHUTDOWN);
 451
 452         connection->protocol->connection_exit(connection);
 453         gb_connection_control_disconnected(connection);
 454         gb_connection_svc_connection_destroy(connection);
 455         gb_connection_hd_cport_disable(connection);
 456         gb_connection_unbind_protocol(connection);
 457 }
 458
 459 /*
 460  * Tear down a previously set up connection.
 461  */
 462 void gb_connection_destroy(struct gb_connection *connection)
 463 {
 464         struct ida *id_map;
 465
 466         if (WARN_ON(!connection))
 467                 return;
 468
 469         gb_connection_exit(connection);
 470
 471         spin_lock_irq(&gb_connections_lock);
 472         list_del(&connection->bundle_links);
 473         list_del(&connection->hd_links);
 474         spin_unlock_irq(&gb_connections_lock);
 475
 476         id_map = &connection->hd->cport_id_map;
 477         ida_simple_remove(id_map, connection->hd_cport_id);
 478         connection->hd_cport_id = CPORT_ID_BAD;
 479
 480         kref_put_mutex(&connection->kref, gb_connection_kref_release,
 481                        &connection_mutex);
 482 }
 483
 484 void gb_connection_latency_tag_enable(struct gb_connection *connection)
 485 {
 486         struct gb_host_device *hd = connection->hd;
 487         int ret;
 488
 489         if (!hd->driver->latency_tag_enable)
 490                 return;
 491
 492         ret = hd->driver->latency_tag_enable(hd, connection->hd_cport_id);
 493         if (ret) {
 494                 dev_err(&connection->hd->dev,
 495                         "%s: failed to enable latency tag: %d\n",
 496                         connection->name, ret);
 497         }
 498 }
 499 EXPORT_SYMBOL_GPL(gb_connection_latency_tag_enable);
 500
 501 void gb_connection_latency_tag_disable(struct gb_connection *connection)
 502 {
 503         struct gb_host_device *hd = connection->hd;
 504         int ret;
 505
 506         if (!hd->driver->latency_tag_disable)
 507                 return;
 508
 509         ret = hd->driver->latency_tag_disable(hd, connection->hd_cport_id);
 510         if (ret) {
 511                 dev_err(&connection->hd->dev,
 512                         "%s: failed to disable latency tag: %d\n",
 513                         connection->name, ret);
 514         }
 515 }
 516 EXPORT_SYMBOL_GPL(gb_connection_latency_tag_disable);
 517
 518 static int gb_connection_bind_protocol(struct gb_connection *connection)
 519 {
 520         struct gb_protocol *protocol;
 521
 522         protocol = gb_protocol_get(connection->protocol_id,
 523                                    connection->major,
 524                                    connection->minor);
 525         if (!protocol) {
 526                 dev_err(&connection->hd->dev,
 527                                 "protocol 0x%02x version %u.%u not found\n",
 528                                 connection->protocol_id,
 529                                 connection->major, connection->minor);
 530                 return -EPROTONOSUPPORT;
 531         }
 532         connection->protocol = protocol;
 533
 534         return 0;
 535 }
 536
 537 static void gb_connection_unbind_protocol(struct gb_connection *connection)
 538 {
 539         struct gb_protocol *protocol = connection->protocol;
 540
 541         gb_protocol_put(protocol);
 542
 543         connection->protocol = NULL;
 544 }