drivers/phy/phy-core.c

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

DEFINITIONS
