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