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