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