drivers/pmdomain/xilinx/zynqmp-pm-domains.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ZynqMP Generic PM domain support
   4  *
   5  *  Copyright (C) 2015-2019 Xilinx, Inc.
   6  *
   7  *  Davorin Mista <davorin.mista@aggios.com>
   8  *  Jolly Shah <jollys@xilinx.com>
   9  *  Rajan Vaja <rajan.vaja@xilinx.com>
  10  */
  11
  12 #include <linux/err.h>
  13 #include <linux/list.h>
  14 #include <linux/module.h>
  15 #include <linux/of_platform.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pm_domain.h>
  18 #include <linux/slab.h>
  19
  20 #include <linux/firmware/xlnx-zynqmp.h>
  21
  22 #define ZYNQMP_NUM_DOMAINS              (100)
  23
  24 static int min_capability;
  25
  26 /**
  27  * struct zynqmp_pm_domain - Wrapper around struct generic_pm_domain
  28  * @gpd:                Generic power domain
  29  * @node_id:            PM node ID corresponding to device inside PM domain
  30  * @requested:          The PM node mapped to the PM domain has been requested
  31  */
  32 struct zynqmp_pm_domain {
  33         struct generic_pm_domain gpd;
  34         u32 node_id;
  35         bool requested;
  36 };
  37
  38 #define to_zynqmp_pm_domain(pm_domain) \
  39         container_of(pm_domain, struct zynqmp_pm_domain, gpd)
  40
  41 /**
  42  * zynqmp_gpd_is_active_wakeup_path() - Check if device is in wakeup source
  43  *                                      path
  44  * @dev:        Device to check for wakeup source path
  45  * @not_used:   Data member (not required)
  46  *
  47  * This function is checks device's child hierarchy and checks if any device is
  48  * set as wakeup source.
  49  *
  50  * Return: 1 if device is in wakeup source path else 0
  51  */
  52 static int zynqmp_gpd_is_active_wakeup_path(struct device *dev, void *not_used)
  53 {
  54         int may_wakeup;
  55
  56         may_wakeup = device_may_wakeup(dev);
  57         if (may_wakeup)
  58                 return may_wakeup;
  59
  60         return device_for_each_child(dev, NULL,
  61                         zynqmp_gpd_is_active_wakeup_path);
  62 }
  63
  64 /**
  65  * zynqmp_gpd_power_on() - Power on PM domain
  66  * @domain:     Generic PM domain
  67  *
  68  * This function is called before devices inside a PM domain are resumed, to
  69  * power on PM domain.
  70  *
  71  * Return: 0 on success, error code otherwise
  72  */
  73 static int zynqmp_gpd_power_on(struct generic_pm_domain *domain)
  74 {
  75         struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain);
  76         int ret;
  77
  78         ret = zynqmp_pm_set_requirement(pd->node_id,
  79                                         ZYNQMP_PM_CAPABILITY_ACCESS,
  80                                         ZYNQMP_PM_MAX_QOS,
  81                                         ZYNQMP_PM_REQUEST_ACK_BLOCKING);
  82         if (ret) {
  83                 dev_err(&domain->dev,
  84                         "failed to set requirement to 0x%x for PM node id %d: %d\n",
  85                         ZYNQMP_PM_CAPABILITY_ACCESS, pd->node_id, ret);
  86                 return ret;
  87         }
  88
  89         dev_dbg(&domain->dev, "set requirement to 0x%x for PM node id %d\n",
  90                 ZYNQMP_PM_CAPABILITY_ACCESS, pd->node_id);
  91
  92         return 0;
  93 }
  94
  95 /**
  96  * zynqmp_gpd_power_off() - Power off PM domain
  97  * @domain:     Generic PM domain
  98  *
  99  * This function is called after devices inside a PM domain are suspended, to
 100  * power off PM domain.
 101  *
 102  * Return: 0 on success, error code otherwise
 103  */
 104 static int zynqmp_gpd_power_off(struct generic_pm_domain *domain)
 105 {
 106         struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain);
 107         int ret;
 108         struct pm_domain_data *pdd, *tmp;
 109         u32 capabilities = min_capability;
 110         bool may_wakeup;
 111
 112         /* If domain is already released there is nothing to be done */
 113         if (!pd->requested) {
 114                 dev_dbg(&domain->dev, "PM node id %d is already released\n",
 115                         pd->node_id);
 116                 return 0;
 117         }
 118
 119         list_for_each_entry_safe(pdd, tmp, &domain->dev_list, list_node) {
 120                 /* If device is in wakeup path, set capability to WAKEUP */
 121                 may_wakeup = zynqmp_gpd_is_active_wakeup_path(pdd->dev, NULL);
 122                 if (may_wakeup) {
 123                         dev_dbg(pdd->dev, "device is in wakeup path in %s\n",
 124                                 domain->name);
 125                         capabilities = ZYNQMP_PM_CAPABILITY_WAKEUP;
 126                         break;
 127                 }
 128         }
 129
 130         ret = zynqmp_pm_set_requirement(pd->node_id, capabilities, 0,
 131                                         ZYNQMP_PM_REQUEST_ACK_NO);
 132         if (ret) {
 133                 dev_err(&domain->dev,
 134                         "failed to set requirement to 0x%x for PM node id %d: %d\n",
 135                         capabilities, pd->node_id, ret);
 136                 return ret;
 137         }
 138
 139         dev_dbg(&domain->dev, "set requirement to 0x%x for PM node id %d\n",
 140                 capabilities, pd->node_id);
 141
 142         return 0;
 143 }
 144
 145 /**
 146  * zynqmp_gpd_attach_dev() - Attach device to the PM domain
 147  * @domain:     Generic PM domain
 148  * @dev:        Device to attach
 149  *
 150  * Return: 0 on success, error code otherwise
 151  */
 152 static int zynqmp_gpd_attach_dev(struct generic_pm_domain *domain,
 153                                  struct device *dev)
 154 {
 155         struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain);
 156         struct device_link *link;
 157         int ret;
 158
 159         link = device_link_add(dev, &domain->dev, DL_FLAG_SYNC_STATE_ONLY);
 160         if (!link)
 161                 dev_dbg(&domain->dev, "failed to create device link for %s\n",
 162                         dev_name(dev));
 163
 164         /* If this is not the first device to attach there is nothing to do */
 165         if (domain->device_count)
 166                 return 0;
 167
 168         ret = zynqmp_pm_request_node(pd->node_id, 0, 0,
 169                                      ZYNQMP_PM_REQUEST_ACK_BLOCKING);
 170         if (ret) {
 171                 dev_err(&domain->dev, "%s request failed for node %d: %d\n",
 172                         domain->name, pd->node_id, ret);
 173                 return ret;
 174         }
 175
 176         pd->requested = true;
 177
 178         dev_dbg(&domain->dev, "%s requested PM node id %d\n",
 179                 dev_name(dev), pd->node_id);
 180
 181         return 0;
 182 }
 183
 184 /**
 185  * zynqmp_gpd_detach_dev() - Detach device from the PM domain
 186  * @domain:     Generic PM domain
 187  * @dev:        Device to detach
 188  */
 189 static void zynqmp_gpd_detach_dev(struct generic_pm_domain *domain,
 190                                   struct device *dev)
 191 {
 192         struct zynqmp_pm_domain *pd = to_zynqmp_pm_domain(domain);
 193         int ret;
 194
 195         /* If this is not the last device to detach there is nothing to do */
 196         if (domain->device_count)
 197                 return;
 198
 199         ret = zynqmp_pm_release_node(pd->node_id);
 200         if (ret) {
 201                 dev_err(&domain->dev, "failed to release PM node id %d: %d\n",
 202                         pd->node_id, ret);
 203                 return;
 204         }
 205
 206         pd->requested = false;
 207
 208         dev_dbg(&domain->dev, "%s released PM node id %d\n",
 209                 dev_name(dev), pd->node_id);
 210 }
 211
 212 static struct generic_pm_domain *zynqmp_gpd_xlate
 213                                 (const struct of_phandle_args *genpdspec, void *data)
 214 {
 215         struct genpd_onecell_data *genpd_data = data;
 216         unsigned int i, idx = genpdspec->args[0];
 217         struct zynqmp_pm_domain *pd;
 218
 219         pd = to_zynqmp_pm_domain(genpd_data->domains[0]);
 220
 221         if (genpdspec->args_count != 1)
 222                 return ERR_PTR(-EINVAL);
 223
 224         /* Check for existing pm domains */
 225         for (i = 0; i < ZYNQMP_NUM_DOMAINS; i++) {
 226                 if (pd[i].node_id == idx)
 227                         goto done;
 228         }
 229
 230         /*
 231          * Add index in empty node_id of power domain list as no existing
 232          * power domain found for current index.
 233          */
 234         for (i = 0; i < ZYNQMP_NUM_DOMAINS; i++) {
 235                 if (pd[i].node_id == 0) {
 236                         pd[i].node_id = idx;
 237                         break;
 238                 }
 239         }
 240
 241 done:
 242         if (!genpd_data->domains[i] || i == ZYNQMP_NUM_DOMAINS)
 243                 return ERR_PTR(-ENOENT);
 244
 245         return genpd_data->domains[i];
 246 }
 247
 248 static int zynqmp_gpd_probe(struct platform_device *pdev)
 249 {
 250         int i;
 251         struct genpd_onecell_data *zynqmp_pd_data;
 252         struct generic_pm_domain **domains;
 253         struct zynqmp_pm_domain *pd;
 254         struct device *dev = &pdev->dev;
 255
 256         pd = devm_kcalloc(dev, ZYNQMP_NUM_DOMAINS, sizeof(*pd), GFP_KERNEL);
 257         if (!pd)
 258                 return -ENOMEM;
 259
 260         zynqmp_pd_data = devm_kzalloc(dev, sizeof(*zynqmp_pd_data), GFP_KERNEL);
 261         if (!zynqmp_pd_data)
 262                 return -ENOMEM;
 263
 264         zynqmp_pd_data->xlate = zynqmp_gpd_xlate;
 265
 266         domains = devm_kcalloc(dev, ZYNQMP_NUM_DOMAINS, sizeof(*domains),
 267                                GFP_KERNEL);
 268         if (!domains)
 269                 return -ENOMEM;
 270
 271         if (!of_device_is_compatible(dev->parent->of_node,
 272                                      "xlnx,zynqmp-firmware"))
 273                 min_capability = ZYNQMP_PM_CAPABILITY_UNUSABLE;
 274
 275         for (i = 0; i < ZYNQMP_NUM_DOMAINS; i++, pd++) {
 276                 pd->node_id = 0;
 277                 pd->gpd.name = kasprintf(GFP_KERNEL, "domain%d", i);
 278                 pd->gpd.power_off = zynqmp_gpd_power_off;
 279                 pd->gpd.power_on = zynqmp_gpd_power_on;
 280                 pd->gpd.attach_dev = zynqmp_gpd_attach_dev;
 281                 pd->gpd.detach_dev = zynqmp_gpd_detach_dev;
 282
 283                 domains[i] = &pd->gpd;
 284
 285                 /* Mark all PM domains as initially powered off */
 286                 pm_genpd_init(&pd->gpd, NULL, true);
 287         }
 288
 289         zynqmp_pd_data->domains = domains;
 290         zynqmp_pd_data->num_domains = ZYNQMP_NUM_DOMAINS;
 291         of_genpd_add_provider_onecell(dev->parent->of_node, zynqmp_pd_data);
 292
 293         return 0;
 294 }
 295
 296 static void zynqmp_gpd_remove(struct platform_device *pdev)
 297 {
 298         of_genpd_del_provider(pdev->dev.parent->of_node);
 299 }
 300
 301 static void zynqmp_gpd_sync_state(struct device *dev)
 302 {
 303         int ret;
 304
 305         ret = zynqmp_pm_init_finalize();
 306         if (ret)
 307                 dev_warn(dev, "failed to release power management to firmware\n");
 308 }
 309
 310 static struct platform_driver zynqmp_power_domain_driver = {
 311         .driver = {
 312                 .name = "zynqmp_power_controller",
 313                 .sync_state = zynqmp_gpd_sync_state,
 314         },
 315         .probe = zynqmp_gpd_probe,
 316         .remove = zynqmp_gpd_remove,
 317 };
 318 module_platform_driver(zynqmp_power_domain_driver);
 319
 320 MODULE_ALIAS("platform:zynqmp_power_controller");