1 /* 2 * Freescale STMP37XX/STMP378X Real Time Clock driver 3 * 4 * Copyright (c) 2007 Sigmatel, Inc. 5 * Peter Hartley, <peter.hartley@sigmatel.com> 6 * 7 * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved. 8 * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved. 9 */ 10 11 /* 12 * The code contained herein is licensed under the GNU General Public 13 * License. You may obtain a copy of the GNU General Public License 14 * Version 2 or later at the following locations: 15 * 16 * http://www.opensource.org/licenses/gpl-license.html 17 * http://www.gnu.org/copyleft/gpl.html 18 */ 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/init.h> 22 #include <linux/platform_device.h> 23 #include <linux/interrupt.h> 24 #include <linux/rtc.h> 25 26 #include <mach/platform.h> 27 #include <mach/stmp3xxx.h> 28 #include <mach/regs-rtc.h> 29 30 struct stmp3xxx_rtc_data { 31 struct rtc_device *rtc; 32 unsigned irq_count; 33 void __iomem *io; 34 int irq_alarm, irq_1msec; 35 }; 36 37 static void stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data) 38 { 39 /* 40 * The datasheet doesn't say which way round the 41 * NEW_REGS/STALE_REGS bitfields go. In fact it's 0x1=P0, 42 * 0x2=P1, .., 0x20=P5, 0x40=ALARM, 0x80=SECONDS 43 */ 44 while (__raw_readl(rtc_data->io + HW_RTC_STAT) & 45 BF(0x80, RTC_STAT_STALE_REGS)) 46 cpu_relax(); 47 } 48 49 /* Time read/write */ 50 static int stmp3xxx_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm) 51 { 52 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev); 53 54 stmp3xxx_wait_time(rtc_data); 55 rtc_time_to_tm(__raw_readl(rtc_data->io + HW_RTC_SECONDS), rtc_tm); 56 return 0; 57 } 58 59 static int stmp3xxx_rtc_set_mmss(struct device *dev, unsigned long t) 60 { 61 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev); 62 63 __raw_writel(t, rtc_data->io + HW_RTC_SECONDS); 64 stmp3xxx_wait_time(rtc_data); 65 return 0; 66 } 67 68 /* interrupt(s) handler */ 69 static irqreturn_t stmp3xxx_rtc_interrupt(int irq, void *dev_id) 70 { 71 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev_id); 72 u32 status; 73 u32 events = 0; 74 75 status = __raw_readl(rtc_data->io + HW_RTC_CTRL) & 76 (BM_RTC_CTRL_ALARM_IRQ | BM_RTC_CTRL_ONEMSEC_IRQ); 77 78 if (status & BM_RTC_CTRL_ALARM_IRQ) { 79 stmp3xxx_clearl(BM_RTC_CTRL_ALARM_IRQ, 80 rtc_data->io + HW_RTC_CTRL); 81 events |= RTC_AF | RTC_IRQF; 82 } 83 84 if (status & BM_RTC_CTRL_ONEMSEC_IRQ) { 85 stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ, 86 rtc_data->io + HW_RTC_CTRL); 87 if (++rtc_data->irq_count % 1000 == 0) { 88 events |= RTC_UF | RTC_IRQF; 89 rtc_data->irq_count = 0; 90 } 91 } 92 93 if (events) 94 rtc_update_irq(rtc_data->rtc, 1, events); 95 96 return IRQ_HANDLED; 97 } 98 99 static int stmp3xxx_alarm_irq_enable(struct device *dev, unsigned int enabled) 100 { 101 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev); 102 void __iomem *p = rtc_data->io + HW_RTC_PERSISTENT0, 103 *ctl = rtc_data->io + HW_RTC_CTRL; 104 105 if (enabled) { 106 stmp3xxx_setl(BM_RTC_PERSISTENT0_ALARM_EN | 107 BM_RTC_PERSISTENT0_ALARM_WAKE_EN, p); 108 stmp3xxx_setl(BM_RTC_CTRL_ALARM_IRQ_EN, ctl); 109 } else { 110 stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN | 111 BM_RTC_PERSISTENT0_ALARM_WAKE_EN, p); 112 stmp3xxx_clearl(BM_RTC_CTRL_ALARM_IRQ_EN, ctl); 113 } 114 return 0; 115 } 116 117 static int stmp3xxx_update_irq_enable(struct device *dev, unsigned int enabled) 118 { 119 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev); 120 121 if (enabled) 122 stmp3xxx_setl(BM_RTC_CTRL_ONEMSEC_IRQ_EN, 123 rtc_data->io + HW_RTC_CTRL); 124 else 125 stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN, 126 rtc_data->io + HW_RTC_CTRL); 127 return 0; 128 } 129 130 static int stmp3xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 131 { 132 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev); 133 134 rtc_time_to_tm(__raw_readl(rtc_data->io + HW_RTC_ALARM), &alm->time); 135 return 0; 136 } 137 138 static int stmp3xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 139 { 140 unsigned long t; 141 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev); 142 143 rtc_tm_to_time(&alm->time, &t); 144 __raw_writel(t, rtc_data->io + HW_RTC_ALARM); 145 return 0; 146 } 147 148 static struct rtc_class_ops stmp3xxx_rtc_ops = { 149 .alarm_irq_enable = 150 stmp3xxx_alarm_irq_enable, 151 .update_irq_enable = 152 stmp3xxx_update_irq_enable, 153 .read_time = stmp3xxx_rtc_gettime, 154 .set_mmss = stmp3xxx_rtc_set_mmss, 155 .read_alarm = stmp3xxx_rtc_read_alarm, 156 .set_alarm = stmp3xxx_rtc_set_alarm, 157 }; 158 159 static int stmp3xxx_rtc_remove(struct platform_device *pdev) 160 { 161 struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev); 162 163 if (!rtc_data) 164 return 0; 165 166 stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN | BM_RTC_CTRL_ALARM_IRQ_EN, 167 rtc_data->io + HW_RTC_CTRL); 168 free_irq(rtc_data->irq_alarm, &pdev->dev); 169 free_irq(rtc_data->irq_1msec, &pdev->dev); 170 rtc_device_unregister(rtc_data->rtc); 171 iounmap(rtc_data->io); 172 kfree(rtc_data); 173 174 return 0; 175 } 176 177 static int stmp3xxx_rtc_probe(struct platform_device *pdev) 178 { 179 struct stmp3xxx_rtc_data *rtc_data; 180 struct resource *r; 181 int err; 182 183 rtc_data = kzalloc(sizeof *rtc_data, GFP_KERNEL); 184 if (!rtc_data) 185 return -ENOMEM; 186 187 r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 188 if (!r) { 189 dev_err(&pdev->dev, "failed to get resource\n"); 190 err = -ENXIO; 191 goto out_free; 192 } 193 194 rtc_data->io = ioremap(r->start, resource_size(r)); 195 if (!rtc_data->io) { 196 dev_err(&pdev->dev, "ioremap failed\n"); 197 err = -EIO; 198 goto out_free; 199 } 200 201 rtc_data->irq_alarm = platform_get_irq(pdev, 0); 202 rtc_data->irq_1msec = platform_get_irq(pdev, 1); 203 204 if (!(__raw_readl(HW_RTC_STAT + rtc_data->io) & 205 BM_RTC_STAT_RTC_PRESENT)) { 206 dev_err(&pdev->dev, "no device onboard\n"); 207 err = -ENODEV; 208 goto out_remap; 209 } 210 211 stmp3xxx_reset_block(rtc_data->io, true); 212 stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN | 213 BM_RTC_PERSISTENT0_ALARM_WAKE_EN | 214 BM_RTC_PERSISTENT0_ALARM_WAKE, 215 rtc_data->io + HW_RTC_PERSISTENT0); 216 rtc_data->rtc = rtc_device_register(pdev->name, &pdev->dev, 217 &stmp3xxx_rtc_ops, THIS_MODULE); 218 if (IS_ERR(rtc_data->rtc)) { 219 err = PTR_ERR(rtc_data->rtc); 220 goto out_remap; 221 } 222 223 rtc_data->irq_count = 0; 224 err = request_irq(rtc_data->irq_alarm, stmp3xxx_rtc_interrupt, 225 IRQF_DISABLED, "RTC alarm", &pdev->dev); 226 if (err) { 227 dev_err(&pdev->dev, "Cannot claim IRQ%d\n", 228 rtc_data->irq_alarm); 229 goto out_irq_alarm; 230 } 231 err = request_irq(rtc_data->irq_1msec, stmp3xxx_rtc_interrupt, 232 IRQF_DISABLED, "RTC tick", &pdev->dev); 233 if (err) { 234 dev_err(&pdev->dev, "Cannot claim IRQ%d\n", 235 rtc_data->irq_1msec); 236 goto out_irq1; 237 } 238 239 platform_set_drvdata(pdev, rtc_data); 240 241 return 0; 242 243 out_irq1: 244 free_irq(rtc_data->irq_alarm, &pdev->dev); 245 out_irq_alarm: 246 stmp3xxx_clearl(BM_RTC_CTRL_ONEMSEC_IRQ_EN | BM_RTC_CTRL_ALARM_IRQ_EN, 247 rtc_data->io + HW_RTC_CTRL); 248 rtc_device_unregister(rtc_data->rtc); 249 out_remap: 250 iounmap(rtc_data->io); 251 out_free: 252 kfree(rtc_data); 253 return err; 254 } 255 256 #ifdef CONFIG_PM 257 static int stmp3xxx_rtc_suspend(struct platform_device *dev, pm_message_t state) 258 { 259 return 0; 260 } 261 262 static int stmp3xxx_rtc_resume(struct platform_device *dev) 263 { 264 struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(dev); 265 266 stmp3xxx_reset_block(rtc_data->io, true); 267 stmp3xxx_clearl(BM_RTC_PERSISTENT0_ALARM_EN | 268 BM_RTC_PERSISTENT0_ALARM_WAKE_EN | 269 BM_RTC_PERSISTENT0_ALARM_WAKE, 270 rtc_data->io + HW_RTC_PERSISTENT0); 271 return 0; 272 } 273 #else 274 #define stmp3xxx_rtc_suspend NULL 275 #define stmp3xxx_rtc_resume NULL 276 #endif 277 278 static struct platform_driver stmp3xxx_rtcdrv = { 279 .probe = stmp3xxx_rtc_probe, 280 .remove = stmp3xxx_rtc_remove, 281 .suspend = stmp3xxx_rtc_suspend, 282 .resume = stmp3xxx_rtc_resume, 283 .driver = { 284 .name = "stmp3xxx-rtc", 285 .owner = THIS_MODULE, 286 }, 287 }; 288 289 static int __init stmp3xxx_rtc_init(void) 290 { 291 return platform_driver_register(&stmp3xxx_rtcdrv); 292 } 293 294 static void __exit stmp3xxx_rtc_exit(void) 295 { 296 platform_driver_unregister(&stmp3xxx_rtcdrv); 297 } 298 299 module_init(stmp3xxx_rtc_init); 300 module_exit(stmp3xxx_rtc_exit); 301 302 MODULE_DESCRIPTION("STMP3xxx RTC Driver"); 303 MODULE_AUTHOR("dmitry pervushin <dpervushin@embeddedalley.com>"); 304 MODULE_LICENSE("GPL"); 305