GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 1 | /* |
Guan Xuetao | 2809e80 | 2011-05-26 16:43:27 +0800 | [diff] [blame] | 2 | * RTC driver code specific to PKUnity SoC and UniCore ISA |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 3 | * |
| 4 | * Maintained by GUAN Xue-tao <gxt@mprc.pku.edu.cn> |
| 5 | * Copyright (C) 2001-2010 Guan Xuetao |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License version 2 as |
| 9 | * published by the Free Software Foundation. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/fs.h> |
| 14 | #include <linux/string.h> |
| 15 | #include <linux/init.h> |
| 16 | #include <linux/platform_device.h> |
| 17 | #include <linux/interrupt.h> |
| 18 | #include <linux/rtc.h> |
| 19 | #include <linux/bcd.h> |
| 20 | #include <linux/clk.h> |
| 21 | #include <linux/log2.h> |
| 22 | #include <linux/slab.h> |
| 23 | #include <linux/uaccess.h> |
| 24 | #include <linux/io.h> |
| 25 | |
| 26 | #include <asm/irq.h> |
| 27 | #include <mach/hardware.h> |
| 28 | |
| 29 | static struct resource *puv3_rtc_mem; |
| 30 | |
| 31 | static int puv3_rtc_alarmno = IRQ_RTCAlarm; |
| 32 | static int puv3_rtc_tickno = IRQ_RTC; |
| 33 | |
| 34 | static DEFINE_SPINLOCK(puv3_rtc_pie_lock); |
| 35 | |
| 36 | /* IRQ Handlers */ |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 37 | static irqreturn_t puv3_rtc_alarmirq(int irq, void *id) |
| 38 | { |
| 39 | struct rtc_device *rdev = id; |
| 40 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 41 | writel(readl(RTC_RTSR) | RTC_RTSR_AL, RTC_RTSR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 42 | rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF); |
| 43 | return IRQ_HANDLED; |
| 44 | } |
| 45 | |
| 46 | static irqreturn_t puv3_rtc_tickirq(int irq, void *id) |
| 47 | { |
| 48 | struct rtc_device *rdev = id; |
| 49 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 50 | writel(readl(RTC_RTSR) | RTC_RTSR_HZ, RTC_RTSR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 51 | rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF); |
| 52 | return IRQ_HANDLED; |
| 53 | } |
| 54 | |
| 55 | /* Update control registers */ |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 56 | static void puv3_rtc_setaie(struct device *dev, int to) |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 57 | { |
| 58 | unsigned int tmp; |
| 59 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 60 | dev_dbg(dev, "%s: aie=%d\n", __func__, to); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 61 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 62 | tmp = readl(RTC_RTSR) & ~RTC_RTSR_ALE; |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 63 | |
| 64 | if (to) |
| 65 | tmp |= RTC_RTSR_ALE; |
| 66 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 67 | writel(tmp, RTC_RTSR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 68 | } |
| 69 | |
| 70 | static int puv3_rtc_setpie(struct device *dev, int enabled) |
| 71 | { |
| 72 | unsigned int tmp; |
| 73 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 74 | dev_debug(dev, "%s: pie=%d\n", __func__, enabled); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 75 | |
| 76 | spin_lock_irq(&puv3_rtc_pie_lock); |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 77 | tmp = readl(RTC_RTSR) & ~RTC_RTSR_HZE; |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 78 | |
| 79 | if (enabled) |
| 80 | tmp |= RTC_RTSR_HZE; |
| 81 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 82 | writel(tmp, RTC_RTSR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 83 | spin_unlock_irq(&puv3_rtc_pie_lock); |
| 84 | |
| 85 | return 0; |
| 86 | } |
| 87 | |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 88 | /* Time read/write */ |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 89 | static int puv3_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm) |
| 90 | { |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 91 | rtc_time_to_tm(readl(RTC_RCNR), rtc_tm); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 92 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 93 | dev_dbg(dev, "read time %02x.%02x.%02x %02x/%02x/%02x\n", |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 94 | rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday, |
| 95 | rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec); |
| 96 | |
| 97 | return 0; |
| 98 | } |
| 99 | |
| 100 | static int puv3_rtc_settime(struct device *dev, struct rtc_time *tm) |
| 101 | { |
| 102 | unsigned long rtc_count = 0; |
| 103 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 104 | dev_dbg(dev, "set time %02d.%02d.%02d %02d/%02d/%02d\n", |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 105 | tm->tm_year, tm->tm_mon, tm->tm_mday, |
| 106 | tm->tm_hour, tm->tm_min, tm->tm_sec); |
| 107 | |
| 108 | rtc_tm_to_time(tm, &rtc_count); |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 109 | writel(rtc_count, RTC_RCNR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 110 | |
| 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | static int puv3_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm) |
| 115 | { |
| 116 | struct rtc_time *alm_tm = &alrm->time; |
| 117 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 118 | rtc_time_to_tm(readl(RTC_RTAR), alm_tm); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 119 | |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 120 | alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE; |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 121 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 122 | dev_dbg(dev, "read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n", |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 123 | alrm->enabled, |
| 124 | alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday, |
| 125 | alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec); |
| 126 | |
| 127 | return 0; |
| 128 | } |
| 129 | |
| 130 | static int puv3_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) |
| 131 | { |
| 132 | struct rtc_time *tm = &alrm->time; |
| 133 | unsigned long rtcalarm_count = 0; |
| 134 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 135 | dev_dbg(dev, "puv3_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n", |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 136 | alrm->enabled, |
| 137 | tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff, |
| 138 | tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec); |
| 139 | |
| 140 | rtc_tm_to_time(tm, &rtcalarm_count); |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 141 | writel(rtcalarm_count, RTC_RTAR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 142 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 143 | puv3_rtc_setaie(&dev->dev, alrm->enabled); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 144 | |
| 145 | if (alrm->enabled) |
| 146 | enable_irq_wake(puv3_rtc_alarmno); |
| 147 | else |
| 148 | disable_irq_wake(puv3_rtc_alarmno); |
| 149 | |
| 150 | return 0; |
| 151 | } |
| 152 | |
| 153 | static int puv3_rtc_proc(struct device *dev, struct seq_file *seq) |
| 154 | { |
| 155 | seq_printf(seq, "periodic_IRQ\t: %s\n", |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 156 | (readl(RTC_RTSR) & RTC_RTSR_HZE) ? "yes" : "no"); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 157 | return 0; |
| 158 | } |
| 159 | |
| 160 | static int puv3_rtc_open(struct device *dev) |
| 161 | { |
| 162 | struct platform_device *pdev = to_platform_device(dev); |
| 163 | struct rtc_device *rtc_dev = platform_get_drvdata(pdev); |
| 164 | int ret; |
| 165 | |
| 166 | ret = request_irq(puv3_rtc_alarmno, puv3_rtc_alarmirq, |
Guan Xuetao | a9196b0 | 2011-12-23 09:15:39 +0800 | [diff] [blame] | 167 | 0, "pkunity-rtc alarm", rtc_dev); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 168 | |
| 169 | if (ret) { |
| 170 | dev_err(dev, "IRQ%d error %d\n", puv3_rtc_alarmno, ret); |
| 171 | return ret; |
| 172 | } |
| 173 | |
| 174 | ret = request_irq(puv3_rtc_tickno, puv3_rtc_tickirq, |
Guan Xuetao | a9196b0 | 2011-12-23 09:15:39 +0800 | [diff] [blame] | 175 | 0, "pkunity-rtc tick", rtc_dev); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 176 | |
| 177 | if (ret) { |
| 178 | dev_err(dev, "IRQ%d error %d\n", puv3_rtc_tickno, ret); |
| 179 | goto tick_err; |
| 180 | } |
| 181 | |
| 182 | return ret; |
| 183 | |
| 184 | tick_err: |
| 185 | free_irq(puv3_rtc_alarmno, rtc_dev); |
| 186 | return ret; |
| 187 | } |
| 188 | |
| 189 | static void puv3_rtc_release(struct device *dev) |
| 190 | { |
| 191 | struct platform_device *pdev = to_platform_device(dev); |
| 192 | struct rtc_device *rtc_dev = platform_get_drvdata(pdev); |
| 193 | |
| 194 | /* do not clear AIE here, it may be needed for wake */ |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 195 | puv3_rtc_setpie(dev, 0); |
| 196 | free_irq(puv3_rtc_alarmno, rtc_dev); |
| 197 | free_irq(puv3_rtc_tickno, rtc_dev); |
| 198 | } |
| 199 | |
| 200 | static const struct rtc_class_ops puv3_rtcops = { |
| 201 | .open = puv3_rtc_open, |
| 202 | .release = puv3_rtc_release, |
| 203 | .read_time = puv3_rtc_gettime, |
| 204 | .set_time = puv3_rtc_settime, |
| 205 | .read_alarm = puv3_rtc_getalarm, |
| 206 | .set_alarm = puv3_rtc_setalarm, |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 207 | .proc = puv3_rtc_proc, |
| 208 | }; |
| 209 | |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 210 | static void puv3_rtc_enable(struct device *dev, int en) |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 211 | { |
| 212 | if (!en) { |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 213 | writel(readl(RTC_RTSR) & ~RTC_RTSR_HZE, RTC_RTSR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 214 | } else { |
| 215 | /* re-enable the device, and check it is ok */ |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 216 | if ((readl(RTC_RTSR) & RTC_RTSR_HZE) == 0) { |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 217 | dev_info(dev, "rtc disabled, re-enabling\n"); |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 218 | writel(readl(RTC_RTSR) | RTC_RTSR_HZE, RTC_RTSR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 219 | } |
| 220 | } |
| 221 | } |
| 222 | |
Greg Kroah-Hartman | 5a167f4 | 2012-12-21 13:09:38 -0800 | [diff] [blame] | 223 | static int puv3_rtc_remove(struct platform_device *dev) |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 224 | { |
| 225 | struct rtc_device *rtc = platform_get_drvdata(dev); |
| 226 | |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 227 | rtc_device_unregister(rtc); |
| 228 | |
| 229 | puv3_rtc_setpie(&dev->dev, 0); |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 230 | puv3_rtc_setaie(&dev->dev, 0); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 231 | |
| 232 | release_resource(puv3_rtc_mem); |
| 233 | kfree(puv3_rtc_mem); |
| 234 | |
| 235 | return 0; |
| 236 | } |
| 237 | |
Greg Kroah-Hartman | 5a167f4 | 2012-12-21 13:09:38 -0800 | [diff] [blame] | 238 | static int puv3_rtc_probe(struct platform_device *pdev) |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 239 | { |
| 240 | struct rtc_device *rtc; |
| 241 | struct resource *res; |
| 242 | int ret; |
| 243 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 244 | dev_dbg(&pdev->dev, "%s: probe=%p\n", __func__, pdev); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 245 | |
| 246 | /* find the IRQs */ |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 247 | puv3_rtc_tickno = platform_get_irq(pdev, 1); |
| 248 | if (puv3_rtc_tickno < 0) { |
| 249 | dev_err(&pdev->dev, "no irq for rtc tick\n"); |
| 250 | return -ENOENT; |
| 251 | } |
| 252 | |
| 253 | puv3_rtc_alarmno = platform_get_irq(pdev, 0); |
| 254 | if (puv3_rtc_alarmno < 0) { |
| 255 | dev_err(&pdev->dev, "no irq for alarm\n"); |
| 256 | return -ENOENT; |
| 257 | } |
| 258 | |
Sangjung Woo | 1fbc4c4 | 2013-11-12 15:11:00 -0800 | [diff] [blame] | 259 | dev_dbg(&pdev->dev, "PKUnity_rtc: tick irq %d, alarm irq %d\n", |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 260 | puv3_rtc_tickno, puv3_rtc_alarmno); |
| 261 | |
| 262 | /* get the memory region */ |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 263 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 264 | if (res == NULL) { |
| 265 | dev_err(&pdev->dev, "failed to get memory region resource\n"); |
| 266 | return -ENOENT; |
| 267 | } |
| 268 | |
Joe Perches | 28f65c11 | 2011-06-09 09:13:32 -0700 | [diff] [blame] | 269 | puv3_rtc_mem = request_mem_region(res->start, resource_size(res), |
| 270 | pdev->name); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 271 | |
| 272 | if (puv3_rtc_mem == NULL) { |
| 273 | dev_err(&pdev->dev, "failed to reserve memory region\n"); |
| 274 | ret = -ENOENT; |
| 275 | goto err_nores; |
| 276 | } |
| 277 | |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 278 | puv3_rtc_enable(&pdev->dev, 1); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 279 | |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 280 | /* register RTC and exit */ |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 281 | rtc = rtc_device_register("pkunity", &pdev->dev, &puv3_rtcops, |
| 282 | THIS_MODULE); |
| 283 | |
| 284 | if (IS_ERR(rtc)) { |
| 285 | dev_err(&pdev->dev, "cannot attach rtc\n"); |
| 286 | ret = PTR_ERR(rtc); |
| 287 | goto err_nortc; |
| 288 | } |
| 289 | |
| 290 | /* platform setup code should have handled this; sigh */ |
| 291 | if (!device_can_wakeup(&pdev->dev)) |
| 292 | device_init_wakeup(&pdev->dev, 1); |
| 293 | |
| 294 | platform_set_drvdata(pdev, rtc); |
| 295 | return 0; |
| 296 | |
| 297 | err_nortc: |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 298 | puv3_rtc_enable(&pdev->dev, 0); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 299 | release_resource(puv3_rtc_mem); |
| 300 | |
| 301 | err_nores: |
| 302 | return ret; |
| 303 | } |
| 304 | |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 305 | #ifdef CONFIG_PM_SLEEP |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 306 | static int ticnt_save; |
| 307 | |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 308 | static int puv3_rtc_suspend(struct device *dev) |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 309 | { |
| 310 | /* save RTAR for anyone using periodic interrupts */ |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 311 | ticnt_save = readl(RTC_RTAR); |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 312 | puv3_rtc_enable(dev, 0); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 313 | return 0; |
| 314 | } |
| 315 | |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 316 | static int puv3_rtc_resume(struct device *dev) |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 317 | { |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 318 | puv3_rtc_enable(dev, 1); |
GuanXuetao | e5abf78 | 2011-02-26 21:21:18 +0800 | [diff] [blame] | 319 | writel(ticnt_save, RTC_RTAR); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 320 | return 0; |
| 321 | } |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 322 | #endif |
| 323 | |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 324 | static SIMPLE_DEV_PM_OPS(puv3_rtc_pm_ops, puv3_rtc_suspend, puv3_rtc_resume); |
| 325 | |
Guan Xuetao | b3a0aa3 | 2011-12-28 09:24:29 +0800 | [diff] [blame] | 326 | static struct platform_driver puv3_rtc_driver = { |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 327 | .probe = puv3_rtc_probe, |
Greg Kroah-Hartman | 5a167f4 | 2012-12-21 13:09:38 -0800 | [diff] [blame] | 328 | .remove = puv3_rtc_remove, |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 329 | .driver = { |
| 330 | .name = "PKUnity-v3-RTC", |
| 331 | .owner = THIS_MODULE, |
Jingoo Han | 5936fdb | 2013-04-29 16:21:02 -0700 | [diff] [blame] | 332 | .pm = &puv3_rtc_pm_ops, |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 333 | } |
| 334 | }; |
| 335 | |
Guan Xuetao | b3a0aa3 | 2011-12-28 09:24:29 +0800 | [diff] [blame] | 336 | module_platform_driver(puv3_rtc_driver); |
GuanXuetao | 02b2ee1 | 2011-01-15 18:19:03 +0800 | [diff] [blame] | 337 | |
| 338 | MODULE_DESCRIPTION("RTC Driver for the PKUnity v3 chip"); |
| 339 | MODULE_AUTHOR("Hu Dongliang"); |
| 340 | MODULE_LICENSE("GPL v2"); |