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 <[email protected]>
   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 /**
 233  * phy_init - phy internal initialization before phy operation
 234  * @phy: the phy returned by phy_get()
 235  *
 236  * Used to allow phy's driver to perform phy internal initialization,
 237  * such as PLL block powering, clock initialization or anything that's
 238  * is required by the phy to perform the start of operation.
 239  * Must be called before phy_power_on().
 240  *
 241  * Return: %0 if successful, a negative error code otherwise
 242  */
 243 int phy_init(struct phy *phy)
 244 {
 245         int ret;
 246
 247         if (!phy)
 248                 return 0;
 249
 250         ret = phy_pm_runtime_get_sync(phy);
 251         if (ret < 0 && ret != -ENOTSUPP)
 252                 return ret;
 253         ret = 0; /* Override possible ret == -ENOTSUPP */
 254
 255         mutex_lock(&phy->mutex);
 256         if (phy->power_count > phy->init_count)
 257                 dev_warn(&phy->dev, "phy_power_on was called before phy_init\n");
 258
 259         if (phy->init_count == 0 && phy->ops->init) {
 260                 ret = phy->ops->init(phy);
 261                 if (ret < 0) {
 262                         dev_err(&phy->dev, "phy init failed --> %d\n", ret);
 263                         goto out;
 264                 }
 265         }
 266         ++phy->init_count;
 267
 268 out:
 269         mutex_unlock(&phy->mutex);
 270         phy_pm_runtime_put(phy);
 271         return ret;
 272 }
 273 EXPORT_SYMBOL_GPL(phy_init);
 274
 275 /**
 276  * phy_exit - Phy internal un-initialization
 277  * @phy: the phy returned by phy_get()
 278  *
 279  * Must be called after phy_power_off().
 280  *
 281  * Return: %0 if successful, a negative error code otherwise
 282  */
 283 int phy_exit(struct phy *phy)
 284 {
 285         int ret;
 286
 287         if (!phy)
 288                 return 0;
 289
 290         ret = phy_pm_runtime_get_sync(phy);
 291         if (ret < 0 && ret != -ENOTSUPP)
 292                 return ret;
 293         ret = 0; /* Override possible ret == -ENOTSUPP */
 294
 295         mutex_lock(&phy->mutex);
 296         if (phy->init_count == 1 && phy->ops->exit) {
 297                 ret = phy->ops->exit(phy);
 298                 if (ret < 0) {
 299                         dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
 300                         goto out;
 301                 }
 302         }
 303         --phy->init_count;
 304
 305 out:
 306         mutex_unlock(&phy->mutex);
 307         phy_pm_runtime_put(phy);
 308         return ret;
 309 }
 310 EXPORT_SYMBOL_GPL(phy_exit);
 311
 312 /**
 313  * phy_power_on - Enable the phy and enter proper operation
 314  * @phy: the phy returned by phy_get()
 315  *
 316  * Must be called after phy_init().
 317  *
 318  * Return: %0 if successful, a negative error code otherwise
 319  */
 320 int phy_power_on(struct phy *phy)
 321 {
 322         int ret = 0;
 323
 324         if (!phy)
 325                 goto out;
 326
 327         if (phy->pwr) {
 328                 ret = regulator_enable(phy->pwr);
 329                 if (ret)
 330                         goto out;
 331         }
 332
 333         ret = phy_pm_runtime_get_sync(phy);
 334         if (ret < 0 && ret != -ENOTSUPP)
 335                 goto err_pm_sync;
 336
 337         ret = 0; /* Override possible ret == -ENOTSUPP */
 338
 339         mutex_lock(&phy->mutex);
 340         if (phy->power_count == 0 && phy->ops->power_on) {
 341                 ret = phy->ops->power_on(phy);
 342                 if (ret < 0) {
 343                         dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
 344                         goto err_pwr_on;
 345                 }
 346         }
 347         ++phy->power_count;
 348         mutex_unlock(&phy->mutex);
 349         return 0;
 350
 351 err_pwr_on:
 352         mutex_unlock(&phy->mutex);
 353         phy_pm_runtime_put_sync(phy);
 354 err_pm_sync:
 355         if (phy->pwr)
 356                 regulator_disable(phy->pwr);
 357 out:
 358         return ret;
 359 }
 360 EXPORT_SYMBOL_GPL(phy_power_on);
 361
 362 /**
 363  * phy_power_off - Disable the phy.
 364  * @phy: the phy returned by phy_get()
 365  *
 366  * Must be called before phy_exit().
 367  *
 368  * Return: %0 if successful, a negative error code otherwise
 369  */
 370 int phy_power_off(struct phy *phy)
 371 {
 372         int ret;
 373
 374         if (!phy)
 375                 return 0;
 376
 377         mutex_lock(&phy->mutex);
 378         if (phy->power_count == 1 && phy->ops->power_off) {
 379                 ret =  phy->ops->power_off(phy);
 380                 if (ret < 0) {
 381                         dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
 382                         mutex_unlock(&phy->mutex);
 383                         return ret;
 384                 }
 385         }
 386         --phy->power_count;
 387         mutex_unlock(&phy->mutex);
 388         phy_pm_runtime_put(phy);
 389
 390         if (phy->pwr)
 391                 regulator_disable(phy->pwr);
 392
 393         return 0;
 394 }
 395 EXPORT_SYMBOL_GPL(phy_power_off);
 396
 397 int phy_set_mode_ext(struct phy *phy, enum phy_mode mode, int submode)
 398 {
 399         int ret;
 400
 401         if (!phy || !phy->ops->set_mode)
 402                 return 0;
 403
 404         mutex_lock(&phy->mutex);
 405         ret = phy->ops->set_mode(phy, mode, submode);
 406         if (!ret)
 407                 phy->attrs.mode = mode;
 408         mutex_unlock(&phy->mutex);
 409
 410         return ret;
 411 }
 412 EXPORT_SYMBOL_GPL(phy_set_mode_ext);
 413
 414 int phy_set_media(struct phy *phy, enum phy_media media)
 415 {
 416         int ret;
 417
 418         if (!phy || !phy->ops->set_media)
 419                 return 0;
 420
 421         mutex_lock(&phy->mutex);
 422         ret = phy->ops->set_media(phy, media);
 423         mutex_unlock(&phy->mutex);
 424
 425         return ret;
 426 }
 427 EXPORT_SYMBOL_GPL(phy_set_media);
 428
 429 int phy_set_speed(struct phy *phy, int speed)
 430 {
 431         int ret;
 432
 433         if (!phy || !phy->ops->set_speed)
 434                 return 0;
 435
 436         mutex_lock(&phy->mutex);
 437         ret = phy->ops->set_speed(phy, speed);
 438         mutex_unlock(&phy->mutex);
 439
 440         return ret;
 441 }
 442 EXPORT_SYMBOL_GPL(phy_set_speed);
 443
 444 int phy_reset(struct phy *phy)
 445 {
 446         int ret;
 447
 448         if (!phy || !phy->ops->reset)
 449                 return 0;
 450
 451         ret = phy_pm_runtime_get_sync(phy);
 452         if (ret < 0 && ret != -ENOTSUPP)
 453                 return ret;
 454
 455         mutex_lock(&phy->mutex);
 456         ret = phy->ops->reset(phy);
 457         mutex_unlock(&phy->mutex);
 458
 459         phy_pm_runtime_put(phy);
 460
 461         return ret;
 462 }
 463 EXPORT_SYMBOL_GPL(phy_reset);
 464
 465 /**
 466  * phy_calibrate() - Tunes the phy hw parameters for current configuration
 467  * @phy: the phy returned by phy_get()
 468  *
 469  * Used to calibrate phy hardware, typically by adjusting some parameters in
 470  * runtime, which are otherwise lost after host controller reset and cannot
 471  * be applied in phy_init() or phy_power_on().
 472  *
 473  * Return: %0 if successful, a negative error code otherwise
 474  */
 475 int phy_calibrate(struct phy *phy)
 476 {
 477         int ret;
 478
 479         if (!phy || !phy->ops->calibrate)
 480                 return 0;
 481
 482         mutex_lock(&phy->mutex);
 483         ret = phy->ops->calibrate(phy);
 484         mutex_unlock(&phy->mutex);
 485
 486         return ret;
 487 }
 488 EXPORT_SYMBOL_GPL(phy_calibrate);
 489
 490 /**
 491  * phy_configure() - Changes the phy parameters
 492  * @phy: the phy returned by phy_get()
 493  * @opts: New configuration to apply
 494  *
 495  * Used to change the PHY parameters. phy_init() must have been called
 496  * on the phy. The configuration will be applied on the current phy
 497  * mode, that can be changed using phy_set_mode().
 498  *
 499  * Return: %0 if successful, a negative error code otherwise
 500  */
 501 int phy_configure(struct phy *phy, union phy_configure_opts *opts)
 502 {
 503         int ret;
 504
 505         if (!phy)
 506                 return -EINVAL;
 507
 508         if (!phy->ops->configure)
 509                 return -EOPNOTSUPP;
 510
 511         mutex_lock(&phy->mutex);
 512         ret = phy->ops->configure(phy, opts);
 513         mutex_unlock(&phy->mutex);
 514
 515         return ret;
 516 }
 517 EXPORT_SYMBOL_GPL(phy_configure);
 518
 519 /**
 520  * phy_validate() - Checks the phy parameters
 521  * @phy: the phy returned by phy_get()
 522  * @mode: phy_mode the configuration is applicable to.
 523  * @submode: PHY submode the configuration is applicable to.
 524  * @opts: Configuration to check
 525  *
 526  * Used to check that the current set of parameters can be handled by
 527  * the phy. Implementations are free to tune the parameters passed as
 528  * arguments if needed by some implementation detail or
 529  * constraints. It will not change any actual configuration of the
 530  * PHY, so calling it as many times as deemed fit will have no side
 531  * effect.
 532  *
 533  * Return: %0 if successful, a negative error code otherwise
 534  */
 535 int phy_validate(struct phy *phy, enum phy_mode mode, int submode,
 536                  union phy_configure_opts *opts)
 537 {
 538         int ret;
 539
 540         if (!phy)
 541                 return -EINVAL;
 542
 543         if (!phy->ops->validate)
 544                 return -EOPNOTSUPP;
 545
 546         mutex_lock(&phy->mutex);
 547         ret = phy->ops->validate(phy, mode, submode, opts);
 548         mutex_unlock(&phy->mutex);
 549
 550         return ret;
 551 }
 552 EXPORT_SYMBOL_GPL(phy_validate);
 553
 554 /**
 555  * _of_phy_get() - lookup and obtain a reference to a phy by phandle
 556  * @np: device_node for which to get the phy
 557  * @index: the index of the phy
 558  *
 559  * Returns the phy associated with the given phandle value,
 560  * after getting a refcount to it or -ENODEV if there is no such phy or
 561  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 562  * not yet loaded. This function uses of_xlate call back function provided
 563  * while registering the phy_provider to find the phy instance.
 564  */
 565 static struct phy *_of_phy_get(struct device_node *np, int index)
 566 {
 567         int ret;
 568         struct phy_provider *phy_provider;
 569         struct phy *phy = NULL;
 570         struct of_phandle_args args;
 571
 572         ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
 573                 index, &args);
 574         if (ret)
 575                 return ERR_PTR(-ENODEV);
 576
 577         /* This phy type handled by the usb-phy subsystem for now */
 578         if (of_device_is_compatible(args.np, "usb-nop-xceiv"))
 579                 return ERR_PTR(-ENODEV);
 580
 581         mutex_lock(&phy_provider_mutex);
 582         phy_provider = of_phy_provider_lookup(args.np);
 583         if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
 584                 phy = ERR_PTR(-EPROBE_DEFER);
 585                 goto out_unlock;
 586         }
 587
 588         if (!of_device_is_available(args.np)) {
 589                 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
 590                 phy = ERR_PTR(-ENODEV);
 591                 goto out_put_module;
 592         }
 593
 594         phy = phy_provider->of_xlate(phy_provider->dev, &args);
 595
 596 out_put_module:
 597         module_put(phy_provider->owner);
 598
 599 out_unlock:
 600         mutex_unlock(&phy_provider_mutex);
 601         of_node_put(args.np);
 602
 603         return phy;
 604 }
 605
 606 /**
 607  * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
 608  * @np: device_node for which to get the phy
 609  * @con_id: name of the phy from device's point of view
 610  *
 611  * Returns the phy driver, after getting a refcount to it; or
 612  * -ENODEV if there is no such phy. The caller is responsible for
 613  * calling phy_put() to release that count.
 614  */
 615 struct phy *of_phy_get(struct device_node *np, const char *con_id)
 616 {
 617         struct phy *phy = NULL;
 618         int index = 0;
 619
 620         if (con_id)
 621                 index = of_property_match_string(np, "phy-names", con_id);
 622
 623         phy = _of_phy_get(np, index);
 624         if (IS_ERR(phy))
 625                 return phy;
 626
 627         if (!try_module_get(phy->ops->owner))
 628                 return ERR_PTR(-EPROBE_DEFER);
 629
 630         get_device(&phy->dev);
 631
 632         return phy;
 633 }
 634 EXPORT_SYMBOL_GPL(of_phy_get);
 635
 636 /**
 637  * of_phy_put() - release the PHY
 638  * @phy: the phy returned by of_phy_get()
 639  *
 640  * Releases a refcount the caller received from of_phy_get().
 641  */
 642 void of_phy_put(struct phy *phy)
 643 {
 644         if (!phy || IS_ERR(phy))
 645                 return;
 646
 647         mutex_lock(&phy->mutex);
 648         if (phy->ops->release)
 649                 phy->ops->release(phy);
 650         mutex_unlock(&phy->mutex);
 651
 652         module_put(phy->ops->owner);
 653         put_device(&phy->dev);
 654 }
 655 EXPORT_SYMBOL_GPL(of_phy_put);
 656
 657 /**
 658  * phy_put() - release the PHY
 659  * @dev: device that wants to release this phy
 660  * @phy: the phy returned by phy_get()
 661  *
 662  * Releases a refcount the caller received from phy_get().
 663  */
 664 void phy_put(struct device *dev, struct phy *phy)
 665 {
 666         device_link_remove(dev, &phy->dev);
 667         of_phy_put(phy);
 668 }
 669 EXPORT_SYMBOL_GPL(phy_put);
 670
 671 /**
 672  * devm_phy_put() - release the PHY
 673  * @dev: device that wants to release this phy
 674  * @phy: the phy returned by devm_phy_get()
 675  *
 676  * destroys the devres associated with this phy and invokes phy_put
 677  * to release the phy.
 678  */
 679 void devm_phy_put(struct device *dev, struct phy *phy)
 680 {
 681         int r;
 682
 683         if (!phy)
 684                 return;
 685
 686         r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
 687         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 688 }
 689 EXPORT_SYMBOL_GPL(devm_phy_put);
 690
 691 /**
 692  * of_phy_simple_xlate() - returns the phy instance from phy provider
 693  * @dev: the PHY provider device
 694  * @args: of_phandle_args (not used here)
 695  *
 696  * Intended to be used by phy provider for the common case where #phy-cells is
 697  * 0. For other cases where #phy-cells is greater than '0', the phy provider
 698  * should provide a custom of_xlate function that reads the *args* and returns
 699  * the appropriate phy.
 700  */
 701 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
 702         *args)
 703 {
 704         struct phy *phy;
 705         struct class_dev_iter iter;
 706
 707         class_dev_iter_init(&iter, phy_class, NULL, NULL);
 708         while ((dev = class_dev_iter_next(&iter))) {
 709                 phy = to_phy(dev);
 710                 if (args->np != phy->dev.of_node)
 711                         continue;
 712
 713                 class_dev_iter_exit(&iter);
 714                 return phy;
 715         }
 716
 717         class_dev_iter_exit(&iter);
 718         return ERR_PTR(-ENODEV);
 719 }
 720 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
 721
 722 /**
 723  * phy_get() - lookup and obtain a reference to a phy.
 724  * @dev: device that requests this phy
 725  * @string: the phy name as given in the dt data or the name of the controller
 726  * port for non-dt case
 727  *
 728  * Returns the phy driver, after getting a refcount to it; or
 729  * -ENODEV if there is no such phy.  The caller is responsible for
 730  * calling phy_put() to release that count.
 731  */
 732 struct phy *phy_get(struct device *dev, const char *string)
 733 {
 734         int index = 0;
 735         struct phy *phy;
 736         struct device_link *link;
 737
 738         if (dev->of_node) {
 739                 if (string)
 740                         index = of_property_match_string(dev->of_node, "phy-names",
 741                                 string);
 742                 else
 743                         index = 0;
 744                 phy = _of_phy_get(dev->of_node, index);
 745         } else {
 746                 if (string == NULL) {
 747                         dev_WARN(dev, "missing string\n");
 748                         return ERR_PTR(-EINVAL);
 749                 }
 750                 phy = phy_find(dev, string);
 751         }
 752         if (IS_ERR(phy))
 753                 return phy;
 754
 755         if (!try_module_get(phy->ops->owner))
 756                 return ERR_PTR(-EPROBE_DEFER);
 757
 758         get_device(&phy->dev);
 759
 760         link = device_link_add(dev, &phy->dev, DL_FLAG_STATELESS);
 761         if (!link)
 762                 dev_dbg(dev, "failed to create device link to %s\n",
 763                         dev_name(phy->dev.parent));
 764
 765         return phy;
 766 }
 767 EXPORT_SYMBOL_GPL(phy_get);
 768
 769 /**
 770  * devm_phy_get() - lookup and obtain a reference to a phy.
 771  * @dev: device that requests this phy
 772  * @string: the phy name as given in the dt data or phy device name
 773  * for non-dt case
 774  *
 775  * Gets the phy using phy_get(), and associates a device with it using
 776  * devres. On driver detach, release function is invoked on the devres data,
 777  * then, devres data is freed.
 778  */
 779 struct phy *devm_phy_get(struct device *dev, const char *string)
 780 {
 781         struct phy **ptr, *phy;
 782
 783         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 784         if (!ptr)
 785                 return ERR_PTR(-ENOMEM);
 786
 787         phy = phy_get(dev, string);
 788         if (!IS_ERR(phy)) {
 789                 *ptr = phy;
 790                 devres_add(dev, ptr);
 791         } else {
 792                 devres_free(ptr);
 793         }
 794
 795         return phy;
 796 }
 797 EXPORT_SYMBOL_GPL(devm_phy_get);
 798
 799 /**
 800  * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
 801  * @dev: device that requests this phy
 802  * @string: the phy name as given in the dt data or phy device name
 803  * for non-dt case
 804  *
 805  * Gets the phy using phy_get(), and associates a device with it using
 806  * devres. On driver detach, release function is invoked on the devres
 807  * data, then, devres data is freed. This differs to devm_phy_get() in
 808  * that if the phy does not exist, it is not considered an error and
 809  * -ENODEV will not be returned. Instead the NULL phy is returned,
 810  * which can be passed to all other phy consumer calls.
 811  */
 812 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
 813 {
 814         struct phy *phy = devm_phy_get(dev, string);
 815
 816         if (PTR_ERR(phy) == -ENODEV)
 817                 phy = NULL;
 818
 819         return phy;
 820 }
 821 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
 822
 823 /**
 824  * devm_of_phy_get() - lookup and obtain a reference to a phy.
 825  * @dev: device that requests this phy
 826  * @np: node containing the phy
 827  * @con_id: name of the phy from device's point of view
 828  *
 829  * Gets the phy using of_phy_get(), and associates a device with it using
 830  * devres. On driver detach, release function is invoked on the devres data,
 831  * then, devres data is freed.
 832  */
 833 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
 834                             const char *con_id)
 835 {
 836         struct phy **ptr, *phy;
 837         struct device_link *link;
 838
 839         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 840         if (!ptr)
 841                 return ERR_PTR(-ENOMEM);
 842
 843         phy = of_phy_get(np, con_id);
 844         if (!IS_ERR(phy)) {
 845                 *ptr = phy;
 846                 devres_add(dev, ptr);
 847         } else {
 848                 devres_free(ptr);
 849                 return phy;
 850         }
 851
 852         link = device_link_add(dev, &phy->dev, DL_FLAG_STATELESS);
 853         if (!link)
 854                 dev_dbg(dev, "failed to create device link to %s\n",
 855                         dev_name(phy->dev.parent));
 856
 857         return phy;
 858 }
 859 EXPORT_SYMBOL_GPL(devm_of_phy_get);
 860
 861 /**
 862  * devm_of_phy_optional_get() - lookup and obtain a reference to an optional
 863  * phy.
 864  * @dev: device that requests this phy
 865  * @np: node containing the phy
 866  * @con_id: name of the phy from device's point of view
 867  *
 868  * Gets the phy using of_phy_get(), and associates a device with it using
 869  * devres. On driver detach, release function is invoked on the devres data,
 870  * then, devres data is freed.  This differs to devm_of_phy_get() in
 871  * that if the phy does not exist, it is not considered an error and
 872  * -ENODEV will not be returned. Instead the NULL phy is returned,
 873  * which can be passed to all other phy consumer calls.
 874  */
 875 struct phy *devm_of_phy_optional_get(struct device *dev, struct device_node *np,
 876                                      const char *con_id)
 877 {
 878         struct phy *phy = devm_of_phy_get(dev, np, con_id);
 879
 880         if (PTR_ERR(phy) == -ENODEV)
 881                 phy = NULL;
 882
 883         if (IS_ERR(phy))
 884                 dev_err_probe(dev, PTR_ERR(phy), "failed to get PHY %pOF:%s",
 885                               np, con_id);
 886
 887         return phy;
 888 }
 889 EXPORT_SYMBOL_GPL(devm_of_phy_optional_get);
 890
 891 /**
 892  * devm_of_phy_get_by_index() - lookup and obtain a reference to a phy by index.
 893  * @dev: device that requests this phy
 894  * @np: node containing the phy
 895  * @index: index of the phy
 896  *
 897  * Gets the phy using _of_phy_get(), then gets a refcount to it,
 898  * and associates a device with it using devres. On driver detach,
 899  * release function is invoked on the devres data,
 900  * then, devres data is freed.
 901  *
 902  */
 903 struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
 904                                      int index)
 905 {
 906         struct phy **ptr, *phy;
 907         struct device_link *link;
 908
 909         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 910         if (!ptr)
 911                 return ERR_PTR(-ENOMEM);
 912
 913         phy = _of_phy_get(np, index);
 914         if (IS_ERR(phy)) {
 915                 devres_free(ptr);
 916                 return phy;
 917         }
 918
 919         if (!try_module_get(phy->ops->owner)) {
 920                 devres_free(ptr);
 921                 return ERR_PTR(-EPROBE_DEFER);
 922         }
 923
 924         get_device(&phy->dev);
 925
 926         *ptr = phy;
 927         devres_add(dev, ptr);
 928
 929         link = device_link_add(dev, &phy->dev, DL_FLAG_STATELESS);
 930         if (!link)
 931                 dev_dbg(dev, "failed to create device link to %s\n",
 932                         dev_name(phy->dev.parent));
 933
 934         return phy;
 935 }
 936 EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
 937
 938 /**
 939  * phy_create() - create a new phy
 940  * @dev: device that is creating the new phy
 941  * @node: device node of the phy
 942  * @ops: function pointers for performing phy operations
 943  *
 944  * Called to create a phy using phy framework.
 945  */
 946 struct phy *phy_create(struct device *dev, struct device_node *node,
 947                        const struct phy_ops *ops)
 948 {
 949         int ret;
 950         int id;
 951         struct phy *phy;
 952
 953         if (WARN_ON(!dev))
 954                 return ERR_PTR(-EINVAL);
 955
 956         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
 957         if (!phy)
 958                 return ERR_PTR(-ENOMEM);
 959
 960         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
 961         if (id < 0) {
 962                 dev_err(dev, "unable to get id\n");
 963                 ret = id;
 964                 goto free_phy;
 965         }
 966
 967         device_initialize(&phy->dev);
 968         mutex_init(&phy->mutex);
 969
 970         phy->dev.class = phy_class;
 971         phy->dev.parent = dev;
 972         phy->dev.of_node = node ?: dev->of_node;
 973         phy->id = id;
 974         phy->ops = ops;
 975
 976         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
 977         if (ret)
 978                 goto put_dev;
 979
 980         /* phy-supply */
 981         phy->pwr = regulator_get_optional(&phy->dev, "phy");
 982         if (IS_ERR(phy->pwr)) {
 983                 ret = PTR_ERR(phy->pwr);
 984                 if (ret == -EPROBE_DEFER)
 985                         goto put_dev;
 986
 987                 phy->pwr = NULL;
 988         }
 989
 990         ret = device_add(&phy->dev);
 991         if (ret)
 992                 goto put_dev;
 993
 994         if (pm_runtime_enabled(dev)) {
 995                 pm_runtime_enable(&phy->dev);
 996                 pm_runtime_no_callbacks(&phy->dev);
 997         }
 998
 999         return phy;
1000
1001 put_dev:
1002         put_device(&phy->dev);  /* calls phy_release() which frees resources */
1003         return ERR_PTR(ret);
1004
1005 free_phy:
1006         kfree(phy);
1007         return ERR_PTR(ret);
1008 }
1009 EXPORT_SYMBOL_GPL(phy_create);
1010
1011 /**
1012  * devm_phy_create() - create a new phy
1013  * @dev: device that is creating the new phy
1014  * @node: device node of the phy
1015  * @ops: function pointers for performing phy operations
1016  *
1017  * Creates a new PHY device adding it to the PHY class.
1018  * While at that, it also associates the device with the phy using devres.
1019  * On driver detach, release function is invoked on the devres data,
1020  * then, devres data is freed.
1021  */
1022 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
1023                             const struct phy_ops *ops)
1024 {
1025         struct phy **ptr, *phy;
1026
1027         ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
1028         if (!ptr)
1029                 return ERR_PTR(-ENOMEM);
1030
1031         phy = phy_create(dev, node, ops);
1032         if (!IS_ERR(phy)) {
1033                 *ptr = phy;
1034                 devres_add(dev, ptr);
1035         } else {
1036                 devres_free(ptr);
1037         }
1038
1039         return phy;
1040 }
1041 EXPORT_SYMBOL_GPL(devm_phy_create);
1042
1043 /**
1044  * phy_destroy() - destroy the phy
1045  * @phy: the phy to be destroyed
1046  *
1047  * Called to destroy the phy.
1048  */
1049 void phy_destroy(struct phy *phy)
1050 {
1051         pm_runtime_disable(&phy->dev);
1052         device_unregister(&phy->dev);
1053 }
1054 EXPORT_SYMBOL_GPL(phy_destroy);
1055
1056 /**
1057  * devm_phy_destroy() - destroy the PHY
1058  * @dev: device that wants to release this phy
1059  * @phy: the phy returned by devm_phy_get()
1060  *
1061  * destroys the devres associated with this phy and invokes phy_destroy
1062  * to destroy the phy.
1063  */
1064 void devm_phy_destroy(struct device *dev, struct phy *phy)
1065 {
1066         int r;
1067
1068         r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
1069         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
1070 }
1071 EXPORT_SYMBOL_GPL(devm_phy_destroy);
1072
1073 /**
1074  * __of_phy_provider_register() - create/register phy provider with the framework
1075  * @dev: struct device of the phy provider
1076  * @children: device node containing children (if different from dev->of_node)
1077  * @owner: the module owner containing of_xlate
1078  * @of_xlate: function pointer to obtain phy instance from phy provider
1079  *
1080  * Creates struct phy_provider from dev and of_xlate function pointer.
1081  * This is used in the case of dt boot for finding the phy instance from
1082  * phy provider.
1083  *
1084  * If the PHY provider doesn't nest children directly but uses a separate
1085  * child node to contain the individual children, the @children parameter
1086  * can be used to override the default. If NULL, the default (dev->of_node)
1087  * will be used. If non-NULL, the device node must be a child (or further
1088  * descendant) of dev->of_node. Otherwise an ERR_PTR()-encoded -EINVAL
1089  * error code is returned.
1090  */
1091 struct phy_provider *__of_phy_provider_register(struct device *dev,
1092         struct device_node *children, struct module *owner,
1093         struct phy * (*of_xlate)(struct device *dev,
1094                                  struct of_phandle_args *args))
1095 {
1096         struct phy_provider *phy_provider;
1097
1098         /*
1099          * If specified, the device node containing the children must itself
1100          * be the provider's device node or a child (or further descendant)
1101          * thereof.
1102          */
1103         if (children) {
1104                 struct device_node *parent = of_node_get(children), *next;
1105
1106                 while (parent) {
1107                         if (parent == dev->of_node)
1108                                 break;
1109
1110                         next = of_get_parent(parent);
1111                         of_node_put(parent);
1112                         parent = next;
1113                 }
1114
1115                 if (!parent)
1116                         return ERR_PTR(-EINVAL);
1117
1118                 of_node_put(parent);
1119         } else {
1120                 children = dev->of_node;
1121         }
1122
1123         phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
1124         if (!phy_provider)
1125                 return ERR_PTR(-ENOMEM);
1126
1127         phy_provider->dev = dev;
1128         phy_provider->children = of_node_get(children);
1129         phy_provider->owner = owner;
1130         phy_provider->of_xlate = of_xlate;
1131
1132         mutex_lock(&phy_provider_mutex);
1133         list_add_tail(&phy_provider->list, &phy_provider_list);
1134         mutex_unlock(&phy_provider_mutex);
1135
1136         return phy_provider;
1137 }
1138 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
1139
1140 /**
1141  * __devm_of_phy_provider_register() - create/register phy provider with the
1142  * framework
1143  * @dev: struct device of the phy provider
1144  * @children: device node containing children (if different from dev->of_node)
1145  * @owner: the module owner containing of_xlate
1146  * @of_xlate: function pointer to obtain phy instance from phy provider
1147  *
1148  * Creates struct phy_provider from dev and of_xlate function pointer.
1149  * This is used in the case of dt boot for finding the phy instance from
1150  * phy provider. While at that, it also associates the device with the
1151  * phy provider using devres. On driver detach, release function is invoked
1152  * on the devres data, then, devres data is freed.
1153  */
1154 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
1155         struct device_node *children, struct module *owner,
1156         struct phy * (*of_xlate)(struct device *dev,
1157                                  struct of_phandle_args *args))
1158 {
1159         struct phy_provider **ptr, *phy_provider;
1160
1161         ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
1162         if (!ptr)
1163                 return ERR_PTR(-ENOMEM);
1164
1165         phy_provider = __of_phy_provider_register(dev, children, owner,
1166                                                   of_xlate);
1167         if (!IS_ERR(phy_provider)) {
1168                 *ptr = phy_provider;
1169                 devres_add(dev, ptr);
1170         } else {
1171                 devres_free(ptr);
1172         }
1173
1174         return phy_provider;
1175 }
1176 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
1177
1178 /**
1179  * of_phy_provider_unregister() - unregister phy provider from the framework
1180  * @phy_provider: phy provider returned by of_phy_provider_register()
1181  *
1182  * Removes the phy_provider created using of_phy_provider_register().
1183  */
1184 void of_phy_provider_unregister(struct phy_provider *phy_provider)
1185 {
1186         if (IS_ERR(phy_provider))
1187                 return;
1188
1189         mutex_lock(&phy_provider_mutex);
1190         list_del(&phy_provider->list);
1191         of_node_put(phy_provider->children);
1192         kfree(phy_provider);
1193         mutex_unlock(&phy_provider_mutex);
1194 }
1195 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
1196
1197 /**
1198  * devm_of_phy_provider_unregister() - remove phy provider from the framework
1199  * @dev: struct device of the phy provider
1200  * @phy_provider: phy provider returned by of_phy_provider_register()
1201  *
1202  * destroys the devres associated with this phy provider and invokes
1203  * of_phy_provider_unregister to unregister the phy provider.
1204  */
1205 void devm_of_phy_provider_unregister(struct device *dev,
1206         struct phy_provider *phy_provider)
1207 {
1208         int r;
1209
1210         r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
1211                 phy_provider);
1212         dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
1213 }
1214 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
1215
1216 /**
1217  * phy_release() - release the phy
1218  * @dev: the dev member within phy
1219  *
1220  * When the last reference to the device is removed, it is called
1221  * from the embedded kobject as release method.
1222  */
1223 static void phy_release(struct device *dev)
1224 {
1225         struct phy *phy;
1226
1227         phy = to_phy(dev);
1228         dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
1229         regulator_put(phy->pwr);
1230         ida_simple_remove(&phy_ida, phy->id);
1231         kfree(phy);
1232 }
1233
1234 static int __init phy_core_init(void)
1235 {
1236         phy_class = class_create("phy");
1237         if (IS_ERR(phy_class)) {
1238                 pr_err("failed to create phy class --> %ld\n",
1239                         PTR_ERR(phy_class));
1240                 return PTR_ERR(phy_class);
1241         }
1242
1243         phy_class->dev_release = phy_release;
1244
1245         return 0;
1246 }
1247 device_initcall(phy_core_init);