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(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_reset(struct phy *phy)
 377 {
 378         int ret;
 379
 380         if (!phy || !phy->ops->reset)
 381                 return 0;
 382
 383         ret = phy_pm_runtime_get_sync(phy);
 384         if (ret < 0 && ret != -ENOTSUPP)
 385                 return ret;
 386
 387         mutex_lock(&phy->mutex);
 388         ret = phy->ops->reset(phy);
 389         mutex_unlock(&phy->mutex);
 390
 391         phy_pm_runtime_put(phy);
 392
 393         return ret;
 394 }
 395 EXPORT_SYMBOL_GPL(phy_reset);
 396
 397 int phy_calibrate(struct phy *phy)
 398 {
 399         int ret;
 400
 401         if (!phy || !phy->ops->calibrate)
 402                 return 0;
 403
 404         mutex_lock(&phy->mutex);
 405         ret = phy->ops->calibrate(phy);
 406         mutex_unlock(&phy->mutex);
 407
 408         return ret;
 409 }
 410 EXPORT_SYMBOL_GPL(phy_calibrate);
 411
 412 /**
 413  * phy_configure() - Changes the phy parameters
 414  * @phy: the phy returned by phy_get()
 415  * @opts: New configuration to apply
 416  *
 417  * Used to change the PHY parameters. phy_init() must have been called
 418  * on the phy. The configuration will be applied on the current phy
 419  * mode, that can be changed using phy_set_mode().
 420  *
 421  * Returns: 0 if successful, an negative error code otherwise
 422  */
 423 int phy_configure(struct phy *phy, union phy_configure_opts *opts)
 424 {
 425         int ret;
 426
 427         if (!phy)
 428                 return -EINVAL;
 429
 430         if (!phy->ops->configure)
 431                 return -EOPNOTSUPP;
 432
 433         mutex_lock(&phy->mutex);
 434         ret = phy->ops->configure(phy, opts);
 435         mutex_unlock(&phy->mutex);
 436
 437         return ret;
 438 }
 439 EXPORT_SYMBOL_GPL(phy_configure);
 440
 441 /**
 442  * phy_validate() - Checks the phy parameters
 443  * @phy: the phy returned by phy_get()
 444  * @mode: phy_mode the configuration is applicable to.
 445  * @submode: PHY submode the configuration is applicable to.
 446  * @opts: Configuration to check
 447  *
 448  * Used to check that the current set of parameters can be handled by
 449  * the phy. Implementations are free to tune the parameters passed as
 450  * arguments if needed by some implementation detail or
 451  * constraints. It will not change any actual configuration of the
 452  * PHY, so calling it as many times as deemed fit will have no side
 453  * effect.
 454  *
 455  * Returns: 0 if successful, an negative error code otherwise
 456  */
 457 int phy_validate(struct phy *phy, enum phy_mode mode, int submode,
 458                  union phy_configure_opts *opts)
 459 {
 460         int ret;
 461
 462         if (!phy)
 463                 return -EINVAL;
 464
 465         if (!phy->ops->validate)
 466                 return -EOPNOTSUPP;
 467
 468         mutex_lock(&phy->mutex);
 469         ret = phy->ops->validate(phy, mode, submode, opts);
 470         mutex_unlock(&phy->mutex);
 471
 472         return ret;
 473 }
 474 EXPORT_SYMBOL_GPL(phy_validate);
 475
 476 /**
 477  * _of_phy_get() - lookup and obtain a reference to a phy by phandle
 478  * @np: device_node for which to get the phy
 479  * @index: the index of the phy
 480  *
 481  * Returns the phy associated with the given phandle value,
 482  * after getting a refcount to it or -ENODEV if there is no such phy or
 483  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 484  * not yet loaded. This function uses of_xlate call back function provided
 485  * while registering the phy_provider to find the phy instance.
 486  */
 487 static struct phy *_of_phy_get(struct device_node *np, int index)
 488 {
 489         int ret;
 490         struct phy_provider *phy_provider;
 491         struct phy *phy = NULL;
 492         struct of_phandle_args args;
 493
 494         ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
 495                 index, &args);
 496         if (ret)
 497                 return ERR_PTR(-ENODEV);
 498
 499         /* This phy type handled by the usb-phy subsystem for now */
 500         if (of_device_is_compatible(args.np, "usb-nop-xceiv"))
 501                 return ERR_PTR(-ENODEV);
 502
 503         mutex_lock(&phy_provider_mutex);
 504         phy_provider = of_phy_provider_lookup(args.np);
 505         if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
 506                 phy = ERR_PTR(-EPROBE_DEFER);
 507                 goto out_unlock;
 508         }
 509
 510         if (!of_device_is_available(args.np)) {
 511                 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
 512                 phy = ERR_PTR(-ENODEV);
 513                 goto out_put_module;
 514         }
 515
 516         phy = phy_provider->of_xlate(phy_provider->dev, &args);
 517
 518 out_put_module:
 519         module_put(phy_provider->owner);
 520
 521 out_unlock:
 522         mutex_unlock(&phy_provider_mutex);
 523         of_node_put(args.np);
 524
 525         return phy;
 526 }
 527
 528 /**
 529  * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
 530  * @np: device_node for which to get the phy
 531  * @con_id: name of the phy from device's point of view
 532  *
 533  * Returns the phy driver, after getting a refcount to it; or
 534  * -ENODEV if there is no such phy. The caller is responsible for
 535  * calling phy_put() to release that count.
 536  */
 537 struct phy *of_phy_get(struct device_node *np, const char *con_id)
 538 {
 539         struct phy *phy = NULL;
 540         int index = 0;
 541
 542         if (con_id)
 543                 index = of_property_match_string(np, "phy-names", con_id);
 544
 545         phy = _of_phy_get(np, index);
 546         if (IS_ERR(phy))
 547                 return phy;
 548
 549         if (!try_module_get(phy->ops->owner))
 550                 return ERR_PTR(-EPROBE_DEFER);
 551
 552         get_device(&phy->dev);
 553
 554         return phy;
 555 }
 556 EXPORT_SYMBOL_GPL(of_phy_get);
 557
 558 /**
 559  * phy_put() - release the PHY
 560  * @phy: the phy returned by phy_get()
 561  *
 562  * Releases a refcount the caller received from phy_get().
 563  */
 564 void phy_put(struct phy *phy)
 565 {
 566         if (!phy || IS_ERR(phy))
 567                 return;
 568
 569         mutex_lock(&phy->mutex);
 570         if (phy->ops->release)
 571                 phy->ops->release(phy);
 572         mutex_unlock(&phy->mutex);
 573
 574         module_put(phy->ops->owner);
 575         put_device(&phy->dev);
 576 }
 577 EXPORT_SYMBOL_GPL(phy_put);
 578
 579 /**
 580  * devm_phy_put() - release the PHY
 581  * @dev: device that wants to release this phy
 582  * @phy: the phy returned by devm_phy_get()
 583  *
 584  * destroys the devres associated with this phy and invokes phy_put
 585  * to release the phy.
 586  */
 587 void devm_phy_put(struct device *dev, struct phy *phy)
 588 {
 589         int r;
 590
 591         if (!phy)
 592                 return;
 593
 594         r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
 595         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 596 }
 597 EXPORT_SYMBOL_GPL(devm_phy_put);
 598
 599 /**
 600  * of_phy_simple_xlate() - returns the phy instance from phy provider
 601  * @dev: the PHY provider device
 602  * @args: of_phandle_args (not used here)
 603  *
 604  * Intended to be used by phy provider for the common case where #phy-cells is
 605  * 0. For other cases where #phy-cells is greater than '0', the phy provider
 606  * should provide a custom of_xlate function that reads the *args* and returns
 607  * the appropriate phy.
 608  */
 609 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
 610         *args)
 611 {
 612         struct phy *phy;
 613         struct class_dev_iter iter;
 614
 615         class_dev_iter_init(&iter, phy_class, NULL, NULL);
 616         while ((dev = class_dev_iter_next(&iter))) {
 617                 phy = to_phy(dev);
 618                 if (args->np != phy->dev.of_node)
 619                         continue;
 620
 621                 class_dev_iter_exit(&iter);
 622                 return phy;
 623         }
 624
 625         class_dev_iter_exit(&iter);
 626         return ERR_PTR(-ENODEV);
 627 }
 628 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
 629
 630 /**
 631  * phy_get() - lookup and obtain a reference to a phy.
 632  * @dev: device that requests this phy
 633  * @string: the phy name as given in the dt data or the name of the controller
 634  * port for non-dt case
 635  *
 636  * Returns the phy driver, after getting a refcount to it; or
 637  * -ENODEV if there is no such phy.  The caller is responsible for
 638  * calling phy_put() to release that count.
 639  */
 640 struct phy *phy_get(struct device *dev, const char *string)
 641 {
 642         int index = 0;
 643         struct phy *phy;
 644
 645         if (string == NULL) {
 646                 dev_WARN(dev, "missing string\n");
 647                 return ERR_PTR(-EINVAL);
 648         }
 649
 650         if (dev->of_node) {
 651                 index = of_property_match_string(dev->of_node, "phy-names",
 652                         string);
 653                 phy = _of_phy_get(dev->of_node, index);
 654         } else {
 655                 phy = phy_find(dev, string);
 656         }
 657         if (IS_ERR(phy))
 658                 return phy;
 659
 660         if (!try_module_get(phy->ops->owner))
 661                 return ERR_PTR(-EPROBE_DEFER);
 662
 663         get_device(&phy->dev);
 664
 665         return phy;
 666 }
 667 EXPORT_SYMBOL_GPL(phy_get);
 668
 669 /**
 670  * phy_optional_get() - lookup and obtain a reference to an optional phy.
 671  * @dev: device that requests this phy
 672  * @string: the phy name as given in the dt data or the name of the controller
 673  * port for non-dt case
 674  *
 675  * Returns the phy driver, after getting a refcount to it; or
 676  * NULL if there is no such phy.  The caller is responsible for
 677  * calling phy_put() to release that count.
 678  */
 679 struct phy *phy_optional_get(struct device *dev, const char *string)
 680 {
 681         struct phy *phy = phy_get(dev, string);
 682
 683         if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
 684                 phy = NULL;
 685
 686         return phy;
 687 }
 688 EXPORT_SYMBOL_GPL(phy_optional_get);
 689
 690 /**
 691  * devm_phy_get() - lookup and obtain a reference to a phy.
 692  * @dev: device that requests this phy
 693  * @string: the phy name as given in the dt data or phy device name
 694  * for non-dt case
 695  *
 696  * Gets the phy using phy_get(), and associates a device with it using
 697  * devres. On driver detach, release function is invoked on the devres data,
 698  * then, devres data is freed.
 699  */
 700 struct phy *devm_phy_get(struct device *dev, const char *string)
 701 {
 702         struct phy **ptr, *phy;
 703
 704         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 705         if (!ptr)
 706                 return ERR_PTR(-ENOMEM);
 707
 708         phy = phy_get(dev, string);
 709         if (!IS_ERR(phy)) {
 710                 *ptr = phy;
 711                 devres_add(dev, ptr);
 712         } else {
 713                 devres_free(ptr);
 714         }
 715
 716         return phy;
 717 }
 718 EXPORT_SYMBOL_GPL(devm_phy_get);
 719
 720 /**
 721  * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
 722  * @dev: device that requests this phy
 723  * @string: the phy name as given in the dt data or phy device name
 724  * for non-dt case
 725  *
 726  * Gets the phy using phy_get(), and associates a device with it using
 727  * devres. On driver detach, release function is invoked on the devres
 728  * data, then, devres data is freed. This differs to devm_phy_get() in
 729  * that if the phy does not exist, it is not considered an error and
 730  * -ENODEV will not be returned. Instead the NULL phy is returned,
 731  * which can be passed to all other phy consumer calls.
 732  */
 733 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
 734 {
 735         struct phy *phy = devm_phy_get(dev, string);
 736
 737         if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
 738                 phy = NULL;
 739
 740         return phy;
 741 }
 742 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
 743
 744 /**
 745  * devm_of_phy_get() - lookup and obtain a reference to a phy.
 746  * @dev: device that requests this phy
 747  * @np: node containing the phy
 748  * @con_id: name of the phy from device's point of view
 749  *
 750  * Gets the phy using of_phy_get(), and associates a device with it using
 751  * devres. On driver detach, release function is invoked on the devres data,
 752  * then, devres data is freed.
 753  */
 754 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
 755                             const char *con_id)
 756 {
 757         struct phy **ptr, *phy;
 758
 759         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 760         if (!ptr)
 761                 return ERR_PTR(-ENOMEM);
 762
 763         phy = of_phy_get(np, con_id);
 764         if (!IS_ERR(phy)) {
 765                 *ptr = phy;
 766                 devres_add(dev, ptr);
 767         } else {
 768                 devres_free(ptr);
 769         }
 770
 771         return phy;
 772 }
 773 EXPORT_SYMBOL_GPL(devm_of_phy_get);
 774
 775 /**
 776  * devm_of_phy_get_by_index() - lookup and obtain a reference to a phy by index.
 777  * @dev: device that requests this phy
 778  * @np: node containing the phy
 779  * @index: index of the phy
 780  *
 781  * Gets the phy using _of_phy_get(), then gets a refcount to it,
 782  * and associates a device with it using devres. On driver detach,
 783  * release function is invoked on the devres data,
 784  * then, devres data is freed.
 785  *
 786  */
 787 struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
 788                                      int index)
 789 {
 790         struct phy **ptr, *phy;
 791
 792         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 793         if (!ptr)
 794                 return ERR_PTR(-ENOMEM);
 795
 796         phy = _of_phy_get(np, index);
 797         if (IS_ERR(phy)) {
 798                 devres_free(ptr);
 799                 return phy;
 800         }
 801
 802         if (!try_module_get(phy->ops->owner)) {
 803                 devres_free(ptr);
 804                 return ERR_PTR(-EPROBE_DEFER);
 805         }
 806
 807         get_device(&phy->dev);
 808
 809         *ptr = phy;
 810         devres_add(dev, ptr);
 811
 812         return phy;
 813 }
 814 EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
 815
 816 /**
 817  * phy_create() - create a new phy
 818  * @dev: device that is creating the new phy
 819  * @node: device node of the phy
 820  * @ops: function pointers for performing phy operations
 821  *
 822  * Called to create a phy using phy framework.
 823  */
 824 struct phy *phy_create(struct device *dev, struct device_node *node,
 825                        const struct phy_ops *ops)
 826 {
 827         int ret;
 828         int id;
 829         struct phy *phy;
 830
 831         if (WARN_ON(!dev))
 832                 return ERR_PTR(-EINVAL);
 833
 834         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
 835         if (!phy)
 836                 return ERR_PTR(-ENOMEM);
 837
 838         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
 839         if (id < 0) {
 840                 dev_err(dev, "unable to get id\n");
 841                 ret = id;
 842                 goto free_phy;
 843         }
 844
 845         device_initialize(&phy->dev);
 846         mutex_init(&phy->mutex);
 847
 848         phy->dev.class = phy_class;
 849         phy->dev.parent = dev;
 850         phy->dev.of_node = node ?: dev->of_node;
 851         phy->id = id;
 852         phy->ops = ops;
 853
 854         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
 855         if (ret)
 856                 goto put_dev;
 857
 858         /* phy-supply */
 859         phy->pwr = regulator_get_optional(&phy->dev, "phy");
 860         if (IS_ERR(phy->pwr)) {
 861                 ret = PTR_ERR(phy->pwr);
 862                 if (ret == -EPROBE_DEFER)
 863                         goto put_dev;
 864
 865                 phy->pwr = NULL;
 866         }
 867
 868         ret = device_add(&phy->dev);
 869         if (ret)
 870                 goto put_dev;
 871
 872         if (pm_runtime_enabled(dev)) {
 873                 pm_runtime_enable(&phy->dev);
 874                 pm_runtime_no_callbacks(&phy->dev);
 875         }
 876
 877         return phy;
 878
 879 put_dev:
 880         put_device(&phy->dev);  /* calls phy_release() which frees resources */
 881         return ERR_PTR(ret);
 882
 883 free_phy:
 884         kfree(phy);
 885         return ERR_PTR(ret);
 886 }
 887 EXPORT_SYMBOL_GPL(phy_create);
 888
 889 /**
 890  * devm_phy_create() - create a new phy
 891  * @dev: device that is creating the new phy
 892  * @node: device node of the phy
 893  * @ops: function pointers for performing phy operations
 894  *
 895  * Creates a new PHY device adding it to the PHY class.
 896  * While at that, it also associates the device with the phy using devres.
 897  * On driver detach, release function is invoked on the devres data,
 898  * then, devres data is freed.
 899  */
 900 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
 901                             const struct phy_ops *ops)
 902 {
 903         struct phy **ptr, *phy;
 904
 905         ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
 906         if (!ptr)
 907                 return ERR_PTR(-ENOMEM);
 908
 909         phy = phy_create(dev, node, ops);
 910         if (!IS_ERR(phy)) {
 911                 *ptr = phy;
 912                 devres_add(dev, ptr);
 913         } else {
 914                 devres_free(ptr);
 915         }
 916
 917         return phy;
 918 }
 919 EXPORT_SYMBOL_GPL(devm_phy_create);
 920
 921 /**
 922  * phy_destroy() - destroy the phy
 923  * @phy: the phy to be destroyed
 924  *
 925  * Called to destroy the phy.
 926  */
 927 void phy_destroy(struct phy *phy)
 928 {
 929         pm_runtime_disable(&phy->dev);
 930         device_unregister(&phy->dev);
 931 }
 932 EXPORT_SYMBOL_GPL(phy_destroy);
 933
 934 /**
 935  * devm_phy_destroy() - destroy the PHY
 936  * @dev: device that wants to release this phy
 937  * @phy: the phy returned by devm_phy_get()
 938  *
 939  * destroys the devres associated with this phy and invokes phy_destroy
 940  * to destroy the phy.
 941  */
 942 void devm_phy_destroy(struct device *dev, struct phy *phy)
 943 {
 944         int r;
 945
 946         r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
 947         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 948 }
 949 EXPORT_SYMBOL_GPL(devm_phy_destroy);
 950
 951 /**
 952  * __of_phy_provider_register() - create/register phy provider with the framework
 953  * @dev: struct device of the phy provider
 954  * @children: device node containing children (if different from dev->of_node)
 955  * @owner: the module owner containing of_xlate
 956  * @of_xlate: function pointer to obtain phy instance from phy provider
 957  *
 958  * Creates struct phy_provider from dev and of_xlate function pointer.
 959  * This is used in the case of dt boot for finding the phy instance from
 960  * phy provider.
 961  *
 962  * If the PHY provider doesn't nest children directly but uses a separate
 963  * child node to contain the individual children, the @children parameter
 964  * can be used to override the default. If NULL, the default (dev->of_node)
 965  * will be used. If non-NULL, the device node must be a child (or further
 966  * descendant) of dev->of_node. Otherwise an ERR_PTR()-encoded -EINVAL
 967  * error code is returned.
 968  */
 969 struct phy_provider *__of_phy_provider_register(struct device *dev,
 970         struct device_node *children, struct module *owner,
 971         struct phy * (*of_xlate)(struct device *dev,
 972                                  struct of_phandle_args *args))
 973 {
 974         struct phy_provider *phy_provider;
 975
 976         /*
 977          * If specified, the device node containing the children must itself
 978          * be the provider's device node or a child (or further descendant)
 979          * thereof.
 980          */
 981         if (children) {
 982                 struct device_node *parent = of_node_get(children), *next;
 983
 984                 while (parent) {
 985                         if (parent == dev->of_node)
 986                                 break;
 987
 988                         next = of_get_parent(parent);
 989                         of_node_put(parent);
 990                         parent = next;
 991                 }
 992
 993                 if (!parent)
 994                         return ERR_PTR(-EINVAL);
 995
 996                 of_node_put(parent);
 997         } else {
 998                 children = dev->of_node;
 999         }
1000
1001         phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
1002         if (!phy_provider)
1003                 return ERR_PTR(-ENOMEM);
1004
1005         phy_provider->dev = dev;
1006         phy_provider->children = of_node_get(children);
1007         phy_provider->owner = owner;
1008         phy_provider->of_xlate = of_xlate;
1009
1010         mutex_lock(&phy_provider_mutex);
1011         list_add_tail(&phy_provider->list, &phy_provider_list);
1012         mutex_unlock(&phy_provider_mutex);
1013
1014         return phy_provider;
1015 }
1016 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
1017
1018 /**
1019  * __devm_of_phy_provider_register() - create/register phy provider with the
1020  * framework
1021  * @dev: struct device of the phy provider
1022  * @owner: the module owner containing of_xlate
1023  * @of_xlate: function pointer to obtain phy instance from phy provider
1024  *
1025  * Creates struct phy_provider from dev and of_xlate function pointer.
1026  * This is used in the case of dt boot for finding the phy instance from
1027  * phy provider. While at that, it also associates the device with the
1028  * phy provider using devres. On driver detach, release function is invoked
1029  * on the devres data, then, devres data is freed.
1030  */
1031 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
1032         struct device_node *children, struct module *owner,
1033         struct phy * (*of_xlate)(struct device *dev,
1034                                  struct of_phandle_args *args))
1035 {
1036         struct phy_provider **ptr, *phy_provider;
1037
1038         ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
1039         if (!ptr)
1040                 return ERR_PTR(-ENOMEM);
1041
1042         phy_provider = __of_phy_provider_register(dev, children, owner,
1043                                                   of_xlate);
1044         if (!IS_ERR(phy_provider)) {
1045                 *ptr = phy_provider;
1046                 devres_add(dev, ptr);
1047         } else {
1048                 devres_free(ptr);
1049         }
1050
1051         return phy_provider;
1052 }
1053 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
1054
1055 /**
1056  * of_phy_provider_unregister() - unregister phy provider from the framework
1057  * @phy_provider: phy provider returned by of_phy_provider_register()
1058  *
1059  * Removes the phy_provider created using of_phy_provider_register().
1060  */
1061 void of_phy_provider_unregister(struct phy_provider *phy_provider)
1062 {
1063         if (IS_ERR(phy_provider))
1064                 return;
1065
1066         mutex_lock(&phy_provider_mutex);
1067         list_del(&phy_provider->list);
1068         of_node_put(phy_provider->children);
1069         kfree(phy_provider);
1070         mutex_unlock(&phy_provider_mutex);
1071 }
1072 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
1073
1074 /**
1075  * devm_of_phy_provider_unregister() - remove phy provider from the framework
1076  * @dev: struct device of the phy provider
1077  *
1078  * destroys the devres associated with this phy provider and invokes
1079  * of_phy_provider_unregister to unregister the phy provider.
1080  */
1081 void devm_of_phy_provider_unregister(struct device *dev,
1082         struct phy_provider *phy_provider) {
1083         int r;
1084
1085         r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
1086                 phy_provider);
1087         dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
1088 }
1089 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
1090
1091 /**
1092  * phy_release() - release the phy
1093  * @dev: the dev member within phy
1094  *
1095  * When the last reference to the device is removed, it is called
1096  * from the embedded kobject as release method.
1097  */
1098 static void phy_release(struct device *dev)
1099 {
1100         struct phy *phy;
1101
1102         phy = to_phy(dev);
1103         dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
1104         regulator_put(phy->pwr);
1105         ida_simple_remove(&phy_ida, phy->id);
1106         kfree(phy);
1107 }
1108
1109 static int __init phy_core_init(void)
1110 {
1111         phy_class = class_create(THIS_MODULE, "phy");
1112         if (IS_ERR(phy_class)) {
1113                 pr_err("failed to create phy class --> %ld\n",
1114                         PTR_ERR(phy_class));
1115                 return PTR_ERR(phy_class);
1116         }
1117
1118         phy_class->dev_release = phy_release;
1119
1120         return 0;
1121 }
1122 device_initcall(phy_core_init);