kernel/power/wakelock.c

   1 /* kernel/power/wakelock.c
   2  *
   3  * Copyright (C) 2005-2008 Google, Inc.
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/rtc.h>
  19 #include <linux/suspend.h>
  20 #include <linux/syscalls.h> /* sys_sync */
  21 #include <linux/wakelock.h>
  22 #ifdef CONFIG_WAKELOCK_STAT
  23 #include <linux/proc_fs.h>
  24 #endif
  25 #include "power.h"
  26
  27 enum {
  28         DEBUG_EXIT_SUSPEND = 1U << 0,
  29         DEBUG_WAKEUP = 1U << 1,
  30         DEBUG_SUSPEND = 1U << 2,
  31         DEBUG_EXPIRE = 1U << 3,
  32         DEBUG_WAKE_LOCK = 1U << 4,
  33 };
  34 static int debug_mask = DEBUG_EXIT_SUSPEND | DEBUG_WAKEUP;
  35 module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
  36
  37 #define WAKE_LOCK_TYPE_MASK              (0x0f)
  38 #define WAKE_LOCK_INITIALIZED            (1U << 8)
  39 #define WAKE_LOCK_ACTIVE                 (1U << 9)
  40 #define WAKE_LOCK_AUTO_EXPIRE            (1U << 10)
  41 #define WAKE_LOCK_PREVENTING_SUSPEND     (1U << 11)
  42
  43 static DEFINE_SPINLOCK(list_lock);
  44 static LIST_HEAD(inactive_locks);
  45 static struct list_head active_wake_locks[WAKE_LOCK_TYPE_COUNT];
  46 static int current_event_num;
  47 struct workqueue_struct *suspend_work_queue;
  48 struct wake_lock main_wake_lock;
  49 suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;
  50 static struct wake_lock unknown_wakeup;
  51
  52 #ifdef CONFIG_WAKELOCK_STAT
  53 static struct wake_lock deleted_wake_locks;
  54 static ktime_t last_sleep_time_update;
  55 static int wait_for_wakeup;
  56
  57 int get_expired_time(struct wake_lock *lock, ktime_t *expire_time)
  58 {
  59         struct timespec ts;
  60         struct timespec kt;
  61         struct timespec tomono;
  62         struct timespec delta;
  63         unsigned long seq;
  64         long timeout;
  65
  66         if (!(lock->flags & WAKE_LOCK_AUTO_EXPIRE))
  67                 return 0;
  68         do {
  69                 seq = read_seqbegin(&xtime_lock);
  70                 timeout = lock->expires - jiffies;
  71                 if (timeout > 0)
  72                         return 0;
  73                 kt = current_kernel_time();
  74                 tomono = wall_to_monotonic;
  75         } while (read_seqretry(&xtime_lock, seq));
  76         jiffies_to_timespec(-timeout, &delta);
  77         set_normalized_timespec(&ts, kt.tv_sec + tomono.tv_sec - delta.tv_sec,
  78                                 kt.tv_nsec + tomono.tv_nsec - delta.tv_nsec);
  79         *expire_time = timespec_to_ktime(ts);
  80         return 1;
  81 }
  82
  83
  84 static int print_lock_stat(struct seq_file *m, struct wake_lock *lock)
  85 {
  86         int lock_count = lock->stat.count;
  87         int expire_count = lock->stat.expire_count;
  88         ktime_t active_time = ktime_set(0, 0);
  89         ktime_t total_time = lock->stat.total_time;
  90         ktime_t max_time = lock->stat.max_time;
  91
  92         ktime_t prevent_suspend_time = lock->stat.prevent_suspend_time;
  93         if (lock->flags & WAKE_LOCK_ACTIVE) {
  94                 ktime_t now, add_time;
  95                 int expired = get_expired_time(lock, &now);
  96                 if (!expired)
  97                         now = ktime_get();
  98                 add_time = ktime_sub(now, lock->stat.last_time);
  99                 lock_count++;
 100                 if (!expired)
 101                         active_time = add_time;
 102                 else
 103                         expire_count++;
 104                 total_time = ktime_add(total_time, add_time);
 105                 if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND)
 106                         prevent_suspend_time = ktime_add(prevent_suspend_time,
 107                                         ktime_sub(now, last_sleep_time_update));
 108                 if (add_time.tv64 > max_time.tv64)
 109                         max_time = add_time;
 110         }
 111
 112         return seq_printf(m,
 113                      "\"%s\"\t%d\t%d\t%d\t%lld\t%lld\t%lld\t%lld\t%lld\n",
 114                      lock->name, lock_count, expire_count,
 115                      lock->stat.wakeup_count, ktime_to_ns(active_time),
 116                      ktime_to_ns(total_time),
 117                      ktime_to_ns(prevent_suspend_time), ktime_to_ns(max_time),
 118                      ktime_to_ns(lock->stat.last_time));
 119 }
 120
 121 static int wakelock_stats_show(struct seq_file *m, void *unused)
 122 {
 123         unsigned long irqflags;
 124         struct wake_lock *lock;
 125         int ret;
 126         int type;
 127
 128         spin_lock_irqsave(&list_lock, irqflags);
 129
 130         ret = seq_puts(m, "name\tcount\texpire_count\twake_count\tactive_since"
 131                         "\ttotal_time\tsleep_time\tmax_time\tlast_change\n");
 132         list_for_each_entry(lock, &inactive_locks, link)
 133                 ret = print_lock_stat(m, lock);
 134         for (type = 0; type < WAKE_LOCK_TYPE_COUNT; type++) {
 135                 list_for_each_entry(lock, &active_wake_locks[type], link)
 136                         ret = print_lock_stat(m, lock);
 137         }
 138         spin_unlock_irqrestore(&list_lock, irqflags);
 139         return 0;
 140 }
 141
 142 static void wake_unlock_stat_locked(struct wake_lock *lock, int expired)
 143 {
 144         ktime_t duration;
 145         ktime_t now;
 146         if (!(lock->flags & WAKE_LOCK_ACTIVE))
 147                 return;
 148         if (get_expired_time(lock, &now))
 149                 expired = 1;
 150         else
 151                 now = ktime_get();
 152         lock->stat.count++;
 153         if (expired)
 154                 lock->stat.expire_count++;
 155         duration = ktime_sub(now, lock->stat.last_time);
 156         lock->stat.total_time = ktime_add(lock->stat.total_time, duration);
 157         if (ktime_to_ns(duration) > ktime_to_ns(lock->stat.max_time))
 158                 lock->stat.max_time = duration;
 159         lock->stat.last_time = ktime_get();
 160         if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND) {
 161                 duration = ktime_sub(now, last_sleep_time_update);
 162                 lock->stat.prevent_suspend_time = ktime_add(
 163                         lock->stat.prevent_suspend_time, duration);
 164                 lock->flags &= ~WAKE_LOCK_PREVENTING_SUSPEND;
 165         }
 166 }
 167
 168 static void update_sleep_wait_stats_locked(int done)
 169 {
 170         struct wake_lock *lock;
 171         ktime_t now, etime, elapsed, add;
 172         int expired;
 173
 174         now = ktime_get();
 175         elapsed = ktime_sub(now, last_sleep_time_update);
 176         list_for_each_entry(lock, &active_wake_locks[WAKE_LOCK_SUSPEND], link) {
 177                 expired = get_expired_time(lock, &etime);
 178                 if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND) {
 179                         if (expired)
 180                                 add = ktime_sub(etime, last_sleep_time_update);
 181                         else
 182                                 add = elapsed;
 183                         lock->stat.prevent_suspend_time = ktime_add(
 184                                 lock->stat.prevent_suspend_time, add);
 185                 }
 186                 if (done || expired)
 187                         lock->flags &= ~WAKE_LOCK_PREVENTING_SUSPEND;
 188                 else
 189                         lock->flags |= WAKE_LOCK_PREVENTING_SUSPEND;
 190         }
 191         last_sleep_time_update = now;
 192 }
 193 #endif
 194
 195
 196 static void expire_wake_lock(struct wake_lock *lock)
 197 {
 198 #ifdef CONFIG_WAKELOCK_STAT
 199         wake_unlock_stat_locked(lock, 1);
 200 #endif
 201         lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);
 202         list_del(&lock->link);
 203         list_add(&lock->link, &inactive_locks);
 204         if (debug_mask & (DEBUG_WAKE_LOCK | DEBUG_EXPIRE))
 205                 pr_info("expired wake lock %s\n", lock->name);
 206 }
 207
 208 /* Caller must acquire the list_lock spinlock */
 209 static void print_active_locks(int type)
 210 {
 211         struct wake_lock *lock;
 212         bool print_expired = true;
 213
 214         BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
 215         list_for_each_entry(lock, &active_wake_locks[type], link) {
 216                 if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {
 217                         long timeout = lock->expires - jiffies;
 218                         if (timeout > 0)
 219                                 pr_info("active wake lock %s, time left %ld\n",
 220                                         lock->name, timeout);
 221                         else if (print_expired)
 222                                 pr_info("wake lock %s, expired\n", lock->name);
 223                 } else {
 224                         pr_info("active wake lock %s\n", lock->name);
 225                         if (!(debug_mask & DEBUG_EXPIRE))
 226                                 print_expired = false;
 227                 }
 228         }
 229 }
 230
 231 static long has_wake_lock_locked(int type)
 232 {
 233         struct wake_lock *lock, *n;
 234         long max_timeout = 0;
 235
 236         BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
 237         list_for_each_entry_safe(lock, n, &active_wake_locks[type], link) {
 238                 if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {
 239                         long timeout = lock->expires - jiffies;
 240                         if (timeout <= 0)
 241                                 expire_wake_lock(lock);
 242                         else if (timeout > max_timeout)
 243                                 max_timeout = timeout;
 244                 } else
 245                         return -1;
 246         }
 247         return max_timeout;
 248 }
 249
 250 long has_wake_lock(int type)
 251 {
 252         long ret;
 253         unsigned long irqflags;
 254         spin_lock_irqsave(&list_lock, irqflags);
 255         ret = has_wake_lock_locked(type);
 256         if (ret && (debug_mask & DEBUG_SUSPEND) && type == WAKE_LOCK_SUSPEND)
 257                 print_active_locks(type);
 258         spin_unlock_irqrestore(&list_lock, irqflags);
 259         return ret;
 260 }
 261
 262 static void suspend(struct work_struct *work)
 263 {
 264         int ret;
 265         int entry_event_num;
 266
 267         if (has_wake_lock(WAKE_LOCK_SUSPEND)) {
 268                 if (debug_mask & DEBUG_SUSPEND)
 269                         pr_info("suspend: abort suspend\n");
 270                 return;
 271         }
 272
 273         entry_event_num = current_event_num;
 274         sys_sync();
 275         if (debug_mask & DEBUG_SUSPEND)
 276                 pr_info("suspend: enter suspend\n");
 277         ret = pm_suspend(requested_suspend_state);
 278         if (debug_mask & DEBUG_EXIT_SUSPEND) {
 279                 struct timespec ts;
 280                 struct rtc_time tm;
 281                 getnstimeofday(&ts);
 282                 rtc_time_to_tm(ts.tv_sec, &tm);
 283                 pr_info("suspend: exit suspend, ret = %d "
 284                         "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,
 285                         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 286                         tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
 287         }
 288         if (current_event_num == entry_event_num) {
 289                 if (debug_mask & DEBUG_SUSPEND)
 290                         pr_info("suspend: pm_suspend returned with no event\n");
 291                 wake_lock_timeout(&unknown_wakeup, HZ / 2);
 292         }
 293 }
 294 static DECLARE_WORK(suspend_work, suspend);
 295
 296 static void expire_wake_locks(unsigned long data)
 297 {
 298         long has_lock;
 299         unsigned long irqflags;
 300         if (debug_mask & DEBUG_EXPIRE)
 301                 pr_info("expire_wake_locks: start\n");
 302         spin_lock_irqsave(&list_lock, irqflags);
 303         if (debug_mask & DEBUG_SUSPEND)
 304                 print_active_locks(WAKE_LOCK_SUSPEND);
 305         has_lock = has_wake_lock_locked(WAKE_LOCK_SUSPEND);
 306         if (debug_mask & DEBUG_EXPIRE)
 307                 pr_info("expire_wake_locks: done, has_lock %ld\n", has_lock);
 308         if (has_lock == 0)
 309                 queue_work(suspend_work_queue, &suspend_work);
 310         spin_unlock_irqrestore(&list_lock, irqflags);
 311 }
 312 static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0);
 313
 314 static int power_suspend_late(struct device *dev)
 315 {
 316         int ret = has_wake_lock(WAKE_LOCK_SUSPEND) ? -EAGAIN : 0;
 317 #ifdef CONFIG_WAKELOCK_STAT
 318         wait_for_wakeup = 1;
 319 #endif
 320         if (debug_mask & DEBUG_SUSPEND)
 321                 pr_info("power_suspend_late return %d\n", ret);
 322         return ret;
 323 }
 324
 325 static struct dev_pm_ops power_driver_pm_ops = {
 326         .suspend_noirq = power_suspend_late,
 327 };
 328
 329 static struct platform_driver power_driver = {
 330         .driver.name = "power",
 331         .driver.pm = &power_driver_pm_ops,
 332 };
 333 static struct platform_device power_device = {
 334         .name = "power",
 335 };
 336
 337 void wake_lock_init(struct wake_lock *lock, int type, const char *name)
 338 {
 339         unsigned long irqflags = 0;
 340
 341         if (name)
 342                 lock->name = name;
 343         BUG_ON(!lock->name);
 344
 345         if (debug_mask & DEBUG_WAKE_LOCK)
 346                 pr_info("wake_lock_init name=%s\n", lock->name);
 347 #ifdef CONFIG_WAKELOCK_STAT
 348         lock->stat.count = 0;
 349         lock->stat.expire_count = 0;
 350         lock->stat.wakeup_count = 0;
 351         lock->stat.total_time = ktime_set(0, 0);
 352         lock->stat.prevent_suspend_time = ktime_set(0, 0);
 353         lock->stat.max_time = ktime_set(0, 0);
 354         lock->stat.last_time = ktime_set(0, 0);
 355 #endif
 356         lock->flags = (type & WAKE_LOCK_TYPE_MASK) | WAKE_LOCK_INITIALIZED;
 357
 358         INIT_LIST_HEAD(&lock->link);
 359         spin_lock_irqsave(&list_lock, irqflags);
 360         list_add(&lock->link, &inactive_locks);
 361         spin_unlock_irqrestore(&list_lock, irqflags);
 362 }
 363 EXPORT_SYMBOL(wake_lock_init);
 364
 365 void wake_lock_destroy(struct wake_lock *lock)
 366 {
 367         unsigned long irqflags;
 368         if (debug_mask & DEBUG_WAKE_LOCK)
 369                 pr_info("wake_lock_destroy name=%s\n", lock->name);
 370         spin_lock_irqsave(&list_lock, irqflags);
 371         lock->flags &= ~WAKE_LOCK_INITIALIZED;
 372 #ifdef CONFIG_WAKELOCK_STAT
 373         if (lock->stat.count) {
 374                 deleted_wake_locks.stat.count += lock->stat.count;
 375                 deleted_wake_locks.stat.expire_count += lock->stat.expire_count;
 376                 deleted_wake_locks.stat.total_time =
 377                         ktime_add(deleted_wake_locks.stat.total_time,
 378                                   lock->stat.total_time);
 379                 deleted_wake_locks.stat.prevent_suspend_time =
 380                         ktime_add(deleted_wake_locks.stat.prevent_suspend_time,
 381                                   lock->stat.prevent_suspend_time);
 382                 deleted_wake_locks.stat.max_time =
 383                         ktime_add(deleted_wake_locks.stat.max_time,
 384                                   lock->stat.max_time);
 385         }
 386 #endif
 387         list_del(&lock->link);
 388         spin_unlock_irqrestore(&list_lock, irqflags);
 389 }
 390 EXPORT_SYMBOL(wake_lock_destroy);
 391
 392 static void wake_lock_internal(
 393         struct wake_lock *lock, long timeout, int has_timeout)
 394 {
 395         int type;
 396         unsigned long irqflags;
 397         long expire_in;
 398
 399         spin_lock_irqsave(&list_lock, irqflags);
 400         type = lock->flags & WAKE_LOCK_TYPE_MASK;
 401         BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
 402         BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));
 403 #ifdef CONFIG_WAKELOCK_STAT
 404         if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {
 405                 if (debug_mask & DEBUG_WAKEUP)
 406                         pr_info("wakeup wake lock: %s\n", lock->name);
 407                 wait_for_wakeup = 0;
 408                 lock->stat.wakeup_count++;
 409         }
 410         if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&
 411             (long)(lock->expires - jiffies) <= 0) {
 412                 wake_unlock_stat_locked(lock, 0);
 413                 lock->stat.last_time = ktime_get();
 414         }
 415 #endif
 416         if (!(lock->flags & WAKE_LOCK_ACTIVE)) {
 417                 lock->flags |= WAKE_LOCK_ACTIVE;
 418 #ifdef CONFIG_WAKELOCK_STAT
 419                 lock->stat.last_time = ktime_get();
 420 #endif
 421         }
 422         list_del(&lock->link);
 423         if (has_timeout) {
 424                 if (debug_mask & DEBUG_WAKE_LOCK)
 425                         pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",
 426                                 lock->name, type, timeout / HZ,
 427                                 (timeout % HZ) * MSEC_PER_SEC / HZ);
 428                 lock->expires = jiffies + timeout;
 429                 lock->flags |= WAKE_LOCK_AUTO_EXPIRE;
 430                 list_add_tail(&lock->link, &active_wake_locks[type]);
 431         } else {
 432                 if (debug_mask & DEBUG_WAKE_LOCK)
 433                         pr_info("wake_lock: %s, type %d\n", lock->name, type);
 434                 lock->expires = LONG_MAX;
 435                 lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;
 436                 list_add(&lock->link, &active_wake_locks[type]);
 437         }
 438         if (type == WAKE_LOCK_SUSPEND) {
 439                 current_event_num++;
 440 #ifdef CONFIG_WAKELOCK_STAT
 441                 if (lock == &main_wake_lock)
 442                         update_sleep_wait_stats_locked(1);
 443                 else if (!wake_lock_active(&main_wake_lock))
 444                         update_sleep_wait_stats_locked(0);
 445 #endif
 446                 if (has_timeout)
 447                         expire_in = has_wake_lock_locked(type);
 448                 else
 449                         expire_in = -1;
 450                 if (expire_in > 0) {
 451                         if (debug_mask & DEBUG_EXPIRE)
 452                                 pr_info("wake_lock: %s, start expire timer, "
 453                                         "%ld\n", lock->name, expire_in);
 454                         mod_timer(&expire_timer, jiffies + expire_in);
 455                 } else {
 456                         if (del_timer(&expire_timer))
 457                                 if (debug_mask & DEBUG_EXPIRE)
 458                                         pr_info("wake_lock: %s, stop expire timer\n",
 459                                                 lock->name);
 460                         if (expire_in == 0)
 461                                 queue_work(suspend_work_queue, &suspend_work);
 462                 }
 463         }
 464         spin_unlock_irqrestore(&list_lock, irqflags);
 465 }
 466
 467 void wake_lock(struct wake_lock *lock)
 468 {
 469         wake_lock_internal(lock, 0, 0);
 470 }
 471 EXPORT_SYMBOL(wake_lock);
 472
 473 void wake_lock_timeout(struct wake_lock *lock, long timeout)
 474 {
 475         wake_lock_internal(lock, timeout, 1);
 476 }
 477 EXPORT_SYMBOL(wake_lock_timeout);
 478
 479 void wake_unlock(struct wake_lock *lock)
 480 {
 481         int type;
 482         unsigned long irqflags;
 483         spin_lock_irqsave(&list_lock, irqflags);
 484         type = lock->flags & WAKE_LOCK_TYPE_MASK;
 485 #ifdef CONFIG_WAKELOCK_STAT
 486         wake_unlock_stat_locked(lock, 0);
 487 #endif
 488         if (debug_mask & DEBUG_WAKE_LOCK)
 489                 pr_info("wake_unlock: %s\n", lock->name);
 490         lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);
 491         list_del(&lock->link);
 492         list_add(&lock->link, &inactive_locks);
 493         if (type == WAKE_LOCK_SUSPEND) {
 494                 long has_lock = has_wake_lock_locked(type);
 495                 if (has_lock > 0) {
 496                         if (debug_mask & DEBUG_EXPIRE)
 497                                 pr_info("wake_unlock: %s, start expire timer, "
 498                                         "%ld\n", lock->name, has_lock);
 499                         mod_timer(&expire_timer, jiffies + has_lock);
 500                 } else {
 501                         if (del_timer(&expire_timer))
 502                                 if (debug_mask & DEBUG_EXPIRE)
 503                                         pr_info("wake_unlock: %s, stop expire "
 504                                                 "timer\n", lock->name);
 505                         if (has_lock == 0)
 506                                 queue_work(suspend_work_queue, &suspend_work);
 507                 }
 508                 if (lock == &main_wake_lock) {
 509                         if (debug_mask & DEBUG_SUSPEND)
 510                                 print_active_locks(WAKE_LOCK_SUSPEND);
 511 #ifdef CONFIG_WAKELOCK_STAT
 512                         update_sleep_wait_stats_locked(0);
 513 #endif
 514                 }
 515         }
 516         spin_unlock_irqrestore(&list_lock, irqflags);
 517 }
 518 EXPORT_SYMBOL(wake_unlock);
 519
 520 int wake_lock_active(struct wake_lock *lock)
 521 {
 522         return !!(lock->flags & WAKE_LOCK_ACTIVE);
 523 }
 524 EXPORT_SYMBOL(wake_lock_active);
 525
 526 static int wakelock_stats_open(struct inode *inode, struct file *file)
 527 {
 528         return single_open(file, wakelock_stats_show, NULL);
 529 }
 530
 531 static const struct file_operations wakelock_stats_fops = {
 532         .owner = THIS_MODULE,
 533         .open = wakelock_stats_open,
 534         .read = seq_read,
 535         .llseek = seq_lseek,
 536         .release = single_release,
 537 };
 538
 539 static int __init wakelocks_init(void)
 540 {
 541         int ret;
 542         int i;
 543
 544         for (i = 0; i < ARRAY_SIZE(active_wake_locks); i++)
 545                 INIT_LIST_HEAD(&active_wake_locks[i]);
 546
 547 #ifdef CONFIG_WAKELOCK_STAT
 548         wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,
 549                         "deleted_wake_locks");
 550 #endif
 551         wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "main");
 552         wake_lock(&main_wake_lock);
 553         wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");
 554
 555         ret = platform_device_register(&power_device);
 556         if (ret) {
 557                 pr_err("wakelocks_init: platform_device_register failed\n");
 558                 goto err_platform_device_register;
 559         }
 560         ret = platform_driver_register(&power_driver);
 561         if (ret) {
 562                 pr_err("wakelocks_init: platform_driver_register failed\n");
 563                 goto err_platform_driver_register;
 564         }
 565
 566         suspend_work_queue = create_singlethread_workqueue("suspend");
 567         if (suspend_work_queue == NULL) {
 568                 ret = -ENOMEM;
 569                 goto err_suspend_work_queue;
 570         }
 571
 572 #ifdef CONFIG_WAKELOCK_STAT
 573         proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops);
 574 #endif
 575
 576         return 0;
 577
 578 err_suspend_work_queue:
 579         platform_driver_unregister(&power_driver);
 580 err_platform_driver_register:
 581         platform_device_unregister(&power_device);
 582 err_platform_device_register:
 583         wake_lock_destroy(&unknown_wakeup);
 584         wake_lock_destroy(&main_wake_lock);
 585 #ifdef CONFIG_WAKELOCK_STAT
 586         wake_lock_destroy(&deleted_wake_locks);
 587 #endif
 588         return ret;
 589 }
 590
 591 static void  __exit wakelocks_exit(void)
 592 {
 593 #ifdef CONFIG_WAKELOCK_STAT
 594         remove_proc_entry("wakelocks", NULL);
 595 #endif
 596         destroy_workqueue(suspend_work_queue);
 597         platform_driver_unregister(&power_driver);
 598         platform_device_unregister(&power_device);
 599         wake_lock_destroy(&unknown_wakeup);
 600         wake_lock_destroy(&main_wake_lock);
 601 #ifdef CONFIG_WAKELOCK_STAT
 602         wake_lock_destroy(&deleted_wake_locks);
 603 #endif
 604 }
 605
 606 core_initcall(wakelocks_init);
 607 module_exit(wakelocks_exit);