kernel/arch/powerpc/sysdev/fsl_mpic_timer_wakeup.c

   1 /*
   2  * MPIC timer wakeup driver
   3  *
   4  * Copyright 2013 Freescale Semiconductor, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2 of the License, or (at your
   9  * option) any later version.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/slab.h>
  14 #include <linux/errno.h>
  15 #include <linux/module.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/device.h>
  18
  19 #include <asm/mpic_timer.h>
  20 #include <asm/mpic.h>
  21
  22 struct fsl_mpic_timer_wakeup {
  23         struct mpic_timer *timer;
  24         struct work_struct free_work;
  25 };
  26
  27 static struct fsl_mpic_timer_wakeup *fsl_wakeup;
  28 static DEFINE_MUTEX(sysfs_lock);
  29
  30 static void fsl_free_resource(struct work_struct *ws)
  31 {
  32         struct fsl_mpic_timer_wakeup *wakeup =
  33                 container_of(ws, struct fsl_mpic_timer_wakeup, free_work);
  34
  35         mutex_lock(&sysfs_lock);
  36
  37         if (wakeup->timer) {
  38                 disable_irq_wake(wakeup->timer->irq);
  39                 mpic_free_timer(wakeup->timer);
  40         }
  41
  42         wakeup->timer = NULL;
  43         mutex_unlock(&sysfs_lock);
  44 }
  45
  46 static irqreturn_t fsl_mpic_timer_irq(int irq, void *dev_id)
  47 {
  48         struct fsl_mpic_timer_wakeup *wakeup = dev_id;
  49
  50         schedule_work(&wakeup->free_work);
  51
  52         return wakeup->timer ? IRQ_HANDLED : IRQ_NONE;
  53 }
  54
  55 static ssize_t fsl_timer_wakeup_show(struct device *dev,
  56                                 struct device_attribute *attr,
  57                                 char *buf)
  58 {
  59         struct timeval interval;
  60         int val = 0;
  61
  62         mutex_lock(&sysfs_lock);
  63         if (fsl_wakeup->timer) {
  64                 mpic_get_remain_time(fsl_wakeup->timer, &interval);
  65                 val = interval.tv_sec + 1;
  66         }
  67         mutex_unlock(&sysfs_lock);
  68
  69         return sprintf(buf, "%d\n", val);
  70 }
  71
  72 static ssize_t fsl_timer_wakeup_store(struct device *dev,
  73                                 struct device_attribute *attr,
  74                                 const char *buf,
  75                                 size_t count)
  76 {
  77         struct timeval interval;
  78         int ret;
  79
  80         interval.tv_usec = 0;
  81         if (kstrtol(buf, 0, &interval.tv_sec))
  82                 return -EINVAL;
  83
  84         mutex_lock(&sysfs_lock);
  85
  86         if (fsl_wakeup->timer) {
  87                 disable_irq_wake(fsl_wakeup->timer->irq);
  88                 mpic_free_timer(fsl_wakeup->timer);
  89                 fsl_wakeup->timer = NULL;
  90         }
  91
  92         if (!interval.tv_sec) {
  93                 mutex_unlock(&sysfs_lock);
  94                 return count;
  95         }
  96
  97         fsl_wakeup->timer = mpic_request_timer(fsl_mpic_timer_irq,
  98                                                 fsl_wakeup, &interval);
  99         if (!fsl_wakeup->timer) {
 100                 mutex_unlock(&sysfs_lock);
 101                 return -EINVAL;
 102         }
 103
 104         ret = enable_irq_wake(fsl_wakeup->timer->irq);
 105         if (ret) {
 106                 mpic_free_timer(fsl_wakeup->timer);
 107                 fsl_wakeup->timer = NULL;
 108                 mutex_unlock(&sysfs_lock);
 109
 110                 return ret;
 111         }
 112
 113         mpic_start_timer(fsl_wakeup->timer);
 114
 115         mutex_unlock(&sysfs_lock);
 116
 117         return count;
 118 }
 119
 120 static struct device_attribute mpic_attributes = __ATTR(timer_wakeup, 0644,
 121                         fsl_timer_wakeup_show, fsl_timer_wakeup_store);
 122
 123 static int __init fsl_wakeup_sys_init(void)
 124 {
 125         int ret;
 126
 127         fsl_wakeup = kzalloc(sizeof(struct fsl_mpic_timer_wakeup), GFP_KERNEL);
 128         if (!fsl_wakeup)
 129                 return -ENOMEM;
 130
 131         INIT_WORK(&fsl_wakeup->free_work, fsl_free_resource);
 132
 133         ret = device_create_file(mpic_subsys.dev_root, &mpic_attributes);
 134         if (ret)
 135                 kfree(fsl_wakeup);
 136
 137         return ret;
 138 }
 139
 140 static void __exit fsl_wakeup_sys_exit(void)
 141 {
 142         device_remove_file(mpic_subsys.dev_root, &mpic_attributes);
 143
 144         mutex_lock(&sysfs_lock);
 145
 146         if (fsl_wakeup->timer) {
 147                 disable_irq_wake(fsl_wakeup->timer->irq);
 148                 mpic_free_timer(fsl_wakeup->timer);
 149         }
 150
 151         kfree(fsl_wakeup);
 152
 153         mutex_unlock(&sysfs_lock);
 154 }
 155
 156 module_init(fsl_wakeup_sys_init);
 157 module_exit(fsl_wakeup_sys_exit);
 158
 159 MODULE_DESCRIPTION("Freescale MPIC global timer wakeup driver");
 160 MODULE_LICENSE("GPL v2");
 161 MODULE_AUTHOR("Wang Dongsheng <dongsheng.wang@freescale.com>");