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