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