drivers/phy/phy-core.c

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