drivers/staging/greybus/interface.c

   1 /*
   2  * Greybus interface code
   3  *
   4  * Copyright 2014 Google Inc.
   5  * Copyright 2014 Linaro Ltd.
   6  *
   7  * Released under the GPLv2 only.
   8  */
   9
  10 #include <linux/delay.h>
  11
  12 #include "greybus.h"
  13 #include "greybus_trace.h"
  14
  15 #define GB_INTERFACE_MODE_SWITCH_TIMEOUT        2000
  16
  17 #define GB_INTERFACE_DEVICE_ID_BAD      0xff
  18
  19 #define GB_INTERFACE_AUTOSUSPEND_MS                     3000
  20
  21 /* Time required for interface to enter standby before disabling REFCLK */
  22 #define GB_INTERFACE_SUSPEND_HIBERNATE_DELAY_MS                 20
  23
  24 /* Don't-care selector index */
  25 #define DME_SELECTOR_INDEX_NULL         0
  26
  27 /* DME attributes */
  28 /* FIXME: remove ES2 support and DME_T_TST_SRC_INCREMENT */
  29 #define DME_T_TST_SRC_INCREMENT         0x4083
  30
  31 #define DME_DDBL1_MANUFACTURERID        0x5003
  32 #define DME_DDBL1_PRODUCTID             0x5004
  33
  34 #define DME_TOSHIBA_ARA_VID             0x6000
  35 #define DME_TOSHIBA_ARA_PID             0x6001
  36 #define DME_TOSHIBA_ARA_SN0             0x6002
  37 #define DME_TOSHIBA_ARA_SN1             0x6003
  38 #define DME_TOSHIBA_ARA_INIT_STATUS     0x6101
  39
  40 /* DDBL1 Manufacturer and Product ids */
  41 #define TOSHIBA_DMID                    0x0126
  42 #define TOSHIBA_ES2_BRIDGE_DPID         0x1000
  43 #define TOSHIBA_ES3_APBRIDGE_DPID       0x1001
  44 #define TOSHIBA_ES3_GBPHY_DPID  0x1002
  45
  46 static int gb_interface_hibernate_link(struct gb_interface *intf);
  47 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable);
  48
  49 static int gb_interface_dme_attr_get(struct gb_interface *intf,
  50                                                         u16 attr, u32 *val)
  51 {
  52         return gb_svc_dme_peer_get(intf->hd->svc, intf->interface_id,
  53                                         attr, DME_SELECTOR_INDEX_NULL, val);
  54 }
  55
  56 static int gb_interface_read_ara_dme(struct gb_interface *intf)
  57 {
  58         u32 sn0, sn1;
  59         int ret;
  60
  61         /*
  62          * Unless this is a Toshiba bridge, bail out until we have defined
  63          * standard Ara attributes.
  64          */
  65         if (intf->ddbl1_manufacturer_id != TOSHIBA_DMID) {
  66                 dev_err(&intf->dev, "unknown manufacturer %08x\n",
  67                                 intf->ddbl1_manufacturer_id);
  68                 return -ENODEV;
  69         }
  70
  71         ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_ARA_VID,
  72                                         &intf->vendor_id);
  73         if (ret)
  74                 return ret;
  75
  76         ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_ARA_PID,
  77                                         &intf->product_id);
  78         if (ret)
  79                 return ret;
  80
  81         ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_ARA_SN0, &sn0);
  82         if (ret)
  83                 return ret;
  84
  85         ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_ARA_SN1, &sn1);
  86         if (ret)
  87                 return ret;
  88
  89         intf->serial_number = (u64)sn1 << 32 | sn0;
  90
  91         return 0;
  92 }
  93
  94 static int gb_interface_read_dme(struct gb_interface *intf)
  95 {
  96         int ret;
  97
  98         ret = gb_interface_dme_attr_get(intf, DME_DDBL1_MANUFACTURERID,
  99                                         &intf->ddbl1_manufacturer_id);
 100         if (ret)
 101                 return ret;
 102
 103         ret = gb_interface_dme_attr_get(intf, DME_DDBL1_PRODUCTID,
 104                                         &intf->ddbl1_product_id);
 105         if (ret)
 106                 return ret;
 107
 108         if (intf->ddbl1_manufacturer_id == TOSHIBA_DMID &&
 109                         intf->ddbl1_product_id == TOSHIBA_ES2_BRIDGE_DPID) {
 110                 intf->quirks |= GB_INTERFACE_QUIRK_NO_ARA_IDS;
 111                 intf->quirks |= GB_INTERFACE_QUIRK_NO_INIT_STATUS;
 112         }
 113
 114         return gb_interface_read_ara_dme(intf);
 115 }
 116
 117 static int gb_interface_route_create(struct gb_interface *intf)
 118 {
 119         struct gb_svc *svc = intf->hd->svc;
 120         u8 intf_id = intf->interface_id;
 121         u8 device_id;
 122         int ret;
 123
 124         /* Allocate an interface device id. */
 125         ret = ida_simple_get(&svc->device_id_map,
 126                              GB_SVC_DEVICE_ID_MIN, GB_SVC_DEVICE_ID_MAX + 1,
 127                              GFP_KERNEL);
 128         if (ret < 0) {
 129                 dev_err(&intf->dev, "failed to allocate device id: %d\n", ret);
 130                 return ret;
 131         }
 132         device_id = ret;
 133
 134         ret = gb_svc_intf_device_id(svc, intf_id, device_id);
 135         if (ret) {
 136                 dev_err(&intf->dev, "failed to set device id %u: %d\n",
 137                                 device_id, ret);
 138                 goto err_ida_remove;
 139         }
 140
 141         /* FIXME: Hard-coded AP device id. */
 142         ret = gb_svc_route_create(svc, svc->ap_intf_id, GB_SVC_DEVICE_ID_AP,
 143                                   intf_id, device_id);
 144         if (ret) {
 145                 dev_err(&intf->dev, "failed to create route: %d\n", ret);
 146                 goto err_svc_id_free;
 147         }
 148
 149         intf->device_id = device_id;
 150
 151         return 0;
 152
 153 err_svc_id_free:
 154         /*
 155          * XXX Should we tell SVC that this id doesn't belong to interface
 156          * XXX anymore.
 157          */
 158 err_ida_remove:
 159         ida_simple_remove(&svc->device_id_map, device_id);
 160
 161         return ret;
 162 }
 163
 164 static void gb_interface_route_destroy(struct gb_interface *intf)
 165 {
 166         struct gb_svc *svc = intf->hd->svc;
 167
 168         if (intf->device_id == GB_INTERFACE_DEVICE_ID_BAD)
 169                 return;
 170
 171         gb_svc_route_destroy(svc, svc->ap_intf_id, intf->interface_id);
 172         ida_simple_remove(&svc->device_id_map, intf->device_id);
 173         intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
 174 }
 175
 176 /* Locking: Caller holds the interface mutex. */
 177 static int gb_interface_legacy_mode_switch(struct gb_interface *intf)
 178 {
 179         int ret;
 180
 181         dev_info(&intf->dev, "legacy mode switch detected\n");
 182
 183         /* Mark as disconnected to prevent I/O during disable. */
 184         intf->disconnected = true;
 185         gb_interface_disable(intf);
 186         intf->disconnected = false;
 187
 188         ret = gb_interface_enable(intf);
 189         if (ret) {
 190                 dev_err(&intf->dev, "failed to re-enable interface: %d\n", ret);
 191                 gb_interface_deactivate(intf);
 192         }
 193
 194         return ret;
 195 }
 196
 197 void gb_interface_mailbox_event(struct gb_interface *intf, u16 result,
 198                                                                 u32 mailbox)
 199 {
 200         mutex_lock(&intf->mutex);
 201
 202         if (result) {
 203                 dev_warn(&intf->dev,
 204                                 "mailbox event with UniPro error: 0x%04x\n",
 205                                 result);
 206                 goto err_disable;
 207         }
 208
 209         if (mailbox != GB_SVC_INTF_MAILBOX_GREYBUS) {
 210                 dev_warn(&intf->dev,
 211                                 "mailbox event with unexpected value: 0x%08x\n",
 212                                 mailbox);
 213                 goto err_disable;
 214         }
 215
 216         if (intf->quirks & GB_INTERFACE_QUIRK_LEGACY_MODE_SWITCH) {
 217                 gb_interface_legacy_mode_switch(intf);
 218                 goto out_unlock;
 219         }
 220
 221         if (!intf->mode_switch) {
 222                 dev_warn(&intf->dev, "unexpected mailbox event: 0x%08x\n",
 223                                 mailbox);
 224                 goto err_disable;
 225         }
 226
 227         dev_info(&intf->dev, "mode switch detected\n");
 228
 229         complete(&intf->mode_switch_completion);
 230
 231 out_unlock:
 232         mutex_unlock(&intf->mutex);
 233
 234         return;
 235
 236 err_disable:
 237         gb_interface_disable(intf);
 238         gb_interface_deactivate(intf);
 239         mutex_unlock(&intf->mutex);
 240 }
 241
 242 static void gb_interface_mode_switch_work(struct work_struct *work)
 243 {
 244         struct gb_interface *intf;
 245         struct gb_control *control;
 246         unsigned long timeout;
 247         int ret;
 248
 249         intf = container_of(work, struct gb_interface, mode_switch_work);
 250
 251         mutex_lock(&intf->mutex);
 252         /* Make sure interface is still enabled. */
 253         if (!intf->enabled) {
 254                 dev_dbg(&intf->dev, "mode switch aborted\n");
 255                 intf->mode_switch = false;
 256                 mutex_unlock(&intf->mutex);
 257                 goto out_interface_put;
 258         }
 259
 260         /*
 261          * Prepare the control device for mode switch and make sure to get an
 262          * extra reference before it goes away during interface disable.
 263          */
 264         control = gb_control_get(intf->control);
 265         gb_control_mode_switch_prepare(control);
 266         gb_interface_disable(intf);
 267         mutex_unlock(&intf->mutex);
 268
 269         timeout = msecs_to_jiffies(GB_INTERFACE_MODE_SWITCH_TIMEOUT);
 270         ret = wait_for_completion_interruptible_timeout(
 271                         &intf->mode_switch_completion, timeout);
 272
 273         /* Finalise control-connection mode switch. */
 274         gb_control_mode_switch_complete(control);
 275         gb_control_put(control);
 276
 277         if (ret < 0) {
 278                 dev_err(&intf->dev, "mode switch interrupted\n");
 279                 goto err_deactivate;
 280         } else if (ret == 0) {
 281                 dev_err(&intf->dev, "mode switch timed out\n");
 282                 goto err_deactivate;
 283         }
 284
 285         /* Re-enable (re-enumerate) interface if still active. */
 286         mutex_lock(&intf->mutex);
 287         intf->mode_switch = false;
 288         if (intf->active) {
 289                 ret = gb_interface_enable(intf);
 290                 if (ret) {
 291                         dev_err(&intf->dev, "failed to re-enable interface: %d\n",
 292                                         ret);
 293                         gb_interface_deactivate(intf);
 294                 }
 295         }
 296         mutex_unlock(&intf->mutex);
 297
 298 out_interface_put:
 299         gb_interface_put(intf);
 300
 301         return;
 302
 303 err_deactivate:
 304         mutex_lock(&intf->mutex);
 305         intf->mode_switch = false;
 306         gb_interface_deactivate(intf);
 307         mutex_unlock(&intf->mutex);
 308
 309         gb_interface_put(intf);
 310 }
 311
 312 int gb_interface_request_mode_switch(struct gb_interface *intf)
 313 {
 314         int ret = 0;
 315
 316         mutex_lock(&intf->mutex);
 317         if (intf->mode_switch) {
 318                 ret = -EBUSY;
 319                 goto out_unlock;
 320         }
 321
 322         intf->mode_switch = true;
 323         reinit_completion(&intf->mode_switch_completion);
 324
 325         /*
 326          * Get a reference to the interface device, which will be put once the
 327          * mode switch is complete.
 328          */
 329         get_device(&intf->dev);
 330
 331         if (!queue_work(system_long_wq, &intf->mode_switch_work)) {
 332                 put_device(&intf->dev);
 333                 ret = -EBUSY;
 334                 goto out_unlock;
 335         }
 336
 337 out_unlock:
 338         mutex_unlock(&intf->mutex);
 339
 340         return ret;
 341 }
 342 EXPORT_SYMBOL_GPL(gb_interface_request_mode_switch);
 343
 344 /*
 345  * T_TstSrcIncrement is written by the module on ES2 as a stand-in for the
 346  * init-status attribute DME_TOSHIBA_INIT_STATUS. The AP needs to read and
 347  * clear it after reading a non-zero value from it.
 348  *
 349  * FIXME: This is module-hardware dependent and needs to be extended for every
 350  * type of module we want to support.
 351  */
 352 static int gb_interface_read_and_clear_init_status(struct gb_interface *intf)
 353 {
 354         struct gb_host_device *hd = intf->hd;
 355         unsigned long bootrom_quirks;
 356         int ret;
 357         u32 value;
 358         u16 attr;
 359         u8 init_status;
 360
 361         /*
 362          * ES2 bridges use T_TstSrcIncrement for the init status.
 363          *
 364          * FIXME: Remove ES2 support
 365          */
 366         if (intf->quirks & GB_INTERFACE_QUIRK_NO_INIT_STATUS)
 367                 attr = DME_T_TST_SRC_INCREMENT;
 368         else
 369                 attr = DME_TOSHIBA_ARA_INIT_STATUS;
 370
 371         ret = gb_svc_dme_peer_get(hd->svc, intf->interface_id, attr,
 372                                   DME_SELECTOR_INDEX_NULL, &value);
 373         if (ret)
 374                 return ret;
 375
 376         /*
 377          * A nonzero init status indicates the module has finished
 378          * initializing.
 379          */
 380         if (!value) {
 381                 dev_err(&intf->dev, "invalid init status\n");
 382                 return -ENODEV;
 383         }
 384
 385         /*
 386          * Extract the init status.
 387          *
 388          * For ES2: We need to check lowest 8 bits of 'value'.
 389          * For ES3: We need to check highest 8 bits out of 32 of 'value'.
 390          *
 391          * FIXME: Remove ES2 support
 392          */
 393         if (intf->quirks & GB_INTERFACE_QUIRK_NO_INIT_STATUS)
 394                 init_status = value & 0xff;
 395         else
 396                 init_status = value >> 24;
 397
 398         /*
 399          * Check if the interface is executing the quirky ES3 bootrom that,
 400          * for example, requires E2EFC, CSD and CSV to be disabled.
 401          */
 402         bootrom_quirks = GB_INTERFACE_QUIRK_NO_CPORT_FEATURES |
 403                                 GB_INTERFACE_QUIRK_FORCED_DISABLE |
 404                                 GB_INTERFACE_QUIRK_LEGACY_MODE_SWITCH;
 405         switch (init_status) {
 406         case GB_INIT_BOOTROM_UNIPRO_BOOT_STARTED:
 407         case GB_INIT_BOOTROM_FALLBACK_UNIPRO_BOOT_STARTED:
 408                 intf->quirks |= bootrom_quirks;
 409                 break;
 410         default:
 411                 intf->quirks &= ~bootrom_quirks;
 412         }
 413
 414         /* Clear the init status. */
 415         return gb_svc_dme_peer_set(hd->svc, intf->interface_id, attr,
 416                                    DME_SELECTOR_INDEX_NULL, 0);
 417 }
 418
 419 /* interface sysfs attributes */
 420 #define gb_interface_attr(field, type)                                  \
 421 static ssize_t field##_show(struct device *dev,                         \
 422                             struct device_attribute *attr,              \
 423                             char *buf)                                  \
 424 {                                                                       \
 425         struct gb_interface *intf = to_gb_interface(dev);               \
 426         return scnprintf(buf, PAGE_SIZE, type"\n", intf->field);        \
 427 }                                                                       \
 428 static DEVICE_ATTR_RO(field)
 429
 430 gb_interface_attr(ddbl1_manufacturer_id, "0x%08x");
 431 gb_interface_attr(ddbl1_product_id, "0x%08x");
 432 gb_interface_attr(interface_id, "%u");
 433 gb_interface_attr(vendor_id, "0x%08x");
 434 gb_interface_attr(product_id, "0x%08x");
 435 gb_interface_attr(serial_number, "0x%016llx");
 436
 437 static ssize_t voltage_now_show(struct device *dev,
 438                                 struct device_attribute *attr, char *buf)
 439 {
 440         struct gb_interface *intf = to_gb_interface(dev);
 441         int ret;
 442         u32 measurement;
 443
 444         ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
 445                                             GB_SVC_PWRMON_TYPE_VOL,
 446                                             &measurement);
 447         if (ret) {
 448                 dev_err(&intf->dev, "failed to get voltage sample (%d)\n", ret);
 449                 return ret;
 450         }
 451
 452         return sprintf(buf, "%u\n", measurement);
 453 }
 454 static DEVICE_ATTR_RO(voltage_now);
 455
 456 static ssize_t current_now_show(struct device *dev,
 457                                 struct device_attribute *attr, char *buf)
 458 {
 459         struct gb_interface *intf = to_gb_interface(dev);
 460         int ret;
 461         u32 measurement;
 462
 463         ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
 464                                             GB_SVC_PWRMON_TYPE_CURR,
 465                                             &measurement);
 466         if (ret) {
 467                 dev_err(&intf->dev, "failed to get current sample (%d)\n", ret);
 468                 return ret;
 469         }
 470
 471         return sprintf(buf, "%u\n", measurement);
 472 }
 473 static DEVICE_ATTR_RO(current_now);
 474
 475 static ssize_t power_now_show(struct device *dev,
 476                               struct device_attribute *attr, char *buf)
 477 {
 478         struct gb_interface *intf = to_gb_interface(dev);
 479         int ret;
 480         u32 measurement;
 481
 482         ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
 483                                             GB_SVC_PWRMON_TYPE_PWR,
 484                                             &measurement);
 485         if (ret) {
 486                 dev_err(&intf->dev, "failed to get power sample (%d)\n", ret);
 487                 return ret;
 488         }
 489
 490         return sprintf(buf, "%u\n", measurement);
 491 }
 492 static DEVICE_ATTR_RO(power_now);
 493
 494 static struct attribute *interface_attrs[] = {
 495         &dev_attr_ddbl1_manufacturer_id.attr,
 496         &dev_attr_ddbl1_product_id.attr,
 497         &dev_attr_interface_id.attr,
 498         &dev_attr_vendor_id.attr,
 499         &dev_attr_product_id.attr,
 500         &dev_attr_serial_number.attr,
 501         &dev_attr_voltage_now.attr,
 502         &dev_attr_current_now.attr,
 503         &dev_attr_power_now.attr,
 504         NULL,
 505 };
 506 ATTRIBUTE_GROUPS(interface);
 507
 508 static void gb_interface_release(struct device *dev)
 509 {
 510         struct gb_interface *intf = to_gb_interface(dev);
 511
 512         trace_gb_interface_release(intf);
 513
 514         kfree(intf);
 515 }
 516
 517 #ifdef CONFIG_PM_RUNTIME
 518 static int gb_interface_suspend(struct device *dev)
 519 {
 520         struct gb_interface *intf = to_gb_interface(dev);
 521         int ret, timesync_ret;
 522
 523         ret = gb_control_interface_suspend_prepare(intf->control);
 524         if (ret)
 525                 return ret;
 526
 527         gb_timesync_interface_remove(intf);
 528
 529         ret = gb_control_suspend(intf->control);
 530         if (ret)
 531                 goto err_hibernate_abort;
 532
 533         ret = gb_interface_hibernate_link(intf);
 534         if (ret)
 535                 return ret;
 536
 537         /* Delay to allow interface to enter standby before disabling refclk */
 538         msleep(GB_INTERFACE_SUSPEND_HIBERNATE_DELAY_MS);
 539
 540         ret = gb_interface_refclk_set(intf, false);
 541         if (ret)
 542                 return ret;
 543
 544         return 0;
 545
 546 err_hibernate_abort:
 547         gb_control_interface_hibernate_abort(intf->control);
 548
 549         timesync_ret = gb_timesync_interface_add(intf);
 550         if (timesync_ret) {
 551                 dev_err(dev, "failed to add to timesync: %d\n", timesync_ret);
 552                 return timesync_ret;
 553         }
 554
 555         return ret;
 556 }
 557
 558 static int gb_interface_resume(struct device *dev)
 559 {
 560         struct gb_interface *intf = to_gb_interface(dev);
 561         struct gb_svc *svc = intf->hd->svc;
 562         int ret;
 563
 564         ret = gb_interface_refclk_set(intf, true);
 565         if (ret)
 566                 return ret;
 567
 568         ret = gb_svc_intf_resume(svc, intf->interface_id);
 569         if (ret)
 570                 return ret;
 571
 572         ret = gb_control_resume(intf->control);
 573         if (ret)
 574                 return ret;
 575
 576         ret = gb_timesync_interface_add(intf);
 577         if (ret) {
 578                 dev_err(dev, "failed to add to timesync: %d\n", ret);
 579                 return ret;
 580         }
 581
 582         ret = gb_timesync_schedule_synchronous(intf);
 583         if (ret) {
 584                 dev_err(dev, "failed to synchronize FrameTime: %d\n", ret);
 585                 return ret;
 586         }
 587
 588         return 0;
 589 }
 590
 591 static int gb_interface_runtime_idle(struct device *dev)
 592 {
 593         pm_runtime_mark_last_busy(dev);
 594         pm_request_autosuspend(dev);
 595
 596         return 0;
 597 }
 598 #endif
 599
 600 static const struct dev_pm_ops gb_interface_pm_ops = {
 601         SET_RUNTIME_PM_OPS(gb_interface_suspend, gb_interface_resume,
 602                            gb_interface_runtime_idle)
 603 };
 604
 605 struct device_type greybus_interface_type = {
 606         .name =         "greybus_interface",
 607         .release =      gb_interface_release,
 608         .pm =           &gb_interface_pm_ops,
 609 };
 610
 611 /*
 612  * A Greybus module represents a user-replaceable component on an Ara
 613  * phone.  An interface is the physical connection on that module.  A
 614  * module may have more than one interface.
 615  *
 616  * Create a gb_interface structure to represent a discovered interface.
 617  * The position of interface within the Endo is encoded in "interface_id"
 618  * argument.
 619  *
 620  * Returns a pointer to the new interfce or a null pointer if a
 621  * failure occurs due to memory exhaustion.
 622  */
 623 struct gb_interface *gb_interface_create(struct gb_module *module,
 624                                          u8 interface_id)
 625 {
 626         struct gb_host_device *hd = module->hd;
 627         struct gb_interface *intf;
 628
 629         intf = kzalloc(sizeof(*intf), GFP_KERNEL);
 630         if (!intf)
 631                 return NULL;
 632
 633         intf->hd = hd;          /* XXX refcount? */
 634         intf->module = module;
 635         intf->interface_id = interface_id;
 636         INIT_LIST_HEAD(&intf->bundles);
 637         INIT_LIST_HEAD(&intf->manifest_descs);
 638         mutex_init(&intf->mutex);
 639         INIT_WORK(&intf->mode_switch_work, gb_interface_mode_switch_work);
 640         init_completion(&intf->mode_switch_completion);
 641
 642         /* Invalid device id to start with */
 643         intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
 644
 645         intf->dev.parent = &module->dev;
 646         intf->dev.bus = &greybus_bus_type;
 647         intf->dev.type = &greybus_interface_type;
 648         intf->dev.groups = interface_groups;
 649         intf->dev.dma_mask = module->dev.dma_mask;
 650         device_initialize(&intf->dev);
 651         dev_set_name(&intf->dev, "%s.%u", dev_name(&module->dev),
 652                         interface_id);
 653
 654         pm_runtime_set_autosuspend_delay(&intf->dev,
 655                                          GB_INTERFACE_AUTOSUSPEND_MS);
 656
 657         trace_gb_interface_create(intf);
 658
 659         return intf;
 660 }
 661
 662 static int gb_interface_vsys_set(struct gb_interface *intf, bool enable)
 663 {
 664         struct gb_svc *svc = intf->hd->svc;
 665         int ret;
 666
 667         dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
 668
 669         ret = gb_svc_intf_vsys_set(svc, intf->interface_id, enable);
 670         if (ret) {
 671                 dev_err(&intf->dev, "failed to set v_sys: %d\n", ret);
 672                 return ret;
 673         }
 674
 675         return 0;
 676 }
 677
 678 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable)
 679 {
 680         struct gb_svc *svc = intf->hd->svc;
 681         int ret;
 682
 683         dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
 684
 685         ret = gb_svc_intf_refclk_set(svc, intf->interface_id, enable);
 686         if (ret) {
 687                 dev_err(&intf->dev, "failed to set refclk: %d\n", ret);
 688                 return ret;
 689         }
 690
 691         return 0;
 692 }
 693
 694 static int gb_interface_unipro_set(struct gb_interface *intf, bool enable)
 695 {
 696         struct gb_svc *svc = intf->hd->svc;
 697         int ret;
 698
 699         dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
 700
 701         ret = gb_svc_intf_unipro_set(svc, intf->interface_id, enable);
 702         if (ret) {
 703                 dev_err(&intf->dev, "failed to set UniPro: %d\n", ret);
 704                 return ret;
 705         }
 706
 707         return 0;
 708 }
 709
 710 static int gb_interface_activate_operation(struct gb_interface *intf)
 711 {
 712         struct gb_svc *svc = intf->hd->svc;
 713         u8 type;
 714         int ret;
 715
 716         dev_dbg(&intf->dev, "%s\n", __func__);
 717
 718         ret = gb_svc_intf_activate(svc, intf->interface_id, &type);
 719         if (ret) {
 720                 dev_err(&intf->dev, "failed to activate: %d\n", ret);
 721                 return ret;
 722         }
 723
 724         switch (type) {
 725         case GB_SVC_INTF_TYPE_DUMMY:
 726                 dev_info(&intf->dev, "dummy interface detected\n");
 727                 /* FIXME: handle as an error for now */
 728                 return -ENODEV;
 729         case GB_SVC_INTF_TYPE_UNIPRO:
 730                 dev_err(&intf->dev, "interface type UniPro not supported\n");
 731                 /* FIXME: check if this is a Toshiba bridge before retrying? */
 732                 return -EAGAIN;
 733         case GB_SVC_INTF_TYPE_GREYBUS:
 734                 break;
 735         default:
 736                 dev_err(&intf->dev, "unknown interface type: %u\n", type);
 737                 return -ENODEV;
 738         }
 739
 740         return 0;
 741 }
 742
 743 static int gb_interface_hibernate_link(struct gb_interface *intf)
 744 {
 745         struct gb_svc *svc = intf->hd->svc;
 746
 747         return gb_svc_intf_set_power_mode_hibernate(svc, intf->interface_id);
 748 }
 749
 750 /*
 751  * Activate an interface.
 752  *
 753  * Locking: Caller holds the interface mutex.
 754  */
 755 int gb_interface_activate(struct gb_interface *intf)
 756 {
 757         int ret;
 758
 759         if (intf->ejected)
 760                 return -ENODEV;
 761
 762         ret = gb_interface_vsys_set(intf, true);
 763         if (ret)
 764                 return ret;
 765
 766         ret = gb_interface_refclk_set(intf, true);
 767         if (ret)
 768                 goto err_vsys_disable;
 769
 770         ret = gb_interface_unipro_set(intf, true);
 771         if (ret)
 772                 goto err_refclk_disable;
 773
 774         ret = gb_interface_activate_operation(intf);
 775         if (ret)
 776                 goto err_unipro_disable;
 777
 778         ret = gb_interface_read_dme(intf);
 779         if (ret)
 780                 goto err_hibernate_link;
 781
 782         ret = gb_interface_route_create(intf);
 783         if (ret)
 784                 goto err_hibernate_link;
 785
 786         intf->active = true;
 787
 788         trace_gb_interface_activate(intf);
 789
 790         return 0;
 791
 792 err_hibernate_link:
 793         gb_interface_hibernate_link(intf);
 794 err_unipro_disable:
 795         gb_interface_unipro_set(intf, false);
 796 err_refclk_disable:
 797         gb_interface_refclk_set(intf, false);
 798 err_vsys_disable:
 799         gb_interface_vsys_set(intf, false);
 800
 801         return ret;
 802 }
 803
 804 /*
 805  * Deactivate an interface.
 806  *
 807  * Locking: Caller holds the interface mutex.
 808  */
 809 void gb_interface_deactivate(struct gb_interface *intf)
 810 {
 811         if (!intf->active)
 812                 return;
 813
 814         trace_gb_interface_deactivate(intf);
 815
 816         /* Abort any ongoing mode switch. */
 817         if (intf->mode_switch)
 818                 complete(&intf->mode_switch_completion);
 819
 820         gb_interface_route_destroy(intf);
 821         gb_interface_hibernate_link(intf);
 822         gb_interface_unipro_set(intf, false);
 823         gb_interface_refclk_set(intf, false);
 824         gb_interface_vsys_set(intf, false);
 825
 826         intf->active = false;
 827 }
 828
 829 /*
 830  * Enable an interface by enabling its control connection, fetching the
 831  * manifest and other information over it, and finally registering its child
 832  * devices.
 833  *
 834  * Locking: Caller holds the interface mutex.
 835  */
 836 int gb_interface_enable(struct gb_interface *intf)
 837 {
 838         struct gb_control *control;
 839         struct gb_bundle *bundle, *tmp;
 840         int ret, size;
 841         void *manifest;
 842
 843         ret = gb_interface_read_and_clear_init_status(intf);
 844         if (ret) {
 845                 dev_err(&intf->dev, "failed to clear init status: %d\n", ret);
 846                 return ret;
 847         }
 848
 849         /* Establish control connection */
 850         control = gb_control_create(intf);
 851         if (IS_ERR(control)) {
 852                 dev_err(&intf->dev, "failed to create control device: %ld\n",
 853                                 PTR_ERR(control));
 854                 return PTR_ERR(control);
 855         }
 856         intf->control = control;
 857
 858         ret = gb_control_enable(intf->control);
 859         if (ret)
 860                 goto err_put_control;
 861
 862         /* Get manifest size using control protocol on CPort */
 863         size = gb_control_get_manifest_size_operation(intf);
 864         if (size <= 0) {
 865                 dev_err(&intf->dev, "failed to get manifest size: %d\n", size);
 866
 867                 if (size)
 868                         ret = size;
 869                 else
 870                         ret =  -EINVAL;
 871
 872                 goto err_disable_control;
 873         }
 874
 875         manifest = kmalloc(size, GFP_KERNEL);
 876         if (!manifest) {
 877                 ret = -ENOMEM;
 878                 goto err_disable_control;
 879         }
 880
 881         /* Get manifest using control protocol on CPort */
 882         ret = gb_control_get_manifest_operation(intf, manifest, size);
 883         if (ret) {
 884                 dev_err(&intf->dev, "failed to get manifest: %d\n", ret);
 885                 goto err_free_manifest;
 886         }
 887
 888         /*
 889          * Parse the manifest and build up our data structures representing
 890          * what's in it.
 891          */
 892         if (!gb_manifest_parse(intf, manifest, size)) {
 893                 dev_err(&intf->dev, "failed to parse manifest\n");
 894                 ret = -EINVAL;
 895                 goto err_destroy_bundles;
 896         }
 897
 898         ret = gb_control_get_bundle_versions(intf->control);
 899         if (ret)
 900                 goto err_destroy_bundles;
 901
 902         /* Register the control device and any bundles */
 903         ret = gb_control_add(intf->control);
 904         if (ret)
 905                 goto err_destroy_bundles;
 906
 907         ret = gb_timesync_interface_add(intf);
 908         if (ret) {
 909                 dev_err(&intf->dev, "failed to add to timesync: %d\n", ret);
 910                 goto err_destroy_bundles;
 911         }
 912
 913         pm_runtime_use_autosuspend(&intf->dev);
 914         pm_runtime_get_noresume(&intf->dev);
 915         pm_runtime_set_active(&intf->dev);
 916         pm_runtime_enable(&intf->dev);
 917
 918         list_for_each_entry_safe_reverse(bundle, tmp, &intf->bundles, links) {
 919                 ret = gb_bundle_add(bundle);
 920                 if (ret) {
 921                         gb_bundle_destroy(bundle);
 922                         continue;
 923                 }
 924         }
 925
 926         kfree(manifest);
 927
 928         intf->enabled = true;
 929
 930         pm_runtime_put(&intf->dev);
 931
 932         trace_gb_interface_enable(intf);
 933
 934         return 0;
 935
 936 err_destroy_bundles:
 937         list_for_each_entry_safe(bundle, tmp, &intf->bundles, links)
 938                 gb_bundle_destroy(bundle);
 939 err_free_manifest:
 940         kfree(manifest);
 941 err_disable_control:
 942         gb_control_disable(intf->control);
 943 err_put_control:
 944         gb_control_put(intf->control);
 945         intf->control = NULL;
 946
 947         return ret;
 948 }
 949
 950 /*
 951  * Disable an interface and destroy its bundles.
 952  *
 953  * Locking: Caller holds the interface mutex.
 954  */
 955 void gb_interface_disable(struct gb_interface *intf)
 956 {
 957         struct gb_bundle *bundle;
 958         struct gb_bundle *next;
 959
 960         if (!intf->enabled)
 961                 return;
 962
 963         trace_gb_interface_disable(intf);
 964
 965         pm_runtime_get_sync(&intf->dev);
 966
 967         /* Set disconnected flag to avoid I/O during connection tear down. */
 968         if (intf->quirks & GB_INTERFACE_QUIRK_FORCED_DISABLE)
 969                 intf->disconnected = true;
 970
 971         list_for_each_entry_safe(bundle, next, &intf->bundles, links)
 972                 gb_bundle_destroy(bundle);
 973
 974         if (!intf->mode_switch && !intf->disconnected)
 975                 gb_control_interface_deactivate_prepare(intf->control);
 976
 977         gb_timesync_interface_remove(intf);
 978         gb_control_del(intf->control);
 979         gb_control_disable(intf->control);
 980         gb_control_put(intf->control);
 981         intf->control = NULL;
 982
 983         intf->enabled = false;
 984
 985         pm_runtime_disable(&intf->dev);
 986         pm_runtime_set_suspended(&intf->dev);
 987         pm_runtime_dont_use_autosuspend(&intf->dev);
 988         pm_runtime_put_noidle(&intf->dev);
 989 }
 990
 991 /* Enable TimeSync on an Interface control connection. */
 992 int gb_interface_timesync_enable(struct gb_interface *intf, u8 count,
 993                                  u64 frame_time, u32 strobe_delay, u32 refclk)
 994 {
 995         return gb_control_timesync_enable(intf->control, count,
 996                                           frame_time, strobe_delay,
 997                                           refclk);
 998 }
 999
1000 /* Disable TimeSync on an Interface control connection. */
1001 int gb_interface_timesync_disable(struct gb_interface *intf)
1002 {
1003         return gb_control_timesync_disable(intf->control);
1004 }
1005
1006 /* Transmit the Authoritative FrameTime via an Interface control connection. */
1007 int gb_interface_timesync_authoritative(struct gb_interface *intf,
1008                                         u64 *frame_time)
1009 {
1010         return gb_control_timesync_authoritative(intf->control,
1011                                                 frame_time);
1012 }
1013
1014 /* Register an interface. */
1015 int gb_interface_add(struct gb_interface *intf)
1016 {
1017         int ret;
1018
1019         ret = device_add(&intf->dev);
1020         if (ret) {
1021                 dev_err(&intf->dev, "failed to register interface: %d\n", ret);
1022                 return ret;
1023         }
1024
1025         trace_gb_interface_add(intf);
1026
1027         dev_info(&intf->dev, "Interface added: VID=0x%08x, PID=0x%08x\n",
1028                  intf->vendor_id, intf->product_id);
1029         dev_info(&intf->dev, "DDBL1 Manufacturer=0x%08x, Product=0x%08x\n",
1030                  intf->ddbl1_manufacturer_id, intf->ddbl1_product_id);
1031
1032         return 0;
1033 }
1034
1035 /* Deregister an interface. */
1036 void gb_interface_del(struct gb_interface *intf)
1037 {
1038         if (device_is_registered(&intf->dev)) {
1039                 trace_gb_interface_del(intf);
1040
1041                 device_del(&intf->dev);
1042                 dev_info(&intf->dev, "Interface removed\n");
1043         }
1044 }
1045
1046 void gb_interface_put(struct gb_interface *intf)
1047 {
1048         put_device(&intf->dev);
1049 }