drivers/phy/phy-core.c

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