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