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