drivers/base/power/clock_ops.c

   1 /*
   2  * drivers/base/power/clock_ops.c - Generic clock manipulation PM callbacks
   3  *
   4  * Copyright (c) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
   5  *
   6  * This file is released under the GPLv2.
   7  */
   8
   9 #include <linux/init.h>
  10 #include <linux/kernel.h>
  11 #include <linux/io.h>
  12 #include <linux/pm.h>
  13 #include <linux/pm_clock.h>
  14 #include <linux/clk.h>
  15 #include <linux/slab.h>
  16 #include <linux/err.h>
  17
  18 #ifdef CONFIG_PM
  19
  20 enum pce_status {
  21         PCE_STATUS_NONE = 0,
  22         PCE_STATUS_ACQUIRED,
  23         PCE_STATUS_ENABLED,
  24         PCE_STATUS_ERROR,
  25 };
  26
  27 struct pm_clock_entry {
  28         struct list_head node;
  29         char *con_id;
  30         struct clk *clk;
  31         enum pce_status status;
  32 };
  33
  34 /**
  35  * pm_clk_add - Start using a device clock for power management.
  36  * @dev: Device whose clock is going to be used for power management.
  37  * @con_id: Connection ID of the clock.
  38  *
  39  * Add the clock represented by @con_id to the list of clocks used for
  40  * the power management of @dev.
  41  */
  42 int pm_clk_add(struct device *dev, const char *con_id)
  43 {
  44         struct pm_subsys_data *psd = dev_to_psd(dev);
  45         struct pm_clock_entry *ce;
  46
  47         if (!psd)
  48                 return -EINVAL;
  49
  50         ce = kzalloc(sizeof(*ce), GFP_KERNEL);
  51         if (!ce) {
  52                 dev_err(dev, "Not enough memory for clock entry.\n");
  53                 return -ENOMEM;
  54         }
  55
  56         if (con_id) {
  57                 ce->con_id = kstrdup(con_id, GFP_KERNEL);
  58                 if (!ce->con_id) {
  59                         dev_err(dev,
  60                                 "Not enough memory for clock connection ID.\n");
  61                         kfree(ce);
  62                         return -ENOMEM;
  63                 }
  64         }
  65
  66         spin_lock_irq(&psd->lock);
  67         list_add_tail(&ce->node, &psd->clock_list);
  68         spin_unlock_irq(&psd->lock);
  69         return 0;
  70 }
  71
  72 /**
  73  * __pm_clk_remove - Destroy PM clock entry.
  74  * @ce: PM clock entry to destroy.
  75  *
  76  * This routine must be called under the spinlock protecting the PM list of
  77  * clocks corresponding the the @ce's device.
  78  */
  79 static void __pm_clk_remove(struct pm_clock_entry *ce)
  80 {
  81         if (!ce)
  82                 return;
  83
  84         list_del(&ce->node);
  85
  86         if (ce->status < PCE_STATUS_ERROR) {
  87                 if (ce->status == PCE_STATUS_ENABLED)
  88                         clk_disable(ce->clk);
  89
  90                 if (ce->status >= PCE_STATUS_ACQUIRED)
  91                         clk_put(ce->clk);
  92         }
  93
  94         if (ce->con_id)
  95                 kfree(ce->con_id);
  96
  97         kfree(ce);
  98 }
  99
 100 /**
 101  * pm_clk_remove - Stop using a device clock for power management.
 102  * @dev: Device whose clock should not be used for PM any more.
 103  * @con_id: Connection ID of the clock.
 104  *
 105  * Remove the clock represented by @con_id from the list of clocks used for
 106  * the power management of @dev.
 107  */
 108 void pm_clk_remove(struct device *dev, const char *con_id)
 109 {
 110         struct pm_subsys_data *psd = dev_to_psd(dev);
 111         struct pm_clock_entry *ce;
 112
 113         if (!psd)
 114                 return;
 115
 116         spin_lock_irq(&psd->lock);
 117
 118         list_for_each_entry(ce, &psd->clock_list, node) {
 119                 if (!con_id && !ce->con_id) {
 120                         __pm_clk_remove(ce);
 121                         break;
 122                 } else if (!con_id || !ce->con_id) {
 123                         continue;
 124                 } else if (!strcmp(con_id, ce->con_id)) {
 125                         __pm_clk_remove(ce);
 126                         break;
 127                 }
 128         }
 129
 130         spin_unlock_irq(&psd->lock);
 131 }
 132
 133 /**
 134  * pm_clk_init - Initialize a device's list of power management clocks.
 135  * @dev: Device to initialize the list of PM clocks for.
 136  *
 137  * Initialize the lock and clock_list members of the device's pm_subsys_data
 138  * object.
 139  */
 140 void pm_clk_init(struct device *dev)
 141 {
 142         struct pm_subsys_data *psd = dev_to_psd(dev);
 143         if (psd)
 144                 INIT_LIST_HEAD(&psd->clock_list);
 145 }
 146
 147 /**
 148  * pm_clk_create - Create and initialize a device's list of PM clocks.
 149  * @dev: Device to create and initialize the list of PM clocks for.
 150  *
 151  * Allocate a struct pm_subsys_data object, initialize its lock and clock_list
 152  * members and make the @dev's power.subsys_data field point to it.
 153  */
 154 int pm_clk_create(struct device *dev)
 155 {
 156         int ret = dev_pm_get_subsys_data(dev);
 157         return ret < 0 ? ret : 0;
 158 }
 159
 160 /**
 161  * pm_clk_destroy - Destroy a device's list of power management clocks.
 162  * @dev: Device to destroy the list of PM clocks for.
 163  *
 164  * Clear the @dev's power.subsys_data field, remove the list of clock entries
 165  * from the struct pm_subsys_data object pointed to by it before and free
 166  * that object.
 167  */
 168 void pm_clk_destroy(struct device *dev)
 169 {
 170         struct pm_subsys_data *psd = dev_to_psd(dev);
 171         struct pm_clock_entry *ce, *c;
 172
 173         if (!psd)
 174                 return;
 175
 176         spin_lock_irq(&psd->lock);
 177
 178         list_for_each_entry_safe_reverse(ce, c, &psd->clock_list, node)
 179                 __pm_clk_remove(ce);
 180
 181         spin_unlock_irq(&psd->lock);
 182
 183         dev_pm_put_subsys_data(dev);
 184 }
 185
 186 #endif /* CONFIG_PM */
 187
 188 #ifdef CONFIG_PM_RUNTIME
 189
 190 /**
 191  * pm_clk_acquire - Acquire a device clock.
 192  * @dev: Device whose clock is to be acquired.
 193  * @con_id: Connection ID of the clock.
 194  */
 195 static void pm_clk_acquire(struct device *dev,
 196                                     struct pm_clock_entry *ce)
 197 {
 198         ce->clk = clk_get(dev, ce->con_id);
 199         if (IS_ERR(ce->clk)) {
 200                 ce->status = PCE_STATUS_ERROR;
 201         } else {
 202                 ce->status = PCE_STATUS_ACQUIRED;
 203                 dev_dbg(dev, "Clock %s managed by runtime PM.\n", ce->con_id);
 204         }
 205 }
 206
 207 /**
 208  * pm_clk_suspend - Disable clocks in a device's PM clock list.
 209  * @dev: Device to disable the clocks for.
 210  */
 211 int pm_clk_suspend(struct device *dev)
 212 {
 213         struct pm_subsys_data *psd = dev_to_psd(dev);
 214         struct pm_clock_entry *ce;
 215         unsigned long flags;
 216
 217         dev_dbg(dev, "%s()\n", __func__);
 218
 219         if (!psd)
 220                 return 0;
 221
 222         spin_lock_irqsave(&psd->lock, flags);
 223
 224         list_for_each_entry_reverse(ce, &psd->clock_list, node) {
 225                 if (ce->status == PCE_STATUS_NONE)
 226                         pm_clk_acquire(dev, ce);
 227
 228                 if (ce->status < PCE_STATUS_ERROR) {
 229                         clk_disable(ce->clk);
 230                         ce->status = PCE_STATUS_ACQUIRED;
 231                 }
 232         }
 233
 234         spin_unlock_irqrestore(&psd->lock, flags);
 235
 236         return 0;
 237 }
 238
 239 /**
 240  * pm_clk_resume - Enable clocks in a device's PM clock list.
 241  * @dev: Device to enable the clocks for.
 242  */
 243 int pm_clk_resume(struct device *dev)
 244 {
 245         struct pm_subsys_data *psd = dev_to_psd(dev);
 246         struct pm_clock_entry *ce;
 247         unsigned long flags;
 248
 249         dev_dbg(dev, "%s()\n", __func__);
 250
 251         if (!psd)
 252                 return 0;
 253
 254         spin_lock_irqsave(&psd->lock, flags);
 255
 256         list_for_each_entry(ce, &psd->clock_list, node) {
 257                 if (ce->status == PCE_STATUS_NONE)
 258                         pm_clk_acquire(dev, ce);
 259
 260                 if (ce->status < PCE_STATUS_ERROR) {
 261                         clk_enable(ce->clk);
 262                         ce->status = PCE_STATUS_ENABLED;
 263                 }
 264         }
 265
 266         spin_unlock_irqrestore(&psd->lock, flags);
 267
 268         return 0;
 269 }
 270
 271 /**
 272  * pm_clk_notify - Notify routine for device addition and removal.
 273  * @nb: Notifier block object this function is a member of.
 274  * @action: Operation being carried out by the caller.
 275  * @data: Device the routine is being run for.
 276  *
 277  * For this function to work, @nb must be a member of an object of type
 278  * struct pm_clk_notifier_block containing all of the requisite data.
 279  * Specifically, the pm_domain member of that object is copied to the device's
 280  * pm_domain field and its con_ids member is used to populate the device's list
 281  * of PM clocks, depending on @action.
 282  *
 283  * If the device's pm_domain field is already populated with a value different
 284  * from the one stored in the struct pm_clk_notifier_block object, the function
 285  * does nothing.
 286  */
 287 static int pm_clk_notify(struct notifier_block *nb,
 288                                  unsigned long action, void *data)
 289 {
 290         struct pm_clk_notifier_block *clknb;
 291         struct device *dev = data;
 292         char **con_id;
 293         int error;
 294
 295         dev_dbg(dev, "%s() %ld\n", __func__, action);
 296
 297         clknb = container_of(nb, struct pm_clk_notifier_block, nb);
 298
 299         switch (action) {
 300         case BUS_NOTIFY_ADD_DEVICE:
 301                 if (dev->pm_domain)
 302                         break;
 303
 304                 error = pm_clk_create(dev);
 305                 if (error)
 306                         break;
 307
 308                 dev->pm_domain = clknb->pm_domain;
 309                 if (clknb->con_ids[0]) {
 310                         for (con_id = clknb->con_ids; *con_id; con_id++)
 311                                 pm_clk_add(dev, *con_id);
 312                 } else {
 313                         pm_clk_add(dev, NULL);
 314                 }
 315
 316                 break;
 317         case BUS_NOTIFY_DEL_DEVICE:
 318                 if (dev->pm_domain != clknb->pm_domain)
 319                         break;
 320
 321                 dev->pm_domain = NULL;
 322                 pm_clk_destroy(dev);
 323                 break;
 324         }
 325
 326         return 0;
 327 }
 328
 329 #else /* !CONFIG_PM_RUNTIME */
 330
 331 #ifdef CONFIG_PM
 332
 333 /**
 334  * pm_clk_suspend - Disable clocks in a device's PM clock list.
 335  * @dev: Device to disable the clocks for.
 336  */
 337 int pm_clk_suspend(struct device *dev)
 338 {
 339         struct pm_subsys_data *psd = dev_to_psd(dev);
 340         struct pm_clock_entry *ce;
 341         unsigned long flags;
 342
 343         dev_dbg(dev, "%s()\n", __func__);
 344
 345         /* If there is no driver, the clocks are already disabled. */
 346         if (!psd || !dev->driver)
 347                 return 0;
 348
 349         spin_lock_irqsave(&psd->lock, flags);
 350
 351         list_for_each_entry_reverse(ce, &psd->clock_list, node)
 352                 clk_disable(ce->clk);
 353
 354         spin_unlock_irqrestore(&psd->lock, flags);
 355
 356         return 0;
 357 }
 358
 359 /**
 360  * pm_clk_resume - Enable clocks in a device's PM clock list.
 361  * @dev: Device to enable the clocks for.
 362  */
 363 int pm_clk_resume(struct device *dev)
 364 {
 365         struct pm_subsys_data *psd = dev_to_psd(dev);
 366         struct pm_clock_entry *ce;
 367         unsigned long flags;
 368
 369         dev_dbg(dev, "%s()\n", __func__);
 370
 371         /* If there is no driver, the clocks should remain disabled. */
 372         if (!psd || !dev->driver)
 373                 return 0;
 374
 375         spin_lock_irqsave(&psd->lock, flags);
 376
 377         list_for_each_entry(ce, &psd->clock_list, node)
 378                 clk_enable(ce->clk);
 379
 380         spin_unlock_irqrestore(&psd->lock, flags);
 381
 382         return 0;
 383 }
 384
 385 #endif /* CONFIG_PM */
 386
 387 /**
 388  * enable_clock - Enable a device clock.
 389  * @dev: Device whose clock is to be enabled.
 390  * @con_id: Connection ID of the clock.
 391  */
 392 static void enable_clock(struct device *dev, const char *con_id)
 393 {
 394         struct clk *clk;
 395
 396         clk = clk_get(dev, con_id);
 397         if (!IS_ERR(clk)) {
 398                 clk_enable(clk);
 399                 clk_put(clk);
 400                 dev_info(dev, "Runtime PM disabled, clock forced on.\n");
 401         }
 402 }
 403
 404 /**
 405  * disable_clock - Disable a device clock.
 406  * @dev: Device whose clock is to be disabled.
 407  * @con_id: Connection ID of the clock.
 408  */
 409 static void disable_clock(struct device *dev, const char *con_id)
 410 {
 411         struct clk *clk;
 412
 413         clk = clk_get(dev, con_id);
 414         if (!IS_ERR(clk)) {
 415                 clk_disable(clk);
 416                 clk_put(clk);
 417                 dev_info(dev, "Runtime PM disabled, clock forced off.\n");
 418         }
 419 }
 420
 421 /**
 422  * pm_clk_notify - Notify routine for device addition and removal.
 423  * @nb: Notifier block object this function is a member of.
 424  * @action: Operation being carried out by the caller.
 425  * @data: Device the routine is being run for.
 426  *
 427  * For this function to work, @nb must be a member of an object of type
 428  * struct pm_clk_notifier_block containing all of the requisite data.
 429  * Specifically, the con_ids member of that object is used to enable or disable
 430  * the device's clocks, depending on @action.
 431  */
 432 static int pm_clk_notify(struct notifier_block *nb,
 433                                  unsigned long action, void *data)
 434 {
 435         struct pm_clk_notifier_block *clknb;
 436         struct device *dev = data;
 437         char **con_id;
 438
 439         dev_dbg(dev, "%s() %ld\n", __func__, action);
 440
 441         clknb = container_of(nb, struct pm_clk_notifier_block, nb);
 442
 443         switch (action) {
 444         case BUS_NOTIFY_BIND_DRIVER:
 445                 if (clknb->con_ids[0]) {
 446                         for (con_id = clknb->con_ids; *con_id; con_id++)
 447                                 enable_clock(dev, *con_id);
 448                 } else {
 449                         enable_clock(dev, NULL);
 450                 }
 451                 break;
 452         case BUS_NOTIFY_UNBOUND_DRIVER:
 453                 if (clknb->con_ids[0]) {
 454                         for (con_id = clknb->con_ids; *con_id; con_id++)
 455                                 disable_clock(dev, *con_id);
 456                 } else {
 457                         disable_clock(dev, NULL);
 458                 }
 459                 break;
 460         }
 461
 462         return 0;
 463 }
 464
 465 #endif /* !CONFIG_PM_RUNTIME */
 466
 467 /**
 468  * pm_clk_add_notifier - Add bus type notifier for power management clocks.
 469  * @bus: Bus type to add the notifier to.
 470  * @clknb: Notifier to be added to the given bus type.
 471  *
 472  * The nb member of @clknb is not expected to be initialized and its
 473  * notifier_call member will be replaced with pm_clk_notify().  However,
 474  * the remaining members of @clknb should be populated prior to calling this
 475  * routine.
 476  */
 477 void pm_clk_add_notifier(struct bus_type *bus,
 478                                  struct pm_clk_notifier_block *clknb)
 479 {
 480         if (!bus || !clknb)
 481                 return;
 482
 483         clknb->nb.notifier_call = pm_clk_notify;
 484         bus_register_notifier(bus, &clknb->nb);
 485 }