drivers/staging/greybus/control.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Greybus CPort control protocol.
   4  *
   5  * Copyright 2015 Google Inc.
   6  * Copyright 2015 Linaro Ltd.
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12 #include "greybus.h"
  13
  14 /* Highest control-protocol version supported */
  15 #define GB_CONTROL_VERSION_MAJOR        0
  16 #define GB_CONTROL_VERSION_MINOR        1
  17
  18
  19 static int gb_control_get_version(struct gb_control *control)
  20 {
  21         struct gb_interface *intf = control->connection->intf;
  22         struct gb_control_version_request request;
  23         struct gb_control_version_response response;
  24         int ret;
  25
  26         request.major = GB_CONTROL_VERSION_MAJOR;
  27         request.minor = GB_CONTROL_VERSION_MINOR;
  28
  29         ret = gb_operation_sync(control->connection,
  30                                 GB_CONTROL_TYPE_VERSION,
  31                                 &request, sizeof(request), &response,
  32                                 sizeof(response));
  33         if (ret) {
  34                 dev_err(&intf->dev,
  35                                 "failed to get control-protocol version: %d\n",
  36                                 ret);
  37                 return ret;
  38         }
  39
  40         if (response.major > request.major) {
  41                 dev_err(&intf->dev,
  42                                 "unsupported major control-protocol version (%u > %u)\n",
  43                                 response.major, request.major);
  44                 return -ENOTSUPP;
  45         }
  46
  47         control->protocol_major = response.major;
  48         control->protocol_minor = response.minor;
  49
  50         dev_dbg(&intf->dev, "%s - %u.%u\n", __func__, response.major,
  51                         response.minor);
  52
  53         return 0;
  54 }
  55
  56 static int gb_control_get_bundle_version(struct gb_control *control,
  57                                                 struct gb_bundle *bundle)
  58 {
  59         struct gb_interface *intf = control->connection->intf;
  60         struct gb_control_bundle_version_request request;
  61         struct gb_control_bundle_version_response response;
  62         int ret;
  63
  64         request.bundle_id = bundle->id;
  65
  66         ret = gb_operation_sync(control->connection,
  67                                 GB_CONTROL_TYPE_BUNDLE_VERSION,
  68                                 &request, sizeof(request),
  69                                 &response, sizeof(response));
  70         if (ret) {
  71                 dev_err(&intf->dev,
  72                                 "failed to get bundle %u class version: %d\n",
  73                                 bundle->id, ret);
  74                 return ret;
  75         }
  76
  77         bundle->class_major = response.major;
  78         bundle->class_minor = response.minor;
  79
  80         dev_dbg(&intf->dev, "%s - %u: %u.%u\n", __func__, bundle->id,
  81                         response.major, response.minor);
  82
  83         return 0;
  84 }
  85
  86 int gb_control_get_bundle_versions(struct gb_control *control)
  87 {
  88         struct gb_interface *intf = control->connection->intf;
  89         struct gb_bundle *bundle;
  90         int ret;
  91
  92         if (!control->has_bundle_version)
  93                 return 0;
  94
  95         list_for_each_entry(bundle, &intf->bundles, links) {
  96                 ret = gb_control_get_bundle_version(control, bundle);
  97                 if (ret)
  98                         return ret;
  99         }
 100
 101         return 0;
 102 }
 103
 104 /* Get Manifest's size from the interface */
 105 int gb_control_get_manifest_size_operation(struct gb_interface *intf)
 106 {
 107         struct gb_control_get_manifest_size_response response;
 108         struct gb_connection *connection = intf->control->connection;
 109         int ret;
 110
 111         ret = gb_operation_sync(connection, GB_CONTROL_TYPE_GET_MANIFEST_SIZE,
 112                                 NULL, 0, &response, sizeof(response));
 113         if (ret) {
 114                 dev_err(&connection->intf->dev,
 115                                 "failed to get manifest size: %d\n", ret);
 116                 return ret;
 117         }
 118
 119         return le16_to_cpu(response.size);
 120 }
 121
 122 /* Reads Manifest from the interface */
 123 int gb_control_get_manifest_operation(struct gb_interface *intf, void *manifest,
 124                                       size_t size)
 125 {
 126         struct gb_connection *connection = intf->control->connection;
 127
 128         return gb_operation_sync(connection, GB_CONTROL_TYPE_GET_MANIFEST,
 129                                 NULL, 0, manifest, size);
 130 }
 131
 132 int gb_control_connected_operation(struct gb_control *control, u16 cport_id)
 133 {
 134         struct gb_control_connected_request request;
 135
 136         request.cport_id = cpu_to_le16(cport_id);
 137         return gb_operation_sync(control->connection, GB_CONTROL_TYPE_CONNECTED,
 138                                  &request, sizeof(request), NULL, 0);
 139 }
 140
 141 int gb_control_disconnected_operation(struct gb_control *control, u16 cport_id)
 142 {
 143         struct gb_control_disconnected_request request;
 144
 145         request.cport_id = cpu_to_le16(cport_id);
 146         return gb_operation_sync(control->connection,
 147                                  GB_CONTROL_TYPE_DISCONNECTED, &request,
 148                                  sizeof(request), NULL, 0);
 149 }
 150
 151 int gb_control_disconnecting_operation(struct gb_control *control,
 152                                         u16 cport_id)
 153 {
 154         struct gb_control_disconnecting_request *request;
 155         struct gb_operation *operation;
 156         int ret;
 157
 158         operation = gb_operation_create_core(control->connection,
 159                                         GB_CONTROL_TYPE_DISCONNECTING,
 160                                         sizeof(*request), 0, 0,
 161                                         GFP_KERNEL);
 162         if (!operation)
 163                 return -ENOMEM;
 164
 165         request = operation->request->payload;
 166         request->cport_id = cpu_to_le16(cport_id);
 167
 168         ret = gb_operation_request_send_sync(operation);
 169         if (ret) {
 170                 dev_err(&control->dev, "failed to send disconnecting: %d\n",
 171                                 ret);
 172         }
 173
 174         gb_operation_put(operation);
 175
 176         return ret;
 177 }
 178
 179 int gb_control_mode_switch_operation(struct gb_control *control)
 180 {
 181         struct gb_operation *operation;
 182         int ret;
 183
 184         operation = gb_operation_create_core(control->connection,
 185                                         GB_CONTROL_TYPE_MODE_SWITCH,
 186                                         0, 0, GB_OPERATION_FLAG_UNIDIRECTIONAL,
 187                                         GFP_KERNEL);
 188         if (!operation)
 189                 return -ENOMEM;
 190
 191         ret = gb_operation_request_send_sync(operation);
 192         if (ret)
 193                 dev_err(&control->dev, "failed to send mode switch: %d\n", ret);
 194
 195         gb_operation_put(operation);
 196
 197         return ret;
 198 }
 199
 200 static int gb_control_bundle_pm_status_map(u8 status)
 201 {
 202         switch (status) {
 203         case GB_CONTROL_BUNDLE_PM_INVAL:
 204                 return -EINVAL;
 205         case GB_CONTROL_BUNDLE_PM_BUSY:
 206                 return -EBUSY;
 207         case GB_CONTROL_BUNDLE_PM_NA:
 208                 return -ENOMSG;
 209         case GB_CONTROL_BUNDLE_PM_FAIL:
 210         default:
 211                 return -EREMOTEIO;
 212         }
 213 }
 214
 215 int gb_control_bundle_suspend(struct gb_control *control, u8 bundle_id)
 216 {
 217         struct gb_control_bundle_pm_request request;
 218         struct gb_control_bundle_pm_response response;
 219         int ret;
 220
 221         request.bundle_id = bundle_id;
 222         ret = gb_operation_sync(control->connection,
 223                                 GB_CONTROL_TYPE_BUNDLE_SUSPEND, &request,
 224                                 sizeof(request), &response, sizeof(response));
 225         if (ret) {
 226                 dev_err(&control->dev, "failed to send bundle %u suspend: %d\n",
 227                         bundle_id, ret);
 228                 return ret;
 229         }
 230
 231         if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
 232                 dev_err(&control->dev, "failed to suspend bundle %u: %d\n",
 233                         bundle_id, response.status);
 234                 return gb_control_bundle_pm_status_map(response.status);
 235         }
 236
 237         return 0;
 238 }
 239
 240 int gb_control_bundle_resume(struct gb_control *control, u8 bundle_id)
 241 {
 242         struct gb_control_bundle_pm_request request;
 243         struct gb_control_bundle_pm_response response;
 244         int ret;
 245
 246         request.bundle_id = bundle_id;
 247         ret = gb_operation_sync(control->connection,
 248                                 GB_CONTROL_TYPE_BUNDLE_RESUME, &request,
 249                                 sizeof(request), &response, sizeof(response));
 250         if (ret) {
 251                 dev_err(&control->dev, "failed to send bundle %u resume: %d\n",
 252                         bundle_id, ret);
 253                 return ret;
 254         }
 255
 256         if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
 257                 dev_err(&control->dev, "failed to resume bundle %u: %d\n",
 258                         bundle_id, response.status);
 259                 return gb_control_bundle_pm_status_map(response.status);
 260         }
 261
 262         return 0;
 263 }
 264
 265 int gb_control_bundle_deactivate(struct gb_control *control, u8 bundle_id)
 266 {
 267         struct gb_control_bundle_pm_request request;
 268         struct gb_control_bundle_pm_response response;
 269         int ret;
 270
 271         request.bundle_id = bundle_id;
 272         ret = gb_operation_sync(control->connection,
 273                                 GB_CONTROL_TYPE_BUNDLE_DEACTIVATE, &request,
 274                                 sizeof(request), &response, sizeof(response));
 275         if (ret) {
 276                 dev_err(&control->dev,
 277                         "failed to send bundle %u deactivate: %d\n", bundle_id,
 278                         ret);
 279                 return ret;
 280         }
 281
 282         if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
 283                 dev_err(&control->dev, "failed to deactivate bundle %u: %d\n",
 284                         bundle_id, response.status);
 285                 return gb_control_bundle_pm_status_map(response.status);
 286         }
 287
 288         return 0;
 289 }
 290
 291 int gb_control_bundle_activate(struct gb_control *control, u8 bundle_id)
 292 {
 293         struct gb_control_bundle_pm_request request;
 294         struct gb_control_bundle_pm_response response;
 295         int ret;
 296
 297         if (!control->has_bundle_activate)
 298                 return 0;
 299
 300         request.bundle_id = bundle_id;
 301         ret = gb_operation_sync(control->connection,
 302                                 GB_CONTROL_TYPE_BUNDLE_ACTIVATE, &request,
 303                                 sizeof(request), &response, sizeof(response));
 304         if (ret) {
 305                 dev_err(&control->dev,
 306                         "failed to send bundle %u activate: %d\n", bundle_id,
 307                         ret);
 308                 return ret;
 309         }
 310
 311         if (response.status != GB_CONTROL_BUNDLE_PM_OK) {
 312                 dev_err(&control->dev, "failed to activate bundle %u: %d\n",
 313                         bundle_id, response.status);
 314                 return gb_control_bundle_pm_status_map(response.status);
 315         }
 316
 317         return 0;
 318 }
 319
 320 static int gb_control_interface_pm_status_map(u8 status)
 321 {
 322         switch (status) {
 323         case GB_CONTROL_INTF_PM_BUSY:
 324                 return -EBUSY;
 325         case GB_CONTROL_INTF_PM_NA:
 326                 return -ENOMSG;
 327         default:
 328                 return -EREMOTEIO;
 329         }
 330 }
 331
 332 int gb_control_interface_suspend_prepare(struct gb_control *control)
 333 {
 334         struct gb_control_intf_pm_response response;
 335         int ret;
 336
 337         ret = gb_operation_sync(control->connection,
 338                                 GB_CONTROL_TYPE_INTF_SUSPEND_PREPARE, NULL, 0,
 339                                 &response, sizeof(response));
 340         if (ret) {
 341                 dev_err(&control->dev,
 342                         "failed to send interface suspend prepare: %d\n", ret);
 343                 return ret;
 344         }
 345
 346         if (response.status != GB_CONTROL_INTF_PM_OK) {
 347                 dev_err(&control->dev, "interface error while preparing suspend: %d\n",
 348                         response.status);
 349                 return gb_control_interface_pm_status_map(response.status);
 350         }
 351
 352         return 0;
 353 }
 354
 355 int gb_control_interface_deactivate_prepare(struct gb_control *control)
 356 {
 357         struct gb_control_intf_pm_response response;
 358         int ret;
 359
 360         ret = gb_operation_sync(control->connection,
 361                                 GB_CONTROL_TYPE_INTF_DEACTIVATE_PREPARE, NULL,
 362                                 0, &response, sizeof(response));
 363         if (ret) {
 364                 dev_err(&control->dev, "failed to send interface deactivate prepare: %d\n",
 365                         ret);
 366                 return ret;
 367         }
 368
 369         if (response.status != GB_CONTROL_INTF_PM_OK) {
 370                 dev_err(&control->dev, "interface error while preparing deactivate: %d\n",
 371                         response.status);
 372                 return gb_control_interface_pm_status_map(response.status);
 373         }
 374
 375         return 0;
 376 }
 377
 378 int gb_control_interface_hibernate_abort(struct gb_control *control)
 379 {
 380         struct gb_control_intf_pm_response response;
 381         int ret;
 382
 383         ret = gb_operation_sync(control->connection,
 384                                 GB_CONTROL_TYPE_INTF_HIBERNATE_ABORT, NULL, 0,
 385                                 &response, sizeof(response));
 386         if (ret) {
 387                 dev_err(&control->dev,
 388                         "failed to send interface aborting hibernate: %d\n",
 389                         ret);
 390                 return ret;
 391         }
 392
 393         if (response.status != GB_CONTROL_INTF_PM_OK) {
 394                 dev_err(&control->dev, "interface error while aborting hibernate: %d\n",
 395                         response.status);
 396                 return gb_control_interface_pm_status_map(response.status);
 397         }
 398
 399         return 0;
 400 }
 401
 402 static ssize_t vendor_string_show(struct device *dev,
 403                         struct device_attribute *attr, char *buf)
 404 {
 405         struct gb_control *control = to_gb_control(dev);
 406
 407         return scnprintf(buf, PAGE_SIZE, "%s\n", control->vendor_string);
 408 }
 409 static DEVICE_ATTR_RO(vendor_string);
 410
 411 static ssize_t product_string_show(struct device *dev,
 412                         struct device_attribute *attr, char *buf)
 413 {
 414         struct gb_control *control = to_gb_control(dev);
 415
 416         return scnprintf(buf, PAGE_SIZE, "%s\n", control->product_string);
 417 }
 418 static DEVICE_ATTR_RO(product_string);
 419
 420 static struct attribute *control_attrs[] = {
 421         &dev_attr_vendor_string.attr,
 422         &dev_attr_product_string.attr,
 423         NULL,
 424 };
 425 ATTRIBUTE_GROUPS(control);
 426
 427 static void gb_control_release(struct device *dev)
 428 {
 429         struct gb_control *control = to_gb_control(dev);
 430
 431         gb_connection_destroy(control->connection);
 432
 433         kfree(control->vendor_string);
 434         kfree(control->product_string);
 435
 436         kfree(control);
 437 }
 438
 439 struct device_type greybus_control_type = {
 440         .name =         "greybus_control",
 441         .release =      gb_control_release,
 442 };
 443
 444 struct gb_control *gb_control_create(struct gb_interface *intf)
 445 {
 446         struct gb_connection *connection;
 447         struct gb_control *control;
 448
 449         control = kzalloc(sizeof(*control), GFP_KERNEL);
 450         if (!control)
 451                 return ERR_PTR(-ENOMEM);
 452
 453         control->intf = intf;
 454
 455         connection = gb_connection_create_control(intf);
 456         if (IS_ERR(connection)) {
 457                 dev_err(&intf->dev,
 458                                 "failed to create control connection: %ld\n",
 459                                 PTR_ERR(connection));
 460                 kfree(control);
 461                 return ERR_CAST(connection);
 462         }
 463
 464         control->connection = connection;
 465
 466         control->dev.parent = &intf->dev;
 467         control->dev.bus = &greybus_bus_type;
 468         control->dev.type = &greybus_control_type;
 469         control->dev.groups = control_groups;
 470         control->dev.dma_mask = intf->dev.dma_mask;
 471         device_initialize(&control->dev);
 472         dev_set_name(&control->dev, "%s.ctrl", dev_name(&intf->dev));
 473
 474         gb_connection_set_data(control->connection, control);
 475
 476         return control;
 477 }
 478
 479 int gb_control_enable(struct gb_control *control)
 480 {
 481         int ret;
 482
 483         dev_dbg(&control->connection->intf->dev, "%s\n", __func__);
 484
 485         ret = gb_connection_enable_tx(control->connection);
 486         if (ret) {
 487                 dev_err(&control->connection->intf->dev,
 488                                 "failed to enable control connection: %d\n",
 489                                 ret);
 490                 return ret;
 491         }
 492
 493         ret = gb_control_get_version(control);
 494         if (ret)
 495                 goto err_disable_connection;
 496
 497         if (control->protocol_major > 0 || control->protocol_minor > 1)
 498                 control->has_bundle_version = true;
 499
 500         /* FIXME: use protocol version instead */
 501         if (!(control->intf->quirks & GB_INTERFACE_QUIRK_NO_BUNDLE_ACTIVATE))
 502                 control->has_bundle_activate = true;
 503
 504         return 0;
 505
 506 err_disable_connection:
 507         gb_connection_disable(control->connection);
 508
 509         return ret;
 510 }
 511
 512 void gb_control_disable(struct gb_control *control)
 513 {
 514         dev_dbg(&control->connection->intf->dev, "%s\n", __func__);
 515
 516         if (control->intf->disconnected)
 517                 gb_connection_disable_forced(control->connection);
 518         else
 519                 gb_connection_disable(control->connection);
 520 }
 521
 522 int gb_control_suspend(struct gb_control *control)
 523 {
 524         gb_connection_disable(control->connection);
 525
 526         return 0;
 527 }
 528
 529 int gb_control_resume(struct gb_control *control)
 530 {
 531         int ret;
 532
 533         ret = gb_connection_enable_tx(control->connection);
 534         if (ret) {
 535                 dev_err(&control->connection->intf->dev,
 536                         "failed to enable control connection: %d\n", ret);
 537                 return ret;
 538         }
 539
 540         return 0;
 541 }
 542
 543 int gb_control_add(struct gb_control *control)
 544 {
 545         int ret;
 546
 547         ret = device_add(&control->dev);
 548         if (ret) {
 549                 dev_err(&control->dev,
 550                                 "failed to register control device: %d\n",
 551                                 ret);
 552                 return ret;
 553         }
 554
 555         return 0;
 556 }
 557
 558 void gb_control_del(struct gb_control *control)
 559 {
 560         if (device_is_registered(&control->dev))
 561                 device_del(&control->dev);
 562 }
 563
 564 struct gb_control *gb_control_get(struct gb_control *control)
 565 {
 566         get_device(&control->dev);
 567
 568         return control;
 569 }
 570
 571 void gb_control_put(struct gb_control *control)
 572 {
 573         put_device(&control->dev);
 574 }
 575
 576 void gb_control_mode_switch_prepare(struct gb_control *control)
 577 {
 578         gb_connection_mode_switch_prepare(control->connection);
 579 }
 580
 581 void gb_control_mode_switch_complete(struct gb_control *control)
 582 {
 583         gb_connection_mode_switch_complete(control->connection);
 584 }