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->dev->of_node, 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 (!pm_runtime_enabled(&phy->dev))
 157                 return -ENOTSUPP;
 158
 159         ret = pm_runtime_get(&phy->dev);
 160         if (ret < 0 && ret != -EINPROGRESS)
 161                 pm_runtime_put_noidle(&phy->dev);
 162
 163         return ret;
 164 }
 165 EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
 166
 167 int phy_pm_runtime_get_sync(struct phy *phy)
 168 {
 169         int ret;
 170
 171         if (!pm_runtime_enabled(&phy->dev))
 172                 return -ENOTSUPP;
 173
 174         ret = pm_runtime_get_sync(&phy->dev);
 175         if (ret < 0)
 176                 pm_runtime_put_sync(&phy->dev);
 177
 178         return ret;
 179 }
 180 EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
 181
 182 int phy_pm_runtime_put(struct phy *phy)
 183 {
 184         if (!pm_runtime_enabled(&phy->dev))
 185                 return -ENOTSUPP;
 186
 187         return pm_runtime_put(&phy->dev);
 188 }
 189 EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
 190
 191 int phy_pm_runtime_put_sync(struct phy *phy)
 192 {
 193         if (!pm_runtime_enabled(&phy->dev))
 194                 return -ENOTSUPP;
 195
 196         return pm_runtime_put_sync(&phy->dev);
 197 }
 198 EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
 199
 200 void phy_pm_runtime_allow(struct phy *phy)
 201 {
 202         if (!pm_runtime_enabled(&phy->dev))
 203                 return;
 204
 205         pm_runtime_allow(&phy->dev);
 206 }
 207 EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
 208
 209 void phy_pm_runtime_forbid(struct phy *phy)
 210 {
 211         if (!pm_runtime_enabled(&phy->dev))
 212                 return;
 213
 214         pm_runtime_forbid(&phy->dev);
 215 }
 216 EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
 217
 218 int phy_init(struct phy *phy)
 219 {
 220         int ret;
 221
 222         if (!phy)
 223                 return 0;
 224
 225         ret = phy_pm_runtime_get_sync(phy);
 226         if (ret < 0 && ret != -ENOTSUPP)
 227                 return ret;
 228         ret = 0; /* Override possible ret == -ENOTSUPP */
 229
 230         mutex_lock(&phy->mutex);
 231         if (phy->init_count == 0 && phy->ops->init) {
 232                 ret = phy->ops->init(phy);
 233                 if (ret < 0) {
 234                         dev_err(&phy->dev, "phy init failed --> %d\n", ret);
 235                         goto out;
 236                 }
 237         }
 238         ++phy->init_count;
 239
 240 out:
 241         mutex_unlock(&phy->mutex);
 242         phy_pm_runtime_put(phy);
 243         return ret;
 244 }
 245 EXPORT_SYMBOL_GPL(phy_init);
 246
 247 int phy_exit(struct phy *phy)
 248 {
 249         int ret;
 250
 251         if (!phy)
 252                 return 0;
 253
 254         ret = phy_pm_runtime_get_sync(phy);
 255         if (ret < 0 && ret != -ENOTSUPP)
 256                 return ret;
 257         ret = 0; /* Override possible ret == -ENOTSUPP */
 258
 259         mutex_lock(&phy->mutex);
 260         if (phy->init_count == 1 && phy->ops->exit) {
 261                 ret = phy->ops->exit(phy);
 262                 if (ret < 0) {
 263                         dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
 264                         goto out;
 265                 }
 266         }
 267         --phy->init_count;
 268
 269 out:
 270         mutex_unlock(&phy->mutex);
 271         phy_pm_runtime_put(phy);
 272         return ret;
 273 }
 274 EXPORT_SYMBOL_GPL(phy_exit);
 275
 276 int phy_power_on(struct phy *phy)
 277 {
 278         int ret = 0;
 279
 280         if (!phy)
 281                 goto out;
 282
 283         if (phy->pwr) {
 284                 ret = regulator_enable(phy->pwr);
 285                 if (ret)
 286                         goto out;
 287         }
 288
 289         ret = phy_pm_runtime_get_sync(phy);
 290         if (ret < 0 && ret != -ENOTSUPP)
 291                 goto err_pm_sync;
 292
 293         ret = 0; /* Override possible ret == -ENOTSUPP */
 294
 295         mutex_lock(&phy->mutex);
 296         if (phy->power_count == 0 && phy->ops->power_on) {
 297                 ret = phy->ops->power_on(phy);
 298                 if (ret < 0) {
 299                         dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
 300                         goto err_pwr_on;
 301                 }
 302         }
 303         ++phy->power_count;
 304         mutex_unlock(&phy->mutex);
 305         return 0;
 306
 307 err_pwr_on:
 308         mutex_unlock(&phy->mutex);
 309         phy_pm_runtime_put_sync(phy);
 310 err_pm_sync:
 311         if (phy->pwr)
 312                 regulator_disable(phy->pwr);
 313 out:
 314         return ret;
 315 }
 316 EXPORT_SYMBOL_GPL(phy_power_on);
 317
 318 int phy_power_off(struct phy *phy)
 319 {
 320         int ret;
 321
 322         if (!phy)
 323                 return 0;
 324
 325         mutex_lock(&phy->mutex);
 326         if (phy->power_count == 1 && phy->ops->power_off) {
 327                 ret =  phy->ops->power_off(phy);
 328                 if (ret < 0) {
 329                         dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
 330                         mutex_unlock(&phy->mutex);
 331                         return ret;
 332                 }
 333         }
 334         --phy->power_count;
 335         mutex_unlock(&phy->mutex);
 336         phy_pm_runtime_put(phy);
 337
 338         if (phy->pwr)
 339                 regulator_disable(phy->pwr);
 340
 341         return 0;
 342 }
 343 EXPORT_SYMBOL_GPL(phy_power_off);
 344
 345 /**
 346  * _of_phy_get() - lookup and obtain a reference to a phy by phandle
 347  * @np: device_node for which to get the phy
 348  * @index: the index of the phy
 349  *
 350  * Returns the phy associated with the given phandle value,
 351  * after getting a refcount to it or -ENODEV if there is no such phy or
 352  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 353  * not yet loaded. This function uses of_xlate call back function provided
 354  * while registering the phy_provider to find the phy instance.
 355  */
 356 static struct phy *_of_phy_get(struct device_node *np, int index)
 357 {
 358         int ret;
 359         struct phy_provider *phy_provider;
 360         struct phy *phy = NULL;
 361         struct of_phandle_args args;
 362
 363         ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
 364                 index, &args);
 365         if (ret)
 366                 return ERR_PTR(-ENODEV);
 367
 368         /* This phy type handled by the usb-phy subsystem for now */
 369         if (of_device_is_compatible(args.np, "usb-nop-xceiv"))
 370                 return ERR_PTR(-ENODEV);
 371
 372         mutex_lock(&phy_provider_mutex);
 373         phy_provider = of_phy_provider_lookup(args.np);
 374         if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
 375                 phy = ERR_PTR(-EPROBE_DEFER);
 376                 goto out_unlock;
 377         }
 378
 379         if (!of_device_is_available(args.np)) {
 380                 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
 381                 phy = ERR_PTR(-ENODEV);
 382                 goto out_put_module;
 383         }
 384
 385         phy = phy_provider->of_xlate(phy_provider->dev, &args);
 386
 387 out_put_module:
 388         module_put(phy_provider->owner);
 389
 390 out_unlock:
 391         mutex_unlock(&phy_provider_mutex);
 392         of_node_put(args.np);
 393
 394         return phy;
 395 }
 396
 397 /**
 398  * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
 399  * @np: device_node for which to get the phy
 400  * @con_id: name of the phy from device's point of view
 401  *
 402  * Returns the phy driver, after getting a refcount to it; or
 403  * -ENODEV if there is no such phy. The caller is responsible for
 404  * calling phy_put() to release that count.
 405  */
 406 struct phy *of_phy_get(struct device_node *np, const char *con_id)
 407 {
 408         struct phy *phy = NULL;
 409         int index = 0;
 410
 411         if (con_id)
 412                 index = of_property_match_string(np, "phy-names", con_id);
 413
 414         phy = _of_phy_get(np, index);
 415         if (IS_ERR(phy))
 416                 return phy;
 417
 418         if (!try_module_get(phy->ops->owner))
 419                 return ERR_PTR(-EPROBE_DEFER);
 420
 421         get_device(&phy->dev);
 422
 423         return phy;
 424 }
 425 EXPORT_SYMBOL_GPL(of_phy_get);
 426
 427 /**
 428  * phy_put() - release the PHY
 429  * @phy: the phy returned by phy_get()
 430  *
 431  * Releases a refcount the caller received from phy_get().
 432  */
 433 void phy_put(struct phy *phy)
 434 {
 435         if (!phy || IS_ERR(phy))
 436                 return;
 437
 438         module_put(phy->ops->owner);
 439         put_device(&phy->dev);
 440 }
 441 EXPORT_SYMBOL_GPL(phy_put);
 442
 443 /**
 444  * devm_phy_put() - release the PHY
 445  * @dev: device that wants to release this phy
 446  * @phy: the phy returned by devm_phy_get()
 447  *
 448  * destroys the devres associated with this phy and invokes phy_put
 449  * to release the phy.
 450  */
 451 void devm_phy_put(struct device *dev, struct phy *phy)
 452 {
 453         int r;
 454
 455         if (!phy)
 456                 return;
 457
 458         r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
 459         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 460 }
 461 EXPORT_SYMBOL_GPL(devm_phy_put);
 462
 463 /**
 464  * of_phy_simple_xlate() - returns the phy instance from phy provider
 465  * @dev: the PHY provider device
 466  * @args: of_phandle_args (not used here)
 467  *
 468  * Intended to be used by phy provider for the common case where #phy-cells is
 469  * 0. For other cases where #phy-cells is greater than '0', the phy provider
 470  * should provide a custom of_xlate function that reads the *args* and returns
 471  * the appropriate phy.
 472  */
 473 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
 474         *args)
 475 {
 476         struct phy *phy;
 477         struct class_dev_iter iter;
 478
 479         class_dev_iter_init(&iter, phy_class, NULL, NULL);
 480         while ((dev = class_dev_iter_next(&iter))) {
 481                 phy = to_phy(dev);
 482                 if (args->np != phy->dev.of_node)
 483                         continue;
 484
 485                 class_dev_iter_exit(&iter);
 486                 return phy;
 487         }
 488
 489         class_dev_iter_exit(&iter);
 490         return ERR_PTR(-ENODEV);
 491 }
 492 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
 493
 494 /**
 495  * phy_get() - lookup and obtain a reference to a phy.
 496  * @dev: device that requests this phy
 497  * @string: the phy name as given in the dt data or the name of the controller
 498  * port for non-dt case
 499  *
 500  * Returns the phy driver, after getting a refcount to it; or
 501  * -ENODEV if there is no such phy.  The caller is responsible for
 502  * calling phy_put() to release that count.
 503  */
 504 struct phy *phy_get(struct device *dev, const char *string)
 505 {
 506         int index = 0;
 507         struct phy *phy;
 508
 509         if (string == NULL) {
 510                 dev_WARN(dev, "missing string\n");
 511                 return ERR_PTR(-EINVAL);
 512         }
 513
 514         if (dev->of_node) {
 515                 index = of_property_match_string(dev->of_node, "phy-names",
 516                         string);
 517                 phy = _of_phy_get(dev->of_node, index);
 518         } else {
 519                 phy = phy_find(dev, string);
 520         }
 521         if (IS_ERR(phy))
 522                 return phy;
 523
 524         if (!try_module_get(phy->ops->owner))
 525                 return ERR_PTR(-EPROBE_DEFER);
 526
 527         get_device(&phy->dev);
 528
 529         return phy;
 530 }
 531 EXPORT_SYMBOL_GPL(phy_get);
 532
 533 /**
 534  * phy_optional_get() - lookup and obtain a reference to an optional phy.
 535  * @dev: device that requests this phy
 536  * @string: the phy name as given in the dt data or the name of the controller
 537  * port for non-dt case
 538  *
 539  * Returns the phy driver, after getting a refcount to it; or
 540  * NULL if there is no such phy.  The caller is responsible for
 541  * calling phy_put() to release that count.
 542  */
 543 struct phy *phy_optional_get(struct device *dev, const char *string)
 544 {
 545         struct phy *phy = phy_get(dev, string);
 546
 547         if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
 548                 phy = NULL;
 549
 550         return phy;
 551 }
 552 EXPORT_SYMBOL_GPL(phy_optional_get);
 553
 554 /**
 555  * devm_phy_get() - lookup and obtain a reference to a phy.
 556  * @dev: device that requests this phy
 557  * @string: the phy name as given in the dt data or phy device name
 558  * for non-dt case
 559  *
 560  * Gets the phy using phy_get(), and associates a device with it using
 561  * devres. On driver detach, release function is invoked on the devres data,
 562  * then, devres data is freed.
 563  */
 564 struct phy *devm_phy_get(struct device *dev, const char *string)
 565 {
 566         struct phy **ptr, *phy;
 567
 568         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 569         if (!ptr)
 570                 return ERR_PTR(-ENOMEM);
 571
 572         phy = phy_get(dev, string);
 573         if (!IS_ERR(phy)) {
 574                 *ptr = phy;
 575                 devres_add(dev, ptr);
 576         } else {
 577                 devres_free(ptr);
 578         }
 579
 580         return phy;
 581 }
 582 EXPORT_SYMBOL_GPL(devm_phy_get);
 583
 584 /**
 585  * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
 586  * @dev: device that requests this phy
 587  * @string: the phy name as given in the dt data or phy device name
 588  * for non-dt case
 589  *
 590  * Gets the phy using phy_get(), and associates a device with it using
 591  * devres. On driver detach, release function is invoked on the devres
 592  * data, then, devres data is freed. This differs to devm_phy_get() in
 593  * that if the phy does not exist, it is not considered an error and
 594  * -ENODEV will not be returned. Instead the NULL phy is returned,
 595  * which can be passed to all other phy consumer calls.
 596  */
 597 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
 598 {
 599         struct phy *phy = devm_phy_get(dev, string);
 600
 601         if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
 602                 phy = NULL;
 603
 604         return phy;
 605 }
 606 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
 607
 608 /**
 609  * devm_of_phy_get() - lookup and obtain a reference to a phy.
 610  * @dev: device that requests this phy
 611  * @np: node containing the phy
 612  * @con_id: name of the phy from device's point of view
 613  *
 614  * Gets the phy using of_phy_get(), and associates a device with it using
 615  * devres. On driver detach, release function is invoked on the devres data,
 616  * then, devres data is freed.
 617  */
 618 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
 619                             const char *con_id)
 620 {
 621         struct phy **ptr, *phy;
 622
 623         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 624         if (!ptr)
 625                 return ERR_PTR(-ENOMEM);
 626
 627         phy = of_phy_get(np, con_id);
 628         if (!IS_ERR(phy)) {
 629                 *ptr = phy;
 630                 devres_add(dev, ptr);
 631         } else {
 632                 devres_free(ptr);
 633         }
 634
 635         return phy;
 636 }
 637 EXPORT_SYMBOL_GPL(devm_of_phy_get);
 638
 639 /**
 640  * devm_of_phy_get_by_index() - lookup and obtain a reference to a phy by index.
 641  * @dev: device that requests this phy
 642  * @np: node containing the phy
 643  * @index: index of the phy
 644  *
 645  * Gets the phy using _of_phy_get(), then gets a refcount to it,
 646  * and associates a device with it using devres. On driver detach,
 647  * release function is invoked on the devres data,
 648  * then, devres data is freed.
 649  *
 650  */
 651 struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
 652                                      int index)
 653 {
 654         struct phy **ptr, *phy;
 655
 656         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 657         if (!ptr)
 658                 return ERR_PTR(-ENOMEM);
 659
 660         phy = _of_phy_get(np, index);
 661         if (IS_ERR(phy)) {
 662                 devres_free(ptr);
 663                 return phy;
 664         }
 665
 666         if (!try_module_get(phy->ops->owner)) {
 667                 devres_free(ptr);
 668                 return ERR_PTR(-EPROBE_DEFER);
 669         }
 670
 671         get_device(&phy->dev);
 672
 673         *ptr = phy;
 674         devres_add(dev, ptr);
 675
 676         return phy;
 677 }
 678 EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
 679
 680 /**
 681  * phy_create() - create a new phy
 682  * @dev: device that is creating the new phy
 683  * @node: device node of the phy
 684  * @ops: function pointers for performing phy operations
 685  *
 686  * Called to create a phy using phy framework.
 687  */
 688 struct phy *phy_create(struct device *dev, struct device_node *node,
 689                        const struct phy_ops *ops)
 690 {
 691         int ret;
 692         int id;
 693         struct phy *phy;
 694
 695         if (WARN_ON(!dev))
 696                 return ERR_PTR(-EINVAL);
 697
 698         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
 699         if (!phy)
 700                 return ERR_PTR(-ENOMEM);
 701
 702         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
 703         if (id < 0) {
 704                 dev_err(dev, "unable to get id\n");
 705                 ret = id;
 706                 goto free_phy;
 707         }
 708
 709         device_initialize(&phy->dev);
 710         mutex_init(&phy->mutex);
 711
 712         phy->dev.class = phy_class;
 713         phy->dev.parent = dev;
 714         phy->dev.of_node = node ?: dev->of_node;
 715         phy->id = id;
 716         phy->ops = ops;
 717
 718         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
 719         if (ret)
 720                 goto put_dev;
 721
 722         /* phy-supply */
 723         phy->pwr = regulator_get_optional(&phy->dev, "phy");
 724         if (IS_ERR(phy->pwr)) {
 725                 ret = PTR_ERR(phy->pwr);
 726                 if (ret == -EPROBE_DEFER)
 727                         goto put_dev;
 728
 729                 phy->pwr = NULL;
 730         }
 731
 732         ret = device_add(&phy->dev);
 733         if (ret)
 734                 goto put_dev;
 735
 736         if (pm_runtime_enabled(dev)) {
 737                 pm_runtime_enable(&phy->dev);
 738                 pm_runtime_no_callbacks(&phy->dev);
 739         }
 740
 741         return phy;
 742
 743 put_dev:
 744         put_device(&phy->dev);  /* calls phy_release() which frees resources */
 745         return ERR_PTR(ret);
 746
 747 free_phy:
 748         kfree(phy);
 749         return ERR_PTR(ret);
 750 }
 751 EXPORT_SYMBOL_GPL(phy_create);
 752
 753 /**
 754  * devm_phy_create() - create a new phy
 755  * @dev: device that is creating the new phy
 756  * @node: device node of the phy
 757  * @ops: function pointers for performing phy operations
 758  *
 759  * Creates a new PHY device adding it to the PHY class.
 760  * While at that, it also associates the device with the phy using devres.
 761  * On driver detach, release function is invoked on the devres data,
 762  * then, devres data is freed.
 763  */
 764 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
 765                             const struct phy_ops *ops)
 766 {
 767         struct phy **ptr, *phy;
 768
 769         ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
 770         if (!ptr)
 771                 return ERR_PTR(-ENOMEM);
 772
 773         phy = phy_create(dev, node, ops);
 774         if (!IS_ERR(phy)) {
 775                 *ptr = phy;
 776                 devres_add(dev, ptr);
 777         } else {
 778                 devres_free(ptr);
 779         }
 780
 781         return phy;
 782 }
 783 EXPORT_SYMBOL_GPL(devm_phy_create);
 784
 785 /**
 786  * phy_destroy() - destroy the phy
 787  * @phy: the phy to be destroyed
 788  *
 789  * Called to destroy the phy.
 790  */
 791 void phy_destroy(struct phy *phy)
 792 {
 793         pm_runtime_disable(&phy->dev);
 794         device_unregister(&phy->dev);
 795 }
 796 EXPORT_SYMBOL_GPL(phy_destroy);
 797
 798 /**
 799  * devm_phy_destroy() - destroy the PHY
 800  * @dev: device that wants to release this phy
 801  * @phy: the phy returned by devm_phy_get()
 802  *
 803  * destroys the devres associated with this phy and invokes phy_destroy
 804  * to destroy the phy.
 805  */
 806 void devm_phy_destroy(struct device *dev, struct phy *phy)
 807 {
 808         int r;
 809
 810         r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
 811         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 812 }
 813 EXPORT_SYMBOL_GPL(devm_phy_destroy);
 814
 815 /**
 816  * __of_phy_provider_register() - create/register phy provider with the framework
 817  * @dev: struct device of the phy provider
 818  * @owner: the module owner containing of_xlate
 819  * @of_xlate: function pointer to obtain phy instance from phy provider
 820  *
 821  * Creates struct phy_provider from dev and of_xlate function pointer.
 822  * This is used in the case of dt boot for finding the phy instance from
 823  * phy provider.
 824  */
 825 struct phy_provider *__of_phy_provider_register(struct device *dev,
 826         struct module *owner, struct phy * (*of_xlate)(struct device *dev,
 827         struct of_phandle_args *args))
 828 {
 829         struct phy_provider *phy_provider;
 830
 831         phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
 832         if (!phy_provider)
 833                 return ERR_PTR(-ENOMEM);
 834
 835         phy_provider->dev = dev;
 836         phy_provider->owner = owner;
 837         phy_provider->of_xlate = of_xlate;
 838
 839         mutex_lock(&phy_provider_mutex);
 840         list_add_tail(&phy_provider->list, &phy_provider_list);
 841         mutex_unlock(&phy_provider_mutex);
 842
 843         return phy_provider;
 844 }
 845 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
 846
 847 /**
 848  * __devm_of_phy_provider_register() - create/register phy provider with the
 849  * framework
 850  * @dev: struct device of the phy provider
 851  * @owner: the module owner containing of_xlate
 852  * @of_xlate: function pointer to obtain phy instance from phy provider
 853  *
 854  * Creates struct phy_provider from dev and of_xlate function pointer.
 855  * This is used in the case of dt boot for finding the phy instance from
 856  * phy provider. While at that, it also associates the device with the
 857  * phy provider using devres. On driver detach, release function is invoked
 858  * on the devres data, then, devres data is freed.
 859  */
 860 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
 861         struct module *owner, struct phy * (*of_xlate)(struct device *dev,
 862         struct of_phandle_args *args))
 863 {
 864         struct phy_provider **ptr, *phy_provider;
 865
 866         ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
 867         if (!ptr)
 868                 return ERR_PTR(-ENOMEM);
 869
 870         phy_provider = __of_phy_provider_register(dev, owner, of_xlate);
 871         if (!IS_ERR(phy_provider)) {
 872                 *ptr = phy_provider;
 873                 devres_add(dev, ptr);
 874         } else {
 875                 devres_free(ptr);
 876         }
 877
 878         return phy_provider;
 879 }
 880 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
 881
 882 /**
 883  * of_phy_provider_unregister() - unregister phy provider from the framework
 884  * @phy_provider: phy provider returned by of_phy_provider_register()
 885  *
 886  * Removes the phy_provider created using of_phy_provider_register().
 887  */
 888 void of_phy_provider_unregister(struct phy_provider *phy_provider)
 889 {
 890         if (IS_ERR(phy_provider))
 891                 return;
 892
 893         mutex_lock(&phy_provider_mutex);
 894         list_del(&phy_provider->list);
 895         kfree(phy_provider);
 896         mutex_unlock(&phy_provider_mutex);
 897 }
 898 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
 899
 900 /**
 901  * devm_of_phy_provider_unregister() - remove phy provider from the framework
 902  * @dev: struct device of the phy provider
 903  *
 904  * destroys the devres associated with this phy provider and invokes
 905  * of_phy_provider_unregister to unregister the phy provider.
 906  */
 907 void devm_of_phy_provider_unregister(struct device *dev,
 908         struct phy_provider *phy_provider) {
 909         int r;
 910
 911         r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
 912                 phy_provider);
 913         dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
 914 }
 915 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
 916
 917 /**
 918  * phy_release() - release the phy
 919  * @dev: the dev member within phy
 920  *
 921  * When the last reference to the device is removed, it is called
 922  * from the embedded kobject as release method.
 923  */
 924 static void phy_release(struct device *dev)
 925 {
 926         struct phy *phy;
 927
 928         phy = to_phy(dev);
 929         dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
 930         regulator_put(phy->pwr);
 931         ida_simple_remove(&phy_ida, phy->id);
 932         kfree(phy);
 933 }
 934
 935 static int __init phy_core_init(void)
 936 {
 937         phy_class = class_create(THIS_MODULE, "phy");
 938         if (IS_ERR(phy_class)) {
 939                 pr_err("failed to create phy class --> %ld\n",
 940                         PTR_ERR(phy_class));
 941                 return PTR_ERR(phy_class);
 942         }
 943
 944         phy_class->dev_release = phy_release;
 945
 946         return 0;
 947 }
 948 module_init(phy_core_init);
 949
 950 static void __exit phy_core_exit(void)
 951 {
 952         class_destroy(phy_class);
 953 }
 954 module_exit(phy_core_exit);
 955
 956 MODULE_DESCRIPTION("Generic PHY Framework");
 957 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 958 MODULE_LICENSE("GPL v2");