drivers/phy/phy-core.c

   1 /*
   2  * phy-core.c  --  Generic Phy framework.
   3  *
   4  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
   5  *
   6  * Author: Kishon Vijay Abraham I <kishon@ti.com>
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/export.h>
  16 #include <linux/module.h>
  17 #include <linux/err.h>
  18 #include <linux/device.h>
  19 #include <linux/slab.h>
  20 #include <linux/of.h>
  21 #include <linux/phy/phy.h>
  22 #include <linux/idr.h>
  23 #include <linux/pm_runtime.h>
  24 #include <linux/regulator/consumer.h>
  25
  26 static struct class *phy_class;
  27 static DEFINE_MUTEX(phy_provider_mutex);
  28 static LIST_HEAD(phy_provider_list);
  29 static LIST_HEAD(phys);
  30 static DEFINE_IDA(phy_ida);
  31
  32 static void devm_phy_release(struct device *dev, void *res)
  33 {
  34         struct phy *phy = *(struct phy **)res;
  35
  36         phy_put(phy);
  37 }
  38
  39 static void devm_phy_provider_release(struct device *dev, void *res)
  40 {
  41         struct phy_provider *phy_provider = *(struct phy_provider **)res;
  42
  43         of_phy_provider_unregister(phy_provider);
  44 }
  45
  46 static void devm_phy_consume(struct device *dev, void *res)
  47 {
  48         struct phy *phy = *(struct phy **)res;
  49
  50         phy_destroy(phy);
  51 }
  52
  53 static int devm_phy_match(struct device *dev, void *res, void *match_data)
  54 {
  55         struct phy **phy = res;
  56
  57         return *phy == match_data;
  58 }
  59
  60 /**
  61  * phy_create_lookup() - allocate and register PHY/device association
  62  * @phy: the phy of the association
  63  * @con_id: connection ID string on device
  64  * @dev_id: the device of the association
  65  *
  66  * Creates and registers phy_lookup entry.
  67  */
  68 int phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id)
  69 {
  70         struct phy_lookup *pl;
  71
  72         if (!phy || !dev_id || !con_id)
  73                 return -EINVAL;
  74
  75         pl = kzalloc(sizeof(*pl), GFP_KERNEL);
  76         if (!pl)
  77                 return -ENOMEM;
  78
  79         pl->dev_id = dev_id;
  80         pl->con_id = con_id;
  81         pl->phy = phy;
  82
  83         mutex_lock(&phy_provider_mutex);
  84         list_add_tail(&pl->node, &phys);
  85         mutex_unlock(&phy_provider_mutex);
  86
  87         return 0;
  88 }
  89 EXPORT_SYMBOL_GPL(phy_create_lookup);
  90
  91 /**
  92  * phy_remove_lookup() - find and remove PHY/device association
  93  * @phy: the phy of the association
  94  * @con_id: connection ID string on device
  95  * @dev_id: the device of the association
  96  *
  97  * Finds and unregisters phy_lookup entry that was created with
  98  * phy_create_lookup().
  99  */
 100 void phy_remove_lookup(struct phy *phy, const char *con_id, const char *dev_id)
 101 {
 102         struct phy_lookup *pl;
 103
 104         if (!phy || !dev_id || !con_id)
 105                 return;
 106
 107         mutex_lock(&phy_provider_mutex);
 108         list_for_each_entry(pl, &phys, node)
 109                 if (pl->phy == phy && !strcmp(pl->dev_id, dev_id) &&
 110                     !strcmp(pl->con_id, con_id)) {
 111                         list_del(&pl->node);
 112                         kfree(pl);
 113                         break;
 114                 }
 115         mutex_unlock(&phy_provider_mutex);
 116 }
 117 EXPORT_SYMBOL_GPL(phy_remove_lookup);
 118
 119 static struct phy *phy_find(struct device *dev, const char *con_id)
 120 {
 121         const char *dev_id = dev_name(dev);
 122         struct phy_lookup *p, *pl = NULL;
 123
 124         mutex_lock(&phy_provider_mutex);
 125         list_for_each_entry(p, &phys, node)
 126                 if (!strcmp(p->dev_id, dev_id) && !strcmp(p->con_id, con_id)) {
 127                         pl = p;
 128                         break;
 129                 }
 130         mutex_unlock(&phy_provider_mutex);
 131
 132         return pl ? pl->phy : ERR_PTR(-ENODEV);
 133 }
 134
 135 static struct phy_provider *of_phy_provider_lookup(struct device_node *node)
 136 {
 137         struct phy_provider *phy_provider;
 138         struct device_node *child;
 139
 140         list_for_each_entry(phy_provider, &phy_provider_list, list) {
 141                 if (phy_provider->dev->of_node == node)
 142                         return phy_provider;
 143
 144                 for_each_child_of_node(phy_provider->children, child)
 145                         if (child == node)
 146                                 return phy_provider;
 147         }
 148
 149         return ERR_PTR(-EPROBE_DEFER);
 150 }
 151
 152 int phy_pm_runtime_get(struct phy *phy)
 153 {
 154         int ret;
 155
 156         if (!phy)
 157                 return 0;
 158
 159         if (!pm_runtime_enabled(&phy->dev))
 160                 return -ENOTSUPP;
 161
 162         ret = pm_runtime_get(&phy->dev);
 163         if (ret < 0 && ret != -EINPROGRESS)
 164                 pm_runtime_put_noidle(&phy->dev);
 165
 166         return ret;
 167 }
 168 EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
 169
 170 int phy_pm_runtime_get_sync(struct phy *phy)
 171 {
 172         int ret;
 173
 174         if (!phy)
 175                 return 0;
 176
 177         if (!pm_runtime_enabled(&phy->dev))
 178                 return -ENOTSUPP;
 179
 180         ret = pm_runtime_get_sync(&phy->dev);
 181         if (ret < 0)
 182                 pm_runtime_put_sync(&phy->dev);
 183
 184         return ret;
 185 }
 186 EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
 187
 188 int phy_pm_runtime_put(struct phy *phy)
 189 {
 190         if (!phy)
 191                 return 0;
 192
 193         if (!pm_runtime_enabled(&phy->dev))
 194                 return -ENOTSUPP;
 195
 196         return pm_runtime_put(&phy->dev);
 197 }
 198 EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
 199
 200 int phy_pm_runtime_put_sync(struct phy *phy)
 201 {
 202         if (!phy)
 203                 return 0;
 204
 205         if (!pm_runtime_enabled(&phy->dev))
 206                 return -ENOTSUPP;
 207
 208         return pm_runtime_put_sync(&phy->dev);
 209 }
 210 EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
 211
 212 void phy_pm_runtime_allow(struct phy *phy)
 213 {
 214         if (!phy)
 215                 return;
 216
 217         if (!pm_runtime_enabled(&phy->dev))
 218                 return;
 219
 220         pm_runtime_allow(&phy->dev);
 221 }
 222 EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
 223
 224 void phy_pm_runtime_forbid(struct phy *phy)
 225 {
 226         if (!phy)
 227                 return;
 228
 229         if (!pm_runtime_enabled(&phy->dev))
 230                 return;
 231
 232         pm_runtime_forbid(&phy->dev);
 233 }
 234 EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
 235
 236 int phy_init(struct phy *phy)
 237 {
 238         int ret;
 239
 240         if (!phy)
 241                 return 0;
 242
 243         ret = phy_pm_runtime_get_sync(phy);
 244         if (ret < 0 && ret != -ENOTSUPP)
 245                 return ret;
 246         ret = 0; /* Override possible ret == -ENOTSUPP */
 247
 248         mutex_lock(&phy->mutex);
 249         if (phy->init_count == 0 && phy->ops->init) {
 250                 ret = phy->ops->init(phy);
 251                 if (ret < 0) {
 252                         dev_err(&phy->dev, "phy init failed --> %d\n", ret);
 253                         goto out;
 254                 }
 255         }
 256         ++phy->init_count;
 257
 258 out:
 259         mutex_unlock(&phy->mutex);
 260         phy_pm_runtime_put(phy);
 261         return ret;
 262 }
 263 EXPORT_SYMBOL_GPL(phy_init);
 264
 265 int phy_exit(struct phy *phy)
 266 {
 267         int ret;
 268
 269         if (!phy)
 270                 return 0;
 271
 272         ret = phy_pm_runtime_get_sync(phy);
 273         if (ret < 0 && ret != -ENOTSUPP)
 274                 return ret;
 275         ret = 0; /* Override possible ret == -ENOTSUPP */
 276
 277         mutex_lock(&phy->mutex);
 278         if (phy->init_count == 1 && phy->ops->exit) {
 279                 ret = phy->ops->exit(phy);
 280                 if (ret < 0) {
 281                         dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
 282                         goto out;
 283                 }
 284         }
 285         --phy->init_count;
 286
 287 out:
 288         mutex_unlock(&phy->mutex);
 289         phy_pm_runtime_put(phy);
 290         return ret;
 291 }
 292 EXPORT_SYMBOL_GPL(phy_exit);
 293
 294 int phy_power_on(struct phy *phy)
 295 {
 296         int ret = 0;
 297
 298         if (!phy)
 299                 goto out;
 300
 301         if (phy->pwr) {
 302                 ret = regulator_enable(phy->pwr);
 303                 if (ret)
 304                         goto out;
 305         }
 306
 307         ret = phy_pm_runtime_get_sync(phy);
 308         if (ret < 0 && ret != -ENOTSUPP)
 309                 goto err_pm_sync;
 310
 311         ret = 0; /* Override possible ret == -ENOTSUPP */
 312
 313         mutex_lock(&phy->mutex);
 314         if (phy->power_count == 0 && phy->ops->power_on) {
 315                 ret = phy->ops->power_on(phy);
 316                 if (ret < 0) {
 317                         dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
 318                         goto err_pwr_on;
 319                 }
 320         }
 321         ++phy->power_count;
 322         mutex_unlock(&phy->mutex);
 323         return 0;
 324
 325 err_pwr_on:
 326         mutex_unlock(&phy->mutex);
 327         phy_pm_runtime_put_sync(phy);
 328 err_pm_sync:
 329         if (phy->pwr)
 330                 regulator_disable(phy->pwr);
 331 out:
 332         return ret;
 333 }
 334 EXPORT_SYMBOL_GPL(phy_power_on);
 335
 336 int phy_power_off(struct phy *phy)
 337 {
 338         int ret;
 339
 340         if (!phy)
 341                 return 0;
 342
 343         mutex_lock(&phy->mutex);
 344         if (phy->power_count == 1 && phy->ops->power_off) {
 345                 ret =  phy->ops->power_off(phy);
 346                 if (ret < 0) {
 347                         dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
 348                         mutex_unlock(&phy->mutex);
 349                         return ret;
 350                 }
 351         }
 352         --phy->power_count;
 353         mutex_unlock(&phy->mutex);
 354         phy_pm_runtime_put(phy);
 355
 356         if (phy->pwr)
 357                 regulator_disable(phy->pwr);
 358
 359         return 0;
 360 }
 361 EXPORT_SYMBOL_GPL(phy_power_off);
 362
 363 int phy_set_mode_ext(struct phy *phy, enum phy_mode mode, int submode)
 364 {
 365         int ret;
 366
 367         if (!phy || !phy->ops->set_mode)
 368                 return 0;
 369
 370         mutex_lock(&phy->mutex);
 371         ret = phy->ops->set_mode(phy, mode, submode);
 372         if (!ret)
 373                 phy->attrs.mode = mode;
 374         mutex_unlock(&phy->mutex);
 375
 376         return ret;
 377 }
 378 EXPORT_SYMBOL_GPL(phy_set_mode_ext);
 379
 380 int phy_reset(struct phy *phy)
 381 {
 382         int ret;
 383
 384         if (!phy || !phy->ops->reset)
 385                 return 0;
 386
 387         ret = phy_pm_runtime_get_sync(phy);
 388         if (ret < 0 && ret != -ENOTSUPP)
 389                 return ret;
 390
 391         mutex_lock(&phy->mutex);
 392         ret = phy->ops->reset(phy);
 393         mutex_unlock(&phy->mutex);
 394
 395         phy_pm_runtime_put(phy);
 396
 397         return ret;
 398 }
 399 EXPORT_SYMBOL_GPL(phy_reset);
 400
 401 int phy_calibrate(struct phy *phy)
 402 {
 403         int ret;
 404
 405         if (!phy || !phy->ops->calibrate)
 406                 return 0;
 407
 408         mutex_lock(&phy->mutex);
 409         ret = phy->ops->calibrate(phy);
 410         mutex_unlock(&phy->mutex);
 411
 412         return ret;
 413 }
 414 EXPORT_SYMBOL_GPL(phy_calibrate);
 415
 416 /**
 417  * phy_configure() - Changes the phy parameters
 418  * @phy: the phy returned by phy_get()
 419  * @opts: New configuration to apply
 420  *
 421  * Used to change the PHY parameters. phy_init() must have been called
 422  * on the phy. The configuration will be applied on the current phy
 423  * mode, that can be changed using phy_set_mode().
 424  *
 425  * Returns: 0 if successful, an negative error code otherwise
 426  */
 427 int phy_configure(struct phy *phy, union phy_configure_opts *opts)
 428 {
 429         int ret;
 430
 431         if (!phy)
 432                 return -EINVAL;
 433
 434         if (!phy->ops->configure)
 435                 return -EOPNOTSUPP;
 436
 437         mutex_lock(&phy->mutex);
 438         ret = phy->ops->configure(phy, opts);
 439         mutex_unlock(&phy->mutex);
 440
 441         return ret;
 442 }
 443 EXPORT_SYMBOL_GPL(phy_configure);
 444
 445 /**
 446  * phy_validate() - Checks the phy parameters
 447  * @phy: the phy returned by phy_get()
 448  * @mode: phy_mode the configuration is applicable to.
 449  * @submode: PHY submode the configuration is applicable to.
 450  * @opts: Configuration to check
 451  *
 452  * Used to check that the current set of parameters can be handled by
 453  * the phy. Implementations are free to tune the parameters passed as
 454  * arguments if needed by some implementation detail or
 455  * constraints. It will not change any actual configuration of the
 456  * PHY, so calling it as many times as deemed fit will have no side
 457  * effect.
 458  *
 459  * Returns: 0 if successful, an negative error code otherwise
 460  */
 461 int phy_validate(struct phy *phy, enum phy_mode mode, int submode,
 462                  union phy_configure_opts *opts)
 463 {
 464         int ret;
 465
 466         if (!phy)
 467                 return -EINVAL;
 468
 469         if (!phy->ops->validate)
 470                 return -EOPNOTSUPP;
 471
 472         mutex_lock(&phy->mutex);
 473         ret = phy->ops->validate(phy, mode, submode, opts);
 474         mutex_unlock(&phy->mutex);
 475
 476         return ret;
 477 }
 478 EXPORT_SYMBOL_GPL(phy_validate);
 479
 480 /**
 481  * _of_phy_get() - lookup and obtain a reference to a phy by phandle
 482  * @np: device_node for which to get the phy
 483  * @index: the index of the phy
 484  *
 485  * Returns the phy associated with the given phandle value,
 486  * after getting a refcount to it or -ENODEV if there is no such phy or
 487  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 488  * not yet loaded. This function uses of_xlate call back function provided
 489  * while registering the phy_provider to find the phy instance.
 490  */
 491 static struct phy *_of_phy_get(struct device_node *np, int index)
 492 {
 493         int ret;
 494         struct phy_provider *phy_provider;
 495         struct phy *phy = NULL;
 496         struct of_phandle_args args;
 497
 498         ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
 499                 index, &args);
 500         if (ret)
 501                 return ERR_PTR(-ENODEV);
 502
 503         /* This phy type handled by the usb-phy subsystem for now */
 504         if (of_device_is_compatible(args.np, "usb-nop-xceiv"))
 505                 return ERR_PTR(-ENODEV);
 506
 507         mutex_lock(&phy_provider_mutex);
 508         phy_provider = of_phy_provider_lookup(args.np);
 509         if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
 510                 phy = ERR_PTR(-EPROBE_DEFER);
 511                 goto out_unlock;
 512         }
 513
 514         if (!of_device_is_available(args.np)) {
 515                 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
 516                 phy = ERR_PTR(-ENODEV);
 517                 goto out_put_module;
 518         }
 519
 520         phy = phy_provider->of_xlate(phy_provider->dev, &args);
 521
 522 out_put_module:
 523         module_put(phy_provider->owner);
 524
 525 out_unlock:
 526         mutex_unlock(&phy_provider_mutex);
 527         of_node_put(args.np);
 528
 529         return phy;
 530 }
 531
 532 /**
 533  * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
 534  * @np: device_node for which to get the phy
 535  * @con_id: name of the phy from device's point of view
 536  *
 537  * Returns the phy driver, after getting a refcount to it; or
 538  * -ENODEV if there is no such phy. The caller is responsible for
 539  * calling phy_put() to release that count.
 540  */
 541 struct phy *of_phy_get(struct device_node *np, const char *con_id)
 542 {
 543         struct phy *phy = NULL;
 544         int index = 0;
 545
 546         if (con_id)
 547                 index = of_property_match_string(np, "phy-names", con_id);
 548
 549         phy = _of_phy_get(np, index);
 550         if (IS_ERR(phy))
 551                 return phy;
 552
 553         if (!try_module_get(phy->ops->owner))
 554                 return ERR_PTR(-EPROBE_DEFER);
 555
 556         get_device(&phy->dev);
 557
 558         return phy;
 559 }
 560 EXPORT_SYMBOL_GPL(of_phy_get);
 561
 562 /**
 563  * phy_put() - release the PHY
 564  * @phy: the phy returned by phy_get()
 565  *
 566  * Releases a refcount the caller received from phy_get().
 567  */
 568 void phy_put(struct phy *phy)
 569 {
 570         if (!phy || IS_ERR(phy))
 571                 return;
 572
 573         mutex_lock(&phy->mutex);
 574         if (phy->ops->release)
 575                 phy->ops->release(phy);
 576         mutex_unlock(&phy->mutex);
 577
 578         module_put(phy->ops->owner);
 579         put_device(&phy->dev);
 580 }
 581 EXPORT_SYMBOL_GPL(phy_put);
 582
 583 /**
 584  * devm_phy_put() - release the PHY
 585  * @dev: device that wants to release this phy
 586  * @phy: the phy returned by devm_phy_get()
 587  *
 588  * destroys the devres associated with this phy and invokes phy_put
 589  * to release the phy.
 590  */
 591 void devm_phy_put(struct device *dev, struct phy *phy)
 592 {
 593         int r;
 594
 595         if (!phy)
 596                 return;
 597
 598         r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
 599         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 600 }
 601 EXPORT_SYMBOL_GPL(devm_phy_put);
 602
 603 /**
 604  * of_phy_simple_xlate() - returns the phy instance from phy provider
 605  * @dev: the PHY provider device
 606  * @args: of_phandle_args (not used here)
 607  *
 608  * Intended to be used by phy provider for the common case where #phy-cells is
 609  * 0. For other cases where #phy-cells is greater than '0', the phy provider
 610  * should provide a custom of_xlate function that reads the *args* and returns
 611  * the appropriate phy.
 612  */
 613 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
 614         *args)
 615 {
 616         struct phy *phy;
 617         struct class_dev_iter iter;
 618
 619         class_dev_iter_init(&iter, phy_class, NULL, NULL);
 620         while ((dev = class_dev_iter_next(&iter))) {
 621                 phy = to_phy(dev);
 622                 if (args->np != phy->dev.of_node)
 623                         continue;
 624
 625                 class_dev_iter_exit(&iter);
 626                 return phy;
 627         }
 628
 629         class_dev_iter_exit(&iter);
 630         return ERR_PTR(-ENODEV);
 631 }
 632 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
 633
 634 /**
 635  * phy_get() - lookup and obtain a reference to a phy.
 636  * @dev: device that requests this phy
 637  * @string: the phy name as given in the dt data or the name of the controller
 638  * port for non-dt case
 639  *
 640  * Returns the phy driver, after getting a refcount to it; or
 641  * -ENODEV if there is no such phy.  The caller is responsible for
 642  * calling phy_put() to release that count.
 643  */
 644 struct phy *phy_get(struct device *dev, const char *string)
 645 {
 646         int index = 0;
 647         struct phy *phy;
 648
 649         if (string == NULL) {
 650                 dev_WARN(dev, "missing string\n");
 651                 return ERR_PTR(-EINVAL);
 652         }
 653
 654         if (dev->of_node) {
 655                 index = of_property_match_string(dev->of_node, "phy-names",
 656                         string);
 657                 phy = _of_phy_get(dev->of_node, index);
 658         } else {
 659                 phy = phy_find(dev, string);
 660         }
 661         if (IS_ERR(phy))
 662                 return phy;
 663
 664         if (!try_module_get(phy->ops->owner))
 665                 return ERR_PTR(-EPROBE_DEFER);
 666
 667         get_device(&phy->dev);
 668
 669         return phy;
 670 }
 671 EXPORT_SYMBOL_GPL(phy_get);
 672
 673 /**
 674  * phy_optional_get() - lookup and obtain a reference to an optional phy.
 675  * @dev: device that requests this phy
 676  * @string: the phy name as given in the dt data or the name of the controller
 677  * port for non-dt case
 678  *
 679  * Returns the phy driver, after getting a refcount to it; or
 680  * NULL if there is no such phy.  The caller is responsible for
 681  * calling phy_put() to release that count.
 682  */
 683 struct phy *phy_optional_get(struct device *dev, const char *string)
 684 {
 685         struct phy *phy = phy_get(dev, string);
 686
 687         if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
 688                 phy = NULL;
 689
 690         return phy;
 691 }
 692 EXPORT_SYMBOL_GPL(phy_optional_get);
 693
 694 /**
 695  * devm_phy_get() - lookup and obtain a reference to a phy.
 696  * @dev: device that requests this phy
 697  * @string: the phy name as given in the dt data or phy device name
 698  * for non-dt case
 699  *
 700  * Gets the phy using phy_get(), and associates a device with it using
 701  * devres. On driver detach, release function is invoked on the devres data,
 702  * then, devres data is freed.
 703  */
 704 struct phy *devm_phy_get(struct device *dev, const char *string)
 705 {
 706         struct phy **ptr, *phy;
 707
 708         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 709         if (!ptr)
 710                 return ERR_PTR(-ENOMEM);
 711
 712         phy = phy_get(dev, string);
 713         if (!IS_ERR(phy)) {
 714                 *ptr = phy;
 715                 devres_add(dev, ptr);
 716         } else {
 717                 devres_free(ptr);
 718         }
 719
 720         return phy;
 721 }
 722 EXPORT_SYMBOL_GPL(devm_phy_get);
 723
 724 /**
 725  * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
 726  * @dev: device that requests this phy
 727  * @string: the phy name as given in the dt data or phy device name
 728  * for non-dt case
 729  *
 730  * Gets the phy using phy_get(), and associates a device with it using
 731  * devres. On driver detach, release function is invoked on the devres
 732  * data, then, devres data is freed. This differs to devm_phy_get() in
 733  * that if the phy does not exist, it is not considered an error and
 734  * -ENODEV will not be returned. Instead the NULL phy is returned,
 735  * which can be passed to all other phy consumer calls.
 736  */
 737 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
 738 {
 739         struct phy *phy = devm_phy_get(dev, string);
 740
 741         if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
 742                 phy = NULL;
 743
 744         return phy;
 745 }
 746 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
 747
 748 /**
 749  * devm_of_phy_get() - lookup and obtain a reference to a phy.
 750  * @dev: device that requests this phy
 751  * @np: node containing the phy
 752  * @con_id: name of the phy from device's point of view
 753  *
 754  * Gets the phy using of_phy_get(), and associates a device with it using
 755  * devres. On driver detach, release function is invoked on the devres data,
 756  * then, devres data is freed.
 757  */
 758 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
 759                             const char *con_id)
 760 {
 761         struct phy **ptr, *phy;
 762
 763         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 764         if (!ptr)
 765                 return ERR_PTR(-ENOMEM);
 766
 767         phy = of_phy_get(np, con_id);
 768         if (!IS_ERR(phy)) {
 769                 *ptr = phy;
 770                 devres_add(dev, ptr);
 771         } else {
 772                 devres_free(ptr);
 773         }
 774
 775         return phy;
 776 }
 777 EXPORT_SYMBOL_GPL(devm_of_phy_get);
 778
 779 /**
 780  * devm_of_phy_get_by_index() - lookup and obtain a reference to a phy by index.
 781  * @dev: device that requests this phy
 782  * @np: node containing the phy
 783  * @index: index of the phy
 784  *
 785  * Gets the phy using _of_phy_get(), then gets a refcount to it,
 786  * and associates a device with it using devres. On driver detach,
 787  * release function is invoked on the devres data,
 788  * then, devres data is freed.
 789  *
 790  */
 791 struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
 792                                      int index)
 793 {
 794         struct phy **ptr, *phy;
 795
 796         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 797         if (!ptr)
 798                 return ERR_PTR(-ENOMEM);
 799
 800         phy = _of_phy_get(np, index);
 801         if (IS_ERR(phy)) {
 802                 devres_free(ptr);
 803                 return phy;
 804         }
 805
 806         if (!try_module_get(phy->ops->owner)) {
 807                 devres_free(ptr);
 808                 return ERR_PTR(-EPROBE_DEFER);
 809         }
 810
 811         get_device(&phy->dev);
 812
 813         *ptr = phy;
 814         devres_add(dev, ptr);
 815
 816         return phy;
 817 }
 818 EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
 819
 820 /**
 821  * phy_create() - create a new phy
 822  * @dev: device that is creating the new phy
 823  * @node: device node of the phy
 824  * @ops: function pointers for performing phy operations
 825  *
 826  * Called to create a phy using phy framework.
 827  */
 828 struct phy *phy_create(struct device *dev, struct device_node *node,
 829                        const struct phy_ops *ops)
 830 {
 831         int ret;
 832         int id;
 833         struct phy *phy;
 834
 835         if (WARN_ON(!dev))
 836                 return ERR_PTR(-EINVAL);
 837
 838         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
 839         if (!phy)
 840                 return ERR_PTR(-ENOMEM);
 841
 842         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
 843         if (id < 0) {
 844                 dev_err(dev, "unable to get id\n");
 845                 ret = id;
 846                 goto free_phy;
 847         }
 848
 849         device_initialize(&phy->dev);
 850         mutex_init(&phy->mutex);
 851
 852         phy->dev.class = phy_class;
 853         phy->dev.parent = dev;
 854         phy->dev.of_node = node ?: dev->of_node;
 855         phy->id = id;
 856         phy->ops = ops;
 857
 858         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
 859         if (ret)
 860                 goto put_dev;
 861
 862         /* phy-supply */
 863         phy->pwr = regulator_get_optional(&phy->dev, "phy");
 864         if (IS_ERR(phy->pwr)) {
 865                 ret = PTR_ERR(phy->pwr);
 866                 if (ret == -EPROBE_DEFER)
 867                         goto put_dev;
 868
 869                 phy->pwr = NULL;
 870         }
 871
 872         ret = device_add(&phy->dev);
 873         if (ret)
 874                 goto put_dev;
 875
 876         if (pm_runtime_enabled(dev)) {
 877                 pm_runtime_enable(&phy->dev);
 878                 pm_runtime_no_callbacks(&phy->dev);
 879         }
 880
 881         return phy;
 882
 883 put_dev:
 884         put_device(&phy->dev);  /* calls phy_release() which frees resources */
 885         return ERR_PTR(ret);
 886
 887 free_phy:
 888         kfree(phy);
 889         return ERR_PTR(ret);
 890 }
 891 EXPORT_SYMBOL_GPL(phy_create);
 892
 893 /**
 894  * devm_phy_create() - create a new phy
 895  * @dev: device that is creating the new phy
 896  * @node: device node of the phy
 897  * @ops: function pointers for performing phy operations
 898  *
 899  * Creates a new PHY device adding it to the PHY class.
 900  * While at that, it also associates the device with the phy using devres.
 901  * On driver detach, release function is invoked on the devres data,
 902  * then, devres data is freed.
 903  */
 904 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
 905                             const struct phy_ops *ops)
 906 {
 907         struct phy **ptr, *phy;
 908
 909         ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
 910         if (!ptr)
 911                 return ERR_PTR(-ENOMEM);
 912
 913         phy = phy_create(dev, node, ops);
 914         if (!IS_ERR(phy)) {
 915                 *ptr = phy;
 916                 devres_add(dev, ptr);
 917         } else {
 918                 devres_free(ptr);
 919         }
 920
 921         return phy;
 922 }
 923 EXPORT_SYMBOL_GPL(devm_phy_create);
 924
 925 /**
 926  * phy_destroy() - destroy the phy
 927  * @phy: the phy to be destroyed
 928  *
 929  * Called to destroy the phy.
 930  */
 931 void phy_destroy(struct phy *phy)
 932 {
 933         pm_runtime_disable(&phy->dev);
 934         device_unregister(&phy->dev);
 935 }
 936 EXPORT_SYMBOL_GPL(phy_destroy);
 937
 938 /**
 939  * devm_phy_destroy() - destroy the PHY
 940  * @dev: device that wants to release this phy
 941  * @phy: the phy returned by devm_phy_get()
 942  *
 943  * destroys the devres associated with this phy and invokes phy_destroy
 944  * to destroy the phy.
 945  */
 946 void devm_phy_destroy(struct device *dev, struct phy *phy)
 947 {
 948         int r;
 949
 950         r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
 951         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 952 }
 953 EXPORT_SYMBOL_GPL(devm_phy_destroy);
 954
 955 /**
 956  * __of_phy_provider_register() - create/register phy provider with the framework
 957  * @dev: struct device of the phy provider
 958  * @children: device node containing children (if different from dev->of_node)
 959  * @owner: the module owner containing of_xlate
 960  * @of_xlate: function pointer to obtain phy instance from phy provider
 961  *
 962  * Creates struct phy_provider from dev and of_xlate function pointer.
 963  * This is used in the case of dt boot for finding the phy instance from
 964  * phy provider.
 965  *
 966  * If the PHY provider doesn't nest children directly but uses a separate
 967  * child node to contain the individual children, the @children parameter
 968  * can be used to override the default. If NULL, the default (dev->of_node)
 969  * will be used. If non-NULL, the device node must be a child (or further
 970  * descendant) of dev->of_node. Otherwise an ERR_PTR()-encoded -EINVAL
 971  * error code is returned.
 972  */
 973 struct phy_provider *__of_phy_provider_register(struct device *dev,
 974         struct device_node *children, struct module *owner,
 975         struct phy * (*of_xlate)(struct device *dev,
 976                                  struct of_phandle_args *args))
 977 {
 978         struct phy_provider *phy_provider;
 979
 980         /*
 981          * If specified, the device node containing the children must itself
 982          * be the provider's device node or a child (or further descendant)
 983          * thereof.
 984          */
 985         if (children) {
 986                 struct device_node *parent = of_node_get(children), *next;
 987
 988                 while (parent) {
 989                         if (parent == dev->of_node)
 990                                 break;
 991
 992                         next = of_get_parent(parent);
 993                         of_node_put(parent);
 994                         parent = next;
 995                 }
 996
 997                 if (!parent)
 998                         return ERR_PTR(-EINVAL);
 999
1000                 of_node_put(parent);
1001         } else {
1002                 children = dev->of_node;
1003         }
1004
1005         phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
1006         if (!phy_provider)
1007                 return ERR_PTR(-ENOMEM);
1008
1009         phy_provider->dev = dev;
1010         phy_provider->children = of_node_get(children);
1011         phy_provider->owner = owner;
1012         phy_provider->of_xlate = of_xlate;
1013
1014         mutex_lock(&phy_provider_mutex);
1015         list_add_tail(&phy_provider->list, &phy_provider_list);
1016         mutex_unlock(&phy_provider_mutex);
1017
1018         return phy_provider;
1019 }
1020 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
1021
1022 /**
1023  * __devm_of_phy_provider_register() - create/register phy provider with the
1024  * framework
1025  * @dev: struct device of the phy provider
1026  * @owner: the module owner containing of_xlate
1027  * @of_xlate: function pointer to obtain phy instance from phy provider
1028  *
1029  * Creates struct phy_provider from dev and of_xlate function pointer.
1030  * This is used in the case of dt boot for finding the phy instance from
1031  * phy provider. While at that, it also associates the device with the
1032  * phy provider using devres. On driver detach, release function is invoked
1033  * on the devres data, then, devres data is freed.
1034  */
1035 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
1036         struct device_node *children, struct module *owner,
1037         struct phy * (*of_xlate)(struct device *dev,
1038                                  struct of_phandle_args *args))
1039 {
1040         struct phy_provider **ptr, *phy_provider;
1041
1042         ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
1043         if (!ptr)
1044                 return ERR_PTR(-ENOMEM);
1045
1046         phy_provider = __of_phy_provider_register(dev, children, owner,
1047                                                   of_xlate);
1048         if (!IS_ERR(phy_provider)) {
1049                 *ptr = phy_provider;
1050                 devres_add(dev, ptr);
1051         } else {
1052                 devres_free(ptr);
1053         }
1054
1055         return phy_provider;
1056 }
1057 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
1058
1059 /**
1060  * of_phy_provider_unregister() - unregister phy provider from the framework
1061  * @phy_provider: phy provider returned by of_phy_provider_register()
1062  *
1063  * Removes the phy_provider created using of_phy_provider_register().
1064  */
1065 void of_phy_provider_unregister(struct phy_provider *phy_provider)
1066 {
1067         if (IS_ERR(phy_provider))
1068                 return;
1069
1070         mutex_lock(&phy_provider_mutex);
1071         list_del(&phy_provider->list);
1072         of_node_put(phy_provider->children);
1073         kfree(phy_provider);
1074         mutex_unlock(&phy_provider_mutex);
1075 }
1076 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
1077
1078 /**
1079  * devm_of_phy_provider_unregister() - remove phy provider from the framework
1080  * @dev: struct device of the phy provider
1081  *
1082  * destroys the devres associated with this phy provider and invokes
1083  * of_phy_provider_unregister to unregister the phy provider.
1084  */
1085 void devm_of_phy_provider_unregister(struct device *dev,
1086         struct phy_provider *phy_provider) {
1087         int r;
1088
1089         r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
1090                 phy_provider);
1091         dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
1092 }
1093 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
1094
1095 /**
1096  * phy_release() - release the phy
1097  * @dev: the dev member within phy
1098  *
1099  * When the last reference to the device is removed, it is called
1100  * from the embedded kobject as release method.
1101  */
1102 static void phy_release(struct device *dev)
1103 {
1104         struct phy *phy;
1105
1106         phy = to_phy(dev);
1107         dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
1108         regulator_put(phy->pwr);
1109         ida_simple_remove(&phy_ida, phy->id);
1110         kfree(phy);
1111 }
1112
1113 static int __init phy_core_init(void)
1114 {
1115         phy_class = class_create(THIS_MODULE, "phy");
1116         if (IS_ERR(phy_class)) {
1117                 pr_err("failed to create phy class --> %ld\n",
1118                         PTR_ERR(phy_class));
1119                 return PTR_ERR(phy_class);
1120         }
1121
1122         phy_class->dev_release = phy_release;
1123
1124         return 0;
1125 }
1126 device_initcall(phy_core_init);