drivers/power/domain/power-domain-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016, NVIDIA CORPORATION.
   4  */
   5
   6 #define LOG_CATEGORY UCLASS_POWER_DOMAIN
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <log.h>
  11 #include <malloc.h>
  12 #include <power-domain.h>
  13 #include <power-domain-uclass.h>
  14 #include <dm/device-internal.h>
  15
  16 static inline struct power_domain_ops *power_domain_dev_ops(struct udevice *dev)
  17 {
  18         return (struct power_domain_ops *)dev->driver->ops;
  19 }
  20
  21 static int power_domain_of_xlate_default(struct power_domain *power_domain,
  22                                          struct ofnode_phandle_args *args)
  23 {
  24         debug("%s(power_domain=%p)\n", __func__, power_domain);
  25
  26         if (args->args_count != 1) {
  27                 debug("Invalid args_count: %d\n", args->args_count);
  28                 return -EINVAL;
  29         }
  30
  31         power_domain->id = args->args[0];
  32
  33         return 0;
  34 }
  35
  36 int power_domain_get_by_index(struct udevice *dev,
  37                               struct power_domain *power_domain, int index)
  38 {
  39         struct ofnode_phandle_args args;
  40         int ret;
  41         struct udevice *dev_power_domain;
  42         struct power_domain_ops *ops;
  43
  44         debug("%s(dev=%p, power_domain=%p)\n", __func__, dev, power_domain);
  45
  46         ret = dev_read_phandle_with_args(dev, "power-domains",
  47                                          "#power-domain-cells", 0, index,
  48                                          &args);
  49         if (ret) {
  50                 debug("%s: dev_read_phandle_with_args failed: %d\n",
  51                       __func__, ret);
  52                 return ret;
  53         }
  54
  55         ret = uclass_get_device_by_ofnode(UCLASS_POWER_DOMAIN, args.node,
  56                                           &dev_power_domain);
  57         if (ret) {
  58                 debug("%s: uclass_get_device_by_ofnode failed: %d\n",
  59                       __func__, ret);
  60                 return ret;
  61         }
  62         ops = power_domain_dev_ops(dev_power_domain);
  63
  64         power_domain->dev = dev_power_domain;
  65         if (ops->of_xlate)
  66                 ret = ops->of_xlate(power_domain, &args);
  67         else
  68                 ret = power_domain_of_xlate_default(power_domain, &args);
  69         if (ret) {
  70                 debug("of_xlate() failed: %d\n", ret);
  71                 return ret;
  72         }
  73
  74         ret = ops->request(power_domain);
  75         if (ret) {
  76                 debug("ops->request() failed: %d\n", ret);
  77                 return ret;
  78         }
  79
  80         return 0;
  81 }
  82
  83 int power_domain_get(struct udevice *dev, struct power_domain *power_domain)
  84 {
  85         return power_domain_get_by_index(dev, power_domain, 0);
  86 }
  87
  88 int power_domain_free(struct power_domain *power_domain)
  89 {
  90         struct power_domain_ops *ops = power_domain_dev_ops(power_domain->dev);
  91
  92         debug("%s(power_domain=%p)\n", __func__, power_domain);
  93
  94         return ops->rfree(power_domain);
  95 }
  96
  97 int power_domain_on(struct power_domain *power_domain)
  98 {
  99         struct power_domain_ops *ops = power_domain_dev_ops(power_domain->dev);
 100
 101         debug("%s(power_domain=%p)\n", __func__, power_domain);
 102
 103         return ops->on(power_domain);
 104 }
 105
 106 int power_domain_off(struct power_domain *power_domain)
 107 {
 108         struct power_domain_ops *ops = power_domain_dev_ops(power_domain->dev);
 109
 110         debug("%s(power_domain=%p)\n", __func__, power_domain);
 111
 112         return ops->off(power_domain);
 113 }
 114
 115 #if CONFIG_IS_ENABLED(OF_REAL)
 116 static int dev_power_domain_ctrl(struct udevice *dev, bool on)
 117 {
 118         struct power_domain pd;
 119         int i, count, ret = 0;
 120
 121         count = dev_count_phandle_with_args(dev, "power-domains",
 122                                             "#power-domain-cells", 0);
 123         for (i = 0; i < count; i++) {
 124                 ret = power_domain_get_by_index(dev, &pd, i);
 125                 if (ret)
 126                         return ret;
 127                 if (on)
 128                         ret = power_domain_on(&pd);
 129                 else
 130                         ret = power_domain_off(&pd);
 131         }
 132
 133         /*
 134          * For platforms with parent and child power-domain devices
 135          * we may not run device_remove() on the power-domain parent
 136          * because it will result in removing its children and switching
 137          * off their power-domain parent. So we will get here again and
 138          * again and will be stuck in an endless loop.
 139          */
 140         if (!on && dev_get_parent(dev) == pd.dev &&
 141             device_get_uclass_id(dev) == UCLASS_POWER_DOMAIN)
 142                 return ret;
 143
 144         /*
 145          * power_domain_get() bound the device, thus
 146          * we must remove it again to prevent unbinding
 147          * active devices (which would result in unbind
 148          * error).
 149          */
 150         if (count > 0 && !on)
 151                 device_remove(pd.dev, DM_REMOVE_NORMAL);
 152
 153         return ret;
 154 }
 155
 156 int dev_power_domain_on(struct udevice *dev)
 157 {
 158         return dev_power_domain_ctrl(dev, true);
 159 }
 160
 161 int dev_power_domain_off(struct udevice *dev)
 162 {
 163         return dev_power_domain_ctrl(dev, false);
 164 }
 165 #endif  /* OF_REAL */
 166
 167 UCLASS_DRIVER(power_domain) = {
 168         .id             = UCLASS_POWER_DOMAIN,
 169         .name           = "power_domain",
 170 };