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 const char *gb_interface_type_string(struct gb_interface *intf)
 495 {
 496         static const char * const types[] = {
 497                 [GB_INTERFACE_TYPE_INVALID] = "invalid",
 498                 [GB_INTERFACE_TYPE_UNKNOWN] = "unknown",
 499                 [GB_INTERFACE_TYPE_DUMMY] = "dummy",
 500                 [GB_INTERFACE_TYPE_UNIPRO] = "unipro",
 501                 [GB_INTERFACE_TYPE_GREYBUS] = "greybus",
 502         };
 503
 504         return types[intf->type];
 505 }
 506
 507 static ssize_t interface_type_show(struct device *dev,
 508                                    struct device_attribute *attr, char *buf)
 509 {
 510         struct gb_interface *intf = to_gb_interface(dev);
 511
 512         return sprintf(buf, "%s\n", gb_interface_type_string(intf));
 513 }
 514 static DEVICE_ATTR_RO(interface_type);
 515
 516 static struct attribute *interface_unipro_attrs[] = {
 517         &dev_attr_ddbl1_manufacturer_id.attr,
 518         &dev_attr_ddbl1_product_id.attr,
 519         NULL
 520 };
 521
 522 static struct attribute *interface_greybus_attrs[] = {
 523         &dev_attr_interface_id.attr,
 524         &dev_attr_vendor_id.attr,
 525         &dev_attr_product_id.attr,
 526         &dev_attr_serial_number.attr,
 527         NULL
 528 };
 529
 530 static struct attribute *interface_power_attrs[] = {
 531         &dev_attr_voltage_now.attr,
 532         &dev_attr_current_now.attr,
 533         &dev_attr_power_now.attr,
 534         NULL
 535 };
 536
 537 static struct attribute *interface_common_attrs[] = {
 538         &dev_attr_interface_type.attr,
 539         NULL
 540 };
 541
 542 static umode_t interface_unipro_is_visible(struct kobject *kobj,
 543                                                 struct attribute *attr, int n)
 544 {
 545         struct device *dev = container_of(kobj, struct device, kobj);
 546         struct gb_interface *intf = to_gb_interface(dev);
 547
 548         switch (intf->type) {
 549         case GB_INTERFACE_TYPE_UNIPRO:
 550         case GB_INTERFACE_TYPE_GREYBUS:
 551                 return attr->mode;
 552         default:
 553                 return 0;
 554         }
 555 }
 556
 557 static umode_t interface_greybus_is_visible(struct kobject *kobj,
 558                                                 struct attribute *attr, int n)
 559 {
 560         struct device *dev = container_of(kobj, struct device, kobj);
 561         struct gb_interface *intf = to_gb_interface(dev);
 562
 563         switch (intf->type) {
 564         case GB_INTERFACE_TYPE_GREYBUS:
 565                 return attr->mode;
 566         default:
 567                 return 0;
 568         }
 569 }
 570
 571 static umode_t interface_power_is_visible(struct kobject *kobj,
 572                                                 struct attribute *attr, int n)
 573 {
 574         struct device *dev = container_of(kobj, struct device, kobj);
 575         struct gb_interface *intf = to_gb_interface(dev);
 576
 577         switch (intf->type) {
 578         case GB_INTERFACE_TYPE_UNIPRO:
 579         case GB_INTERFACE_TYPE_GREYBUS:
 580                 return attr->mode;
 581         default:
 582                 return 0;
 583         }
 584 }
 585
 586 static const struct attribute_group interface_unipro_group = {
 587         .is_visible     = interface_unipro_is_visible,
 588         .attrs          = interface_unipro_attrs,
 589 };
 590
 591 static const struct attribute_group interface_greybus_group = {
 592         .is_visible     = interface_greybus_is_visible,
 593         .attrs          = interface_greybus_attrs,
 594 };
 595
 596 static const struct attribute_group interface_power_group = {
 597         .is_visible     = interface_power_is_visible,
 598         .attrs          = interface_power_attrs,
 599 };
 600
 601 static const struct attribute_group interface_common_group = {
 602         .attrs          = interface_common_attrs,
 603 };
 604
 605 static const struct attribute_group *interface_groups[] = {
 606         &interface_unipro_group,
 607         &interface_greybus_group,
 608         &interface_power_group,
 609         &interface_common_group,
 610         NULL
 611 };
 612
 613 static void gb_interface_release(struct device *dev)
 614 {
 615         struct gb_interface *intf = to_gb_interface(dev);
 616
 617         trace_gb_interface_release(intf);
 618
 619         kfree(intf);
 620 }
 621
 622 #ifdef CONFIG_PM_RUNTIME
 623 static int gb_interface_suspend(struct device *dev)
 624 {
 625         struct gb_interface *intf = to_gb_interface(dev);
 626         int ret, timesync_ret;
 627
 628         ret = gb_control_interface_suspend_prepare(intf->control);
 629         if (ret)
 630                 return ret;
 631
 632         gb_timesync_interface_remove(intf);
 633
 634         ret = gb_control_suspend(intf->control);
 635         if (ret)
 636                 goto err_hibernate_abort;
 637
 638         ret = gb_interface_hibernate_link(intf);
 639         if (ret)
 640                 return ret;
 641
 642         /* Delay to allow interface to enter standby before disabling refclk */
 643         msleep(GB_INTERFACE_SUSPEND_HIBERNATE_DELAY_MS);
 644
 645         ret = gb_interface_refclk_set(intf, false);
 646         if (ret)
 647                 return ret;
 648
 649         return 0;
 650
 651 err_hibernate_abort:
 652         gb_control_interface_hibernate_abort(intf->control);
 653
 654         timesync_ret = gb_timesync_interface_add(intf);
 655         if (timesync_ret) {
 656                 dev_err(dev, "failed to add to timesync: %d\n", timesync_ret);
 657                 return timesync_ret;
 658         }
 659
 660         return ret;
 661 }
 662
 663 static int gb_interface_resume(struct device *dev)
 664 {
 665         struct gb_interface *intf = to_gb_interface(dev);
 666         struct gb_svc *svc = intf->hd->svc;
 667         int ret;
 668
 669         ret = gb_interface_refclk_set(intf, true);
 670         if (ret)
 671                 return ret;
 672
 673         ret = gb_svc_intf_resume(svc, intf->interface_id);
 674         if (ret)
 675                 return ret;
 676
 677         ret = gb_control_resume(intf->control);
 678         if (ret)
 679                 return ret;
 680
 681         ret = gb_timesync_interface_add(intf);
 682         if (ret) {
 683                 dev_err(dev, "failed to add to timesync: %d\n", ret);
 684                 return ret;
 685         }
 686
 687         ret = gb_timesync_schedule_synchronous(intf);
 688         if (ret) {
 689                 dev_err(dev, "failed to synchronize FrameTime: %d\n", ret);
 690                 return ret;
 691         }
 692
 693         return 0;
 694 }
 695
 696 static int gb_interface_runtime_idle(struct device *dev)
 697 {
 698         pm_runtime_mark_last_busy(dev);
 699         pm_request_autosuspend(dev);
 700
 701         return 0;
 702 }
 703 #endif
 704
 705 static const struct dev_pm_ops gb_interface_pm_ops = {
 706         SET_RUNTIME_PM_OPS(gb_interface_suspend, gb_interface_resume,
 707                            gb_interface_runtime_idle)
 708 };
 709
 710 struct device_type greybus_interface_type = {
 711         .name =         "greybus_interface",
 712         .release =      gb_interface_release,
 713         .pm =           &gb_interface_pm_ops,
 714 };
 715
 716 /*
 717  * A Greybus module represents a user-replaceable component on an Ara
 718  * phone.  An interface is the physical connection on that module.  A
 719  * module may have more than one interface.
 720  *
 721  * Create a gb_interface structure to represent a discovered interface.
 722  * The position of interface within the Endo is encoded in "interface_id"
 723  * argument.
 724  *
 725  * Returns a pointer to the new interfce or a null pointer if a
 726  * failure occurs due to memory exhaustion.
 727  */
 728 struct gb_interface *gb_interface_create(struct gb_module *module,
 729                                          u8 interface_id)
 730 {
 731         struct gb_host_device *hd = module->hd;
 732         struct gb_interface *intf;
 733
 734         intf = kzalloc(sizeof(*intf), GFP_KERNEL);
 735         if (!intf)
 736                 return NULL;
 737
 738         intf->hd = hd;          /* XXX refcount? */
 739         intf->module = module;
 740         intf->interface_id = interface_id;
 741         INIT_LIST_HEAD(&intf->bundles);
 742         INIT_LIST_HEAD(&intf->manifest_descs);
 743         mutex_init(&intf->mutex);
 744         INIT_WORK(&intf->mode_switch_work, gb_interface_mode_switch_work);
 745         init_completion(&intf->mode_switch_completion);
 746
 747         /* Invalid device id to start with */
 748         intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
 749
 750         intf->dev.parent = &module->dev;
 751         intf->dev.bus = &greybus_bus_type;
 752         intf->dev.type = &greybus_interface_type;
 753         intf->dev.groups = interface_groups;
 754         intf->dev.dma_mask = module->dev.dma_mask;
 755         device_initialize(&intf->dev);
 756         dev_set_name(&intf->dev, "%s.%u", dev_name(&module->dev),
 757                         interface_id);
 758
 759         pm_runtime_set_autosuspend_delay(&intf->dev,
 760                                          GB_INTERFACE_AUTOSUSPEND_MS);
 761
 762         trace_gb_interface_create(intf);
 763
 764         return intf;
 765 }
 766
 767 static int gb_interface_vsys_set(struct gb_interface *intf, bool enable)
 768 {
 769         struct gb_svc *svc = intf->hd->svc;
 770         int ret;
 771
 772         dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
 773
 774         ret = gb_svc_intf_vsys_set(svc, intf->interface_id, enable);
 775         if (ret) {
 776                 dev_err(&intf->dev, "failed to set v_sys: %d\n", ret);
 777                 return ret;
 778         }
 779
 780         return 0;
 781 }
 782
 783 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable)
 784 {
 785         struct gb_svc *svc = intf->hd->svc;
 786         int ret;
 787
 788         dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
 789
 790         ret = gb_svc_intf_refclk_set(svc, intf->interface_id, enable);
 791         if (ret) {
 792                 dev_err(&intf->dev, "failed to set refclk: %d\n", ret);
 793                 return ret;
 794         }
 795
 796         return 0;
 797 }
 798
 799 static int gb_interface_unipro_set(struct gb_interface *intf, bool enable)
 800 {
 801         struct gb_svc *svc = intf->hd->svc;
 802         int ret;
 803
 804         dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
 805
 806         ret = gb_svc_intf_unipro_set(svc, intf->interface_id, enable);
 807         if (ret) {
 808                 dev_err(&intf->dev, "failed to set UniPro: %d\n", ret);
 809                 return ret;
 810         }
 811
 812         return 0;
 813 }
 814
 815 static int gb_interface_activate_operation(struct gb_interface *intf)
 816 {
 817         struct gb_svc *svc = intf->hd->svc;
 818         u8 type;
 819         int ret;
 820
 821         dev_dbg(&intf->dev, "%s\n", __func__);
 822
 823         ret = gb_svc_intf_activate(svc, intf->interface_id, &type);
 824         if (ret) {
 825                 dev_err(&intf->dev, "failed to activate: %d\n", ret);
 826                 return ret;
 827         }
 828
 829         switch (type) {
 830         case GB_SVC_INTF_TYPE_DUMMY:
 831                 intf->type = GB_INTERFACE_TYPE_DUMMY;
 832                 /* FIXME: handle as an error for now */
 833                 return -ENODEV;
 834         case GB_SVC_INTF_TYPE_UNIPRO:
 835                 intf->type = GB_INTERFACE_TYPE_UNIPRO;
 836                 dev_err(&intf->dev, "interface type UniPro not supported\n");
 837                 /* FIXME: check if this is a Toshiba bridge before retrying? */
 838                 return -EAGAIN;
 839         case GB_SVC_INTF_TYPE_GREYBUS:
 840                 intf->type = GB_INTERFACE_TYPE_GREYBUS;
 841                 break;
 842         default:
 843                 dev_err(&intf->dev, "unknown interface type: %u\n", type);
 844                 intf->type = GB_INTERFACE_TYPE_UNKNOWN;
 845                 return -ENODEV;
 846         }
 847
 848         return 0;
 849 }
 850
 851 static int gb_interface_hibernate_link(struct gb_interface *intf)
 852 {
 853         struct gb_svc *svc = intf->hd->svc;
 854
 855         return gb_svc_intf_set_power_mode_hibernate(svc, intf->interface_id);
 856 }
 857
 858 /*
 859  * Activate an interface.
 860  *
 861  * Locking: Caller holds the interface mutex.
 862  */
 863 int gb_interface_activate(struct gb_interface *intf)
 864 {
 865         int ret;
 866
 867         if (intf->ejected)
 868                 return -ENODEV;
 869
 870         ret = gb_interface_vsys_set(intf, true);
 871         if (ret)
 872                 return ret;
 873
 874         ret = gb_interface_refclk_set(intf, true);
 875         if (ret)
 876                 goto err_vsys_disable;
 877
 878         ret = gb_interface_unipro_set(intf, true);
 879         if (ret)
 880                 goto err_refclk_disable;
 881
 882         ret = gb_interface_activate_operation(intf);
 883         if (ret)
 884                 goto err_unipro_disable;
 885
 886         ret = gb_interface_read_dme(intf);
 887         if (ret)
 888                 goto err_hibernate_link;
 889
 890         ret = gb_interface_route_create(intf);
 891         if (ret)
 892                 goto err_hibernate_link;
 893
 894         intf->active = true;
 895
 896         trace_gb_interface_activate(intf);
 897
 898         return 0;
 899
 900 err_hibernate_link:
 901         gb_interface_hibernate_link(intf);
 902 err_unipro_disable:
 903         gb_interface_unipro_set(intf, false);
 904 err_refclk_disable:
 905         gb_interface_refclk_set(intf, false);
 906 err_vsys_disable:
 907         gb_interface_vsys_set(intf, false);
 908
 909         return ret;
 910 }
 911
 912 /*
 913  * Deactivate an interface.
 914  *
 915  * Locking: Caller holds the interface mutex.
 916  */
 917 void gb_interface_deactivate(struct gb_interface *intf)
 918 {
 919         if (!intf->active)
 920                 return;
 921
 922         trace_gb_interface_deactivate(intf);
 923
 924         /* Abort any ongoing mode switch. */
 925         if (intf->mode_switch)
 926                 complete(&intf->mode_switch_completion);
 927
 928         gb_interface_route_destroy(intf);
 929         gb_interface_hibernate_link(intf);
 930         gb_interface_unipro_set(intf, false);
 931         gb_interface_refclk_set(intf, false);
 932         gb_interface_vsys_set(intf, false);
 933
 934         intf->active = false;
 935 }
 936
 937 /*
 938  * Enable an interface by enabling its control connection, fetching the
 939  * manifest and other information over it, and finally registering its child
 940  * devices.
 941  *
 942  * Locking: Caller holds the interface mutex.
 943  */
 944 int gb_interface_enable(struct gb_interface *intf)
 945 {
 946         struct gb_control *control;
 947         struct gb_bundle *bundle, *tmp;
 948         int ret, size;
 949         void *manifest;
 950
 951         ret = gb_interface_read_and_clear_init_status(intf);
 952         if (ret) {
 953                 dev_err(&intf->dev, "failed to clear init status: %d\n", ret);
 954                 return ret;
 955         }
 956
 957         /* Establish control connection */
 958         control = gb_control_create(intf);
 959         if (IS_ERR(control)) {
 960                 dev_err(&intf->dev, "failed to create control device: %ld\n",
 961                                 PTR_ERR(control));
 962                 return PTR_ERR(control);
 963         }
 964         intf->control = control;
 965
 966         ret = gb_control_enable(intf->control);
 967         if (ret)
 968                 goto err_put_control;
 969
 970         /* Get manifest size using control protocol on CPort */
 971         size = gb_control_get_manifest_size_operation(intf);
 972         if (size <= 0) {
 973                 dev_err(&intf->dev, "failed to get manifest size: %d\n", size);
 974
 975                 if (size)
 976                         ret = size;
 977                 else
 978                         ret =  -EINVAL;
 979
 980                 goto err_disable_control;
 981         }
 982
 983         manifest = kmalloc(size, GFP_KERNEL);
 984         if (!manifest) {
 985                 ret = -ENOMEM;
 986                 goto err_disable_control;
 987         }
 988
 989         /* Get manifest using control protocol on CPort */
 990         ret = gb_control_get_manifest_operation(intf, manifest, size);
 991         if (ret) {
 992                 dev_err(&intf->dev, "failed to get manifest: %d\n", ret);
 993                 goto err_free_manifest;
 994         }
 995
 996         /*
 997          * Parse the manifest and build up our data structures representing
 998          * what's in it.
 999          */
1000         if (!gb_manifest_parse(intf, manifest, size)) {
1001                 dev_err(&intf->dev, "failed to parse manifest\n");
1002                 ret = -EINVAL;
1003                 goto err_destroy_bundles;
1004         }
1005
1006         ret = gb_control_get_bundle_versions(intf->control);
1007         if (ret)
1008                 goto err_destroy_bundles;
1009
1010         /* Register the control device and any bundles */
1011         ret = gb_control_add(intf->control);
1012         if (ret)
1013                 goto err_destroy_bundles;
1014
1015         ret = gb_timesync_interface_add(intf);
1016         if (ret) {
1017                 dev_err(&intf->dev, "failed to add to timesync: %d\n", ret);
1018                 goto err_destroy_bundles;
1019         }
1020
1021         pm_runtime_use_autosuspend(&intf->dev);
1022         pm_runtime_get_noresume(&intf->dev);
1023         pm_runtime_set_active(&intf->dev);
1024         pm_runtime_enable(&intf->dev);
1025
1026         list_for_each_entry_safe_reverse(bundle, tmp, &intf->bundles, links) {
1027                 ret = gb_bundle_add(bundle);
1028                 if (ret) {
1029                         gb_bundle_destroy(bundle);
1030                         continue;
1031                 }
1032         }
1033
1034         kfree(manifest);
1035
1036         intf->enabled = true;
1037
1038         pm_runtime_put(&intf->dev);
1039
1040         trace_gb_interface_enable(intf);
1041
1042         return 0;
1043
1044 err_destroy_bundles:
1045         list_for_each_entry_safe(bundle, tmp, &intf->bundles, links)
1046                 gb_bundle_destroy(bundle);
1047 err_free_manifest:
1048         kfree(manifest);
1049 err_disable_control:
1050         gb_control_disable(intf->control);
1051 err_put_control:
1052         gb_control_put(intf->control);
1053         intf->control = NULL;
1054
1055         return ret;
1056 }
1057
1058 /*
1059  * Disable an interface and destroy its bundles.
1060  *
1061  * Locking: Caller holds the interface mutex.
1062  */
1063 void gb_interface_disable(struct gb_interface *intf)
1064 {
1065         struct gb_bundle *bundle;
1066         struct gb_bundle *next;
1067
1068         if (!intf->enabled)
1069                 return;
1070
1071         trace_gb_interface_disable(intf);
1072
1073         pm_runtime_get_sync(&intf->dev);
1074
1075         /* Set disconnected flag to avoid I/O during connection tear down. */
1076         if (intf->quirks & GB_INTERFACE_QUIRK_FORCED_DISABLE)
1077                 intf->disconnected = true;
1078
1079         list_for_each_entry_safe(bundle, next, &intf->bundles, links)
1080                 gb_bundle_destroy(bundle);
1081
1082         if (!intf->mode_switch && !intf->disconnected)
1083                 gb_control_interface_deactivate_prepare(intf->control);
1084
1085         gb_timesync_interface_remove(intf);
1086         gb_control_del(intf->control);
1087         gb_control_disable(intf->control);
1088         gb_control_put(intf->control);
1089         intf->control = NULL;
1090
1091         intf->enabled = false;
1092
1093         pm_runtime_disable(&intf->dev);
1094         pm_runtime_set_suspended(&intf->dev);
1095         pm_runtime_dont_use_autosuspend(&intf->dev);
1096         pm_runtime_put_noidle(&intf->dev);
1097 }
1098
1099 /* Enable TimeSync on an Interface control connection. */
1100 int gb_interface_timesync_enable(struct gb_interface *intf, u8 count,
1101                                  u64 frame_time, u32 strobe_delay, u32 refclk)
1102 {
1103         return gb_control_timesync_enable(intf->control, count,
1104                                           frame_time, strobe_delay,
1105                                           refclk);
1106 }
1107
1108 /* Disable TimeSync on an Interface control connection. */
1109 int gb_interface_timesync_disable(struct gb_interface *intf)
1110 {
1111         return gb_control_timesync_disable(intf->control);
1112 }
1113
1114 /* Transmit the Authoritative FrameTime via an Interface control connection. */
1115 int gb_interface_timesync_authoritative(struct gb_interface *intf,
1116                                         u64 *frame_time)
1117 {
1118         return gb_control_timesync_authoritative(intf->control,
1119                                                 frame_time);
1120 }
1121
1122 /* Register an interface. */
1123 int gb_interface_add(struct gb_interface *intf)
1124 {
1125         int ret;
1126
1127         ret = device_add(&intf->dev);
1128         if (ret) {
1129                 dev_err(&intf->dev, "failed to register interface: %d\n", ret);
1130                 return ret;
1131         }
1132
1133         trace_gb_interface_add(intf);
1134
1135         dev_info(&intf->dev, "Interface added (%s)\n",
1136                         gb_interface_type_string(intf));
1137
1138         switch (intf->type) {
1139         case GB_INTERFACE_TYPE_GREYBUS:
1140                 dev_info(&intf->dev, "Ara VID=0x%08x, PID=0x%08x\n",
1141                                 intf->vendor_id, intf->product_id);
1142                 /* fall-through */
1143         case GB_INTERFACE_TYPE_UNIPRO:
1144                 dev_info(&intf->dev, "DDBL1 Manufacturer=0x%08x, Product=0x%08x\n",
1145                                 intf->ddbl1_manufacturer_id,
1146                                 intf->ddbl1_product_id);
1147                 break;
1148         default:
1149                 break;
1150         }
1151
1152         return 0;
1153 }
1154
1155 /* Deregister an interface. */
1156 void gb_interface_del(struct gb_interface *intf)
1157 {
1158         if (device_is_registered(&intf->dev)) {
1159                 trace_gb_interface_del(intf);
1160
1161                 device_del(&intf->dev);
1162                 dev_info(&intf->dev, "Interface removed\n");
1163         }
1164 }
1165
1166 void gb_interface_put(struct gb_interface *intf)
1167 {
1168         put_device(&intf->dev);
1169 }