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
  25 static struct class *phy_class;
  26 static DEFINE_MUTEX(phy_provider_mutex);
  27 static LIST_HEAD(phy_provider_list);
  28 static DEFINE_IDA(phy_ida);
  29
  30 static void devm_phy_release(struct device *dev, void *res)
  31 {
  32         struct phy *phy = *(struct phy **)res;
  33
  34         phy_put(phy);
  35 }
  36
  37 static void devm_phy_provider_release(struct device *dev, void *res)
  38 {
  39         struct phy_provider *phy_provider = *(struct phy_provider **)res;
  40
  41         of_phy_provider_unregister(phy_provider);
  42 }
  43
  44 static void devm_phy_consume(struct device *dev, void *res)
  45 {
  46         struct phy *phy = *(struct phy **)res;
  47
  48         phy_destroy(phy);
  49 }
  50
  51 static int devm_phy_match(struct device *dev, void *res, void *match_data)
  52 {
  53         return res == match_data;
  54 }
  55
  56 static struct phy *phy_lookup(struct device *device, const char *port)
  57 {
  58         unsigned int count;
  59         struct phy *phy;
  60         struct device *dev;
  61         struct phy_consumer *consumers;
  62         struct class_dev_iter iter;
  63
  64         class_dev_iter_init(&iter, phy_class, NULL, NULL);
  65         while ((dev = class_dev_iter_next(&iter))) {
  66                 phy = to_phy(dev);
  67
  68                 if (!phy->init_data)
  69                         continue;
  70                 count = phy->init_data->num_consumers;
  71                 consumers = phy->init_data->consumers;
  72                 while (count--) {
  73                         if (!strcmp(consumers->dev_name, dev_name(device)) &&
  74                                         !strcmp(consumers->port, port)) {
  75                                 class_dev_iter_exit(&iter);
  76                                 return phy;
  77                         }
  78                         consumers++;
  79                 }
  80         }
  81
  82         class_dev_iter_exit(&iter);
  83         return ERR_PTR(-ENODEV);
  84 }
  85
  86 static struct phy_provider *of_phy_provider_lookup(struct device_node *node)
  87 {
  88         struct phy_provider *phy_provider;
  89
  90         list_for_each_entry(phy_provider, &phy_provider_list, list) {
  91                 if (phy_provider->dev->of_node == node)
  92                         return phy_provider;
  93         }
  94
  95         return ERR_PTR(-EPROBE_DEFER);
  96 }
  97
  98 int phy_pm_runtime_get(struct phy *phy)
  99 {
 100         int ret;
 101
 102         if (!pm_runtime_enabled(&phy->dev))
 103                 return -ENOTSUPP;
 104
 105         ret = pm_runtime_get(&phy->dev);
 106         if (ret < 0 && ret != -EINPROGRESS)
 107                 pm_runtime_put_noidle(&phy->dev);
 108
 109         return ret;
 110 }
 111 EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
 112
 113 int phy_pm_runtime_get_sync(struct phy *phy)
 114 {
 115         int ret;
 116
 117         if (!pm_runtime_enabled(&phy->dev))
 118                 return -ENOTSUPP;
 119
 120         ret = pm_runtime_get_sync(&phy->dev);
 121         if (ret < 0)
 122                 pm_runtime_put_sync(&phy->dev);
 123
 124         return ret;
 125 }
 126 EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
 127
 128 int phy_pm_runtime_put(struct phy *phy)
 129 {
 130         if (!pm_runtime_enabled(&phy->dev))
 131                 return -ENOTSUPP;
 132
 133         return pm_runtime_put(&phy->dev);
 134 }
 135 EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
 136
 137 int phy_pm_runtime_put_sync(struct phy *phy)
 138 {
 139         if (!pm_runtime_enabled(&phy->dev))
 140                 return -ENOTSUPP;
 141
 142         return pm_runtime_put_sync(&phy->dev);
 143 }
 144 EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
 145
 146 void phy_pm_runtime_allow(struct phy *phy)
 147 {
 148         if (!pm_runtime_enabled(&phy->dev))
 149                 return;
 150
 151         pm_runtime_allow(&phy->dev);
 152 }
 153 EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
 154
 155 void phy_pm_runtime_forbid(struct phy *phy)
 156 {
 157         if (!pm_runtime_enabled(&phy->dev))
 158                 return;
 159
 160         pm_runtime_forbid(&phy->dev);
 161 }
 162 EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
 163
 164 int phy_init(struct phy *phy)
 165 {
 166         int ret;
 167
 168         if (!phy)
 169                 return 0;
 170
 171         ret = phy_pm_runtime_get_sync(phy);
 172         if (ret < 0 && ret != -ENOTSUPP)
 173                 return ret;
 174
 175         mutex_lock(&phy->mutex);
 176         if (phy->init_count == 0 && phy->ops->init) {
 177                 ret = phy->ops->init(phy);
 178                 if (ret < 0) {
 179                         dev_err(&phy->dev, "phy init failed --> %d\n", ret);
 180                         goto out;
 181                 }
 182         } else {
 183                 ret = 0; /* Override possible ret == -ENOTSUPP */
 184         }
 185         ++phy->init_count;
 186
 187 out:
 188         mutex_unlock(&phy->mutex);
 189         phy_pm_runtime_put(phy);
 190         return ret;
 191 }
 192 EXPORT_SYMBOL_GPL(phy_init);
 193
 194 int phy_exit(struct phy *phy)
 195 {
 196         int ret;
 197
 198         if (!phy)
 199                 return 0;
 200
 201         ret = phy_pm_runtime_get_sync(phy);
 202         if (ret < 0 && ret != -ENOTSUPP)
 203                 return ret;
 204
 205         mutex_lock(&phy->mutex);
 206         if (phy->init_count == 1 && phy->ops->exit) {
 207                 ret = phy->ops->exit(phy);
 208                 if (ret < 0) {
 209                         dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
 210                         goto out;
 211                 }
 212         }
 213         --phy->init_count;
 214
 215 out:
 216         mutex_unlock(&phy->mutex);
 217         phy_pm_runtime_put(phy);
 218         return ret;
 219 }
 220 EXPORT_SYMBOL_GPL(phy_exit);
 221
 222 int phy_power_on(struct phy *phy)
 223 {
 224         int ret;
 225
 226         if (!phy)
 227                 return 0;
 228
 229         ret = phy_pm_runtime_get_sync(phy);
 230         if (ret < 0 && ret != -ENOTSUPP)
 231                 return ret;
 232
 233         mutex_lock(&phy->mutex);
 234         if (phy->power_count == 0 && phy->ops->power_on) {
 235                 ret = phy->ops->power_on(phy);
 236                 if (ret < 0) {
 237                         dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
 238                         goto out;
 239                 }
 240         } else {
 241                 ret = 0; /* Override possible ret == -ENOTSUPP */
 242         }
 243         ++phy->power_count;
 244         mutex_unlock(&phy->mutex);
 245         return 0;
 246
 247 out:
 248         mutex_unlock(&phy->mutex);
 249         phy_pm_runtime_put_sync(phy);
 250
 251         return ret;
 252 }
 253 EXPORT_SYMBOL_GPL(phy_power_on);
 254
 255 int phy_power_off(struct phy *phy)
 256 {
 257         int ret;
 258
 259         if (!phy)
 260                 return 0;
 261
 262         mutex_lock(&phy->mutex);
 263         if (phy->power_count == 1 && phy->ops->power_off) {
 264                 ret =  phy->ops->power_off(phy);
 265                 if (ret < 0) {
 266                         dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
 267                         mutex_unlock(&phy->mutex);
 268                         return ret;
 269                 }
 270         }
 271         --phy->power_count;
 272         mutex_unlock(&phy->mutex);
 273         phy_pm_runtime_put(phy);
 274
 275         return 0;
 276 }
 277 EXPORT_SYMBOL_GPL(phy_power_off);
 278
 279 /**
 280  * _of_phy_get() - lookup and obtain a reference to a phy by phandle
 281  * @np: device_node for which to get the phy
 282  * @index: the index of the phy
 283  *
 284  * Returns the phy associated with the given phandle value,
 285  * after getting a refcount to it or -ENODEV if there is no such phy or
 286  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 287  * not yet loaded. This function uses of_xlate call back function provided
 288  * while registering the phy_provider to find the phy instance.
 289  */
 290 static struct phy *_of_phy_get(struct device_node *np, int index)
 291 {
 292         int ret;
 293         struct phy_provider *phy_provider;
 294         struct phy *phy = NULL;
 295         struct of_phandle_args args;
 296
 297         ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
 298                 index, &args);
 299         if (ret)
 300                 return ERR_PTR(-ENODEV);
 301
 302         mutex_lock(&phy_provider_mutex);
 303         phy_provider = of_phy_provider_lookup(args.np);
 304         if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
 305                 phy = ERR_PTR(-EPROBE_DEFER);
 306                 goto err0;
 307         }
 308
 309         phy = phy_provider->of_xlate(phy_provider->dev, &args);
 310         module_put(phy_provider->owner);
 311
 312 err0:
 313         mutex_unlock(&phy_provider_mutex);
 314         of_node_put(args.np);
 315
 316         return phy;
 317 }
 318
 319 /**
 320  * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
 321  * @np: device_node for which to get the phy
 322  * @con_id: name of the phy from device's point of view
 323  *
 324  * Returns the phy driver, after getting a refcount to it; or
 325  * -ENODEV if there is no such phy. The caller is responsible for
 326  * calling phy_put() to release that count.
 327  */
 328 struct phy *of_phy_get(struct device_node *np, const char *con_id)
 329 {
 330         struct phy *phy = NULL;
 331         int index = 0;
 332
 333         if (con_id)
 334                 index = of_property_match_string(np, "phy-names", con_id);
 335
 336         phy = _of_phy_get(np, index);
 337         if (IS_ERR(phy))
 338                 return phy;
 339
 340         if (!try_module_get(phy->ops->owner))
 341                 return ERR_PTR(-EPROBE_DEFER);
 342
 343         get_device(&phy->dev);
 344
 345         return phy;
 346 }
 347 EXPORT_SYMBOL_GPL(of_phy_get);
 348
 349 /**
 350  * phy_put() - release the PHY
 351  * @phy: the phy returned by phy_get()
 352  *
 353  * Releases a refcount the caller received from phy_get().
 354  */
 355 void phy_put(struct phy *phy)
 356 {
 357         if (!phy || IS_ERR(phy))
 358                 return;
 359
 360         module_put(phy->ops->owner);
 361         put_device(&phy->dev);
 362 }
 363 EXPORT_SYMBOL_GPL(phy_put);
 364
 365 /**
 366  * devm_phy_put() - release the PHY
 367  * @dev: device that wants to release this phy
 368  * @phy: the phy returned by devm_phy_get()
 369  *
 370  * destroys the devres associated with this phy and invokes phy_put
 371  * to release the phy.
 372  */
 373 void devm_phy_put(struct device *dev, struct phy *phy)
 374 {
 375         int r;
 376
 377         if (!phy)
 378                 return;
 379
 380         r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
 381         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 382 }
 383 EXPORT_SYMBOL_GPL(devm_phy_put);
 384
 385 /**
 386  * of_phy_simple_xlate() - returns the phy instance from phy provider
 387  * @dev: the PHY provider device
 388  * @args: of_phandle_args (not used here)
 389  *
 390  * Intended to be used by phy provider for the common case where #phy-cells is
 391  * 0. For other cases where #phy-cells is greater than '0', the phy provider
 392  * should provide a custom of_xlate function that reads the *args* and returns
 393  * the appropriate phy.
 394  */
 395 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
 396         *args)
 397 {
 398         struct phy *phy;
 399         struct class_dev_iter iter;
 400         struct device_node *node = dev->of_node;
 401
 402         class_dev_iter_init(&iter, phy_class, NULL, NULL);
 403         while ((dev = class_dev_iter_next(&iter))) {
 404                 phy = to_phy(dev);
 405                 if (node != phy->dev.of_node)
 406                         continue;
 407
 408                 class_dev_iter_exit(&iter);
 409                 return phy;
 410         }
 411
 412         class_dev_iter_exit(&iter);
 413         return ERR_PTR(-ENODEV);
 414 }
 415 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
 416
 417 /**
 418  * phy_get() - lookup and obtain a reference to a phy.
 419  * @dev: device that requests this phy
 420  * @string: the phy name as given in the dt data or the name of the controller
 421  * port for non-dt case
 422  *
 423  * Returns the phy driver, after getting a refcount to it; or
 424  * -ENODEV if there is no such phy.  The caller is responsible for
 425  * calling phy_put() to release that count.
 426  */
 427 struct phy *phy_get(struct device *dev, const char *string)
 428 {
 429         int index = 0;
 430         struct phy *phy;
 431
 432         if (string == NULL) {
 433                 dev_WARN(dev, "missing string\n");
 434                 return ERR_PTR(-EINVAL);
 435         }
 436
 437         if (dev->of_node) {
 438                 index = of_property_match_string(dev->of_node, "phy-names",
 439                         string);
 440                 phy = _of_phy_get(dev->of_node, index);
 441         } else {
 442                 phy = phy_lookup(dev, string);
 443         }
 444         if (IS_ERR(phy))
 445                 return phy;
 446
 447         if (!try_module_get(phy->ops->owner))
 448                 return ERR_PTR(-EPROBE_DEFER);
 449
 450         get_device(&phy->dev);
 451
 452         return phy;
 453 }
 454 EXPORT_SYMBOL_GPL(phy_get);
 455
 456 /**
 457  * phy_optional_get() - lookup and obtain a reference to an optional phy.
 458  * @dev: device that requests this phy
 459  * @string: the phy name as given in the dt data or the name of the controller
 460  * port for non-dt case
 461  *
 462  * Returns the phy driver, after getting a refcount to it; or
 463  * NULL if there is no such phy.  The caller is responsible for
 464  * calling phy_put() to release that count.
 465  */
 466 struct phy *phy_optional_get(struct device *dev, const char *string)
 467 {
 468         struct phy *phy = phy_get(dev, string);
 469
 470         if (PTR_ERR(phy) == -ENODEV)
 471                 phy = NULL;
 472
 473         return phy;
 474 }
 475 EXPORT_SYMBOL_GPL(phy_optional_get);
 476
 477 /**
 478  * devm_phy_get() - lookup and obtain a reference to a phy.
 479  * @dev: device that requests this phy
 480  * @string: the phy name as given in the dt data or phy device name
 481  * for non-dt case
 482  *
 483  * Gets the phy using phy_get(), and associates a device with it using
 484  * devres. On driver detach, release function is invoked on the devres data,
 485  * then, devres data is freed.
 486  */
 487 struct phy *devm_phy_get(struct device *dev, const char *string)
 488 {
 489         struct phy **ptr, *phy;
 490
 491         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 492         if (!ptr)
 493                 return ERR_PTR(-ENOMEM);
 494
 495         phy = phy_get(dev, string);
 496         if (!IS_ERR(phy)) {
 497                 *ptr = phy;
 498                 devres_add(dev, ptr);
 499         } else {
 500                 devres_free(ptr);
 501         }
 502
 503         return phy;
 504 }
 505 EXPORT_SYMBOL_GPL(devm_phy_get);
 506
 507 /**
 508  * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
 509  * @dev: device that requests this phy
 510  * @string: the phy name as given in the dt data or phy device name
 511  * for non-dt case
 512  *
 513  * Gets the phy using phy_get(), and associates a device with it using
 514  * devres. On driver detach, release function is invoked on the devres
 515  * data, then, devres data is freed. This differs to devm_phy_get() in
 516  * that if the phy does not exist, it is not considered an error and
 517  * -ENODEV will not be returned. Instead the NULL phy is returned,
 518  * which can be passed to all other phy consumer calls.
 519  */
 520 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
 521 {
 522         struct phy *phy = devm_phy_get(dev, string);
 523
 524         if (PTR_ERR(phy) == -ENODEV)
 525                 phy = NULL;
 526
 527         return phy;
 528 }
 529 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
 530
 531 /**
 532  * devm_of_phy_get() - lookup and obtain a reference to a phy.
 533  * @dev: device that requests this phy
 534  * @np: node containing the phy
 535  * @con_id: name of the phy from device's point of view
 536  *
 537  * Gets the phy using of_phy_get(), and associates a device with it using
 538  * devres. On driver detach, release function is invoked on the devres data,
 539  * then, devres data is freed.
 540  */
 541 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
 542                             const char *con_id)
 543 {
 544         struct phy **ptr, *phy;
 545
 546         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
 547         if (!ptr)
 548                 return ERR_PTR(-ENOMEM);
 549
 550         phy = of_phy_get(np, con_id);
 551         if (!IS_ERR(phy)) {
 552                 *ptr = phy;
 553                 devres_add(dev, ptr);
 554         } else {
 555                 devres_free(ptr);
 556         }
 557
 558         return phy;
 559 }
 560 EXPORT_SYMBOL_GPL(devm_of_phy_get);
 561
 562 /**
 563  * phy_create() - create a new phy
 564  * @dev: device that is creating the new phy
 565  * @ops: function pointers for performing phy operations
 566  * @init_data: contains the list of PHY consumers or NULL
 567  *
 568  * Called to create a phy using phy framework.
 569  */
 570 struct phy *phy_create(struct device *dev, const struct phy_ops *ops,
 571         struct phy_init_data *init_data)
 572 {
 573         int ret;
 574         int id;
 575         struct phy *phy;
 576
 577         if (WARN_ON(!dev))
 578                 return ERR_PTR(-EINVAL);
 579
 580         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
 581         if (!phy)
 582                 return ERR_PTR(-ENOMEM);
 583
 584         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
 585         if (id < 0) {
 586                 dev_err(dev, "unable to get id\n");
 587                 ret = id;
 588                 goto free_phy;
 589         }
 590
 591         device_initialize(&phy->dev);
 592         mutex_init(&phy->mutex);
 593
 594         phy->dev.class = phy_class;
 595         phy->dev.parent = dev;
 596         phy->dev.of_node = dev->of_node;
 597         phy->id = id;
 598         phy->ops = ops;
 599         phy->init_data = init_data;
 600
 601         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
 602         if (ret)
 603                 goto put_dev;
 604
 605         ret = device_add(&phy->dev);
 606         if (ret)
 607                 goto put_dev;
 608
 609         if (pm_runtime_enabled(dev)) {
 610                 pm_runtime_enable(&phy->dev);
 611                 pm_runtime_no_callbacks(&phy->dev);
 612         }
 613
 614         return phy;
 615
 616 put_dev:
 617         put_device(&phy->dev);
 618         ida_remove(&phy_ida, phy->id);
 619 free_phy:
 620         kfree(phy);
 621         return ERR_PTR(ret);
 622 }
 623 EXPORT_SYMBOL_GPL(phy_create);
 624
 625 /**
 626  * devm_phy_create() - create a new phy
 627  * @dev: device that is creating the new phy
 628  * @ops: function pointers for performing phy operations
 629  * @init_data: contains the list of PHY consumers or NULL
 630  *
 631  * Creates a new PHY device adding it to the PHY class.
 632  * While at that, it also associates the device with the phy using devres.
 633  * On driver detach, release function is invoked on the devres data,
 634  * then, devres data is freed.
 635  */
 636 struct phy *devm_phy_create(struct device *dev, const struct phy_ops *ops,
 637         struct phy_init_data *init_data)
 638 {
 639         struct phy **ptr, *phy;
 640
 641         ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
 642         if (!ptr)
 643                 return ERR_PTR(-ENOMEM);
 644
 645         phy = phy_create(dev, ops, init_data);
 646         if (!IS_ERR(phy)) {
 647                 *ptr = phy;
 648                 devres_add(dev, ptr);
 649         } else {
 650                 devres_free(ptr);
 651         }
 652
 653         return phy;
 654 }
 655 EXPORT_SYMBOL_GPL(devm_phy_create);
 656
 657 /**
 658  * phy_destroy() - destroy the phy
 659  * @phy: the phy to be destroyed
 660  *
 661  * Called to destroy the phy.
 662  */
 663 void phy_destroy(struct phy *phy)
 664 {
 665         pm_runtime_disable(&phy->dev);
 666         device_unregister(&phy->dev);
 667 }
 668 EXPORT_SYMBOL_GPL(phy_destroy);
 669
 670 /**
 671  * devm_phy_destroy() - destroy the PHY
 672  * @dev: device that wants to release this phy
 673  * @phy: the phy returned by devm_phy_get()
 674  *
 675  * destroys the devres associated with this phy and invokes phy_destroy
 676  * to destroy the phy.
 677  */
 678 void devm_phy_destroy(struct device *dev, struct phy *phy)
 679 {
 680         int r;
 681
 682         r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
 683         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 684 }
 685 EXPORT_SYMBOL_GPL(devm_phy_destroy);
 686
 687 /**
 688  * __of_phy_provider_register() - create/register phy provider with the framework
 689  * @dev: struct device of the phy provider
 690  * @owner: the module owner containing of_xlate
 691  * @of_xlate: function pointer to obtain phy instance from phy provider
 692  *
 693  * Creates struct phy_provider from dev and of_xlate function pointer.
 694  * This is used in the case of dt boot for finding the phy instance from
 695  * phy provider.
 696  */
 697 struct phy_provider *__of_phy_provider_register(struct device *dev,
 698         struct module *owner, struct phy * (*of_xlate)(struct device *dev,
 699         struct of_phandle_args *args))
 700 {
 701         struct phy_provider *phy_provider;
 702
 703         phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
 704         if (!phy_provider)
 705                 return ERR_PTR(-ENOMEM);
 706
 707         phy_provider->dev = dev;
 708         phy_provider->owner = owner;
 709         phy_provider->of_xlate = of_xlate;
 710
 711         mutex_lock(&phy_provider_mutex);
 712         list_add_tail(&phy_provider->list, &phy_provider_list);
 713         mutex_unlock(&phy_provider_mutex);
 714
 715         return phy_provider;
 716 }
 717 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
 718
 719 /**
 720  * __devm_of_phy_provider_register() - create/register phy provider with the
 721  * framework
 722  * @dev: struct device of the phy provider
 723  * @owner: the module owner containing of_xlate
 724  * @of_xlate: function pointer to obtain phy instance from phy provider
 725  *
 726  * Creates struct phy_provider from dev and of_xlate function pointer.
 727  * This is used in the case of dt boot for finding the phy instance from
 728  * phy provider. While at that, it also associates the device with the
 729  * phy provider using devres. On driver detach, release function is invoked
 730  * on the devres data, then, devres data is freed.
 731  */
 732 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
 733         struct module *owner, struct phy * (*of_xlate)(struct device *dev,
 734         struct of_phandle_args *args))
 735 {
 736         struct phy_provider **ptr, *phy_provider;
 737
 738         ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
 739         if (!ptr)
 740                 return ERR_PTR(-ENOMEM);
 741
 742         phy_provider = __of_phy_provider_register(dev, owner, of_xlate);
 743         if (!IS_ERR(phy_provider)) {
 744                 *ptr = phy_provider;
 745                 devres_add(dev, ptr);
 746         } else {
 747                 devres_free(ptr);
 748         }
 749
 750         return phy_provider;
 751 }
 752 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
 753
 754 /**
 755  * of_phy_provider_unregister() - unregister phy provider from the framework
 756  * @phy_provider: phy provider returned by of_phy_provider_register()
 757  *
 758  * Removes the phy_provider created using of_phy_provider_register().
 759  */
 760 void of_phy_provider_unregister(struct phy_provider *phy_provider)
 761 {
 762         if (IS_ERR(phy_provider))
 763                 return;
 764
 765         mutex_lock(&phy_provider_mutex);
 766         list_del(&phy_provider->list);
 767         kfree(phy_provider);
 768         mutex_unlock(&phy_provider_mutex);
 769 }
 770 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
 771
 772 /**
 773  * devm_of_phy_provider_unregister() - remove phy provider from the framework
 774  * @dev: struct device of the phy provider
 775  *
 776  * destroys the devres associated with this phy provider and invokes
 777  * of_phy_provider_unregister to unregister the phy provider.
 778  */
 779 void devm_of_phy_provider_unregister(struct device *dev,
 780         struct phy_provider *phy_provider) {
 781         int r;
 782
 783         r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
 784                 phy_provider);
 785         dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
 786 }
 787 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
 788
 789 /**
 790  * phy_release() - release the phy
 791  * @dev: the dev member within phy
 792  *
 793  * When the last reference to the device is removed, it is called
 794  * from the embedded kobject as release method.
 795  */
 796 static void phy_release(struct device *dev)
 797 {
 798         struct phy *phy;
 799
 800         phy = to_phy(dev);
 801         dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
 802         ida_remove(&phy_ida, phy->id);
 803         kfree(phy);
 804 }
 805
 806 static int __init phy_core_init(void)
 807 {
 808         phy_class = class_create(THIS_MODULE, "phy");
 809         if (IS_ERR(phy_class)) {
 810                 pr_err("failed to create phy class --> %ld\n",
 811                         PTR_ERR(phy_class));
 812                 return PTR_ERR(phy_class);
 813         }
 814
 815         phy_class->dev_release = phy_release;
 816
 817         return 0;
 818 }
 819 module_init(phy_core_init);
 820
 821 static void __exit phy_core_exit(void)
 822 {
 823         class_destroy(phy_class);
 824 }
 825 module_exit(phy_core_exit);
 826
 827 MODULE_DESCRIPTION("Generic PHY Framework");
 828 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 829 MODULE_LICENSE("GPL v2");