drivers/phy/phy-core.c

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