1 /* 2 * rtc-palmas.c -- Palmas Real Time Clock driver. 3 4 * RTC driver for TI Palma series devices like TPS65913, 5 * TPS65914 power management IC. 6 * 7 * Copyright (c) 2012, NVIDIA Corporation. 8 * 9 * Author: Laxman Dewangan <ldewangan@nvidia.com> 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License as 13 * published by the Free Software Foundation version 2. 14 * 15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind, 16 * whether express or implied; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 23 * 02111-1307, USA 24 */ 25 26 #include <linux/bcd.h> 27 #include <linux/errno.h> 28 #include <linux/init.h> 29 #include <linux/interrupt.h> 30 #include <linux/kernel.h> 31 #include <linux/mfd/palmas.h> 32 #include <linux/module.h> 33 #include <linux/of.h> 34 #include <linux/rtc.h> 35 #include <linux/types.h> 36 #include <linux/platform_device.h> 37 #include <linux/pm.h> 38 39 struct palmas_rtc { 40 struct rtc_device *rtc; 41 struct device *dev; 42 unsigned int irq; 43 }; 44 45 /* Total number of RTC registers needed to set time*/ 46 #define PALMAS_NUM_TIME_REGS (PALMAS_YEARS_REG - PALMAS_SECONDS_REG + 1) 47 48 static int palmas_rtc_read_time(struct device *dev, struct rtc_time *tm) 49 { 50 unsigned char rtc_data[PALMAS_NUM_TIME_REGS]; 51 struct palmas *palmas = dev_get_drvdata(dev->parent); 52 int ret; 53 54 /* Copy RTC counting registers to static registers or latches */ 55 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG, 56 PALMAS_RTC_CTRL_REG_GET_TIME, PALMAS_RTC_CTRL_REG_GET_TIME); 57 if (ret < 0) { 58 dev_err(dev, "RTC CTRL reg update failed, err: %d\n", ret); 59 return ret; 60 } 61 62 ret = palmas_bulk_read(palmas, PALMAS_RTC_BASE, PALMAS_SECONDS_REG, 63 rtc_data, PALMAS_NUM_TIME_REGS); 64 if (ret < 0) { 65 dev_err(dev, "RTC_SECONDS reg read failed, err = %d\n", ret); 66 return ret; 67 } 68 69 tm->tm_sec = bcd2bin(rtc_data[0]); 70 tm->tm_min = bcd2bin(rtc_data[1]); 71 tm->tm_hour = bcd2bin(rtc_data[2]); 72 tm->tm_mday = bcd2bin(rtc_data[3]); 73 tm->tm_mon = bcd2bin(rtc_data[4]) - 1; 74 tm->tm_year = bcd2bin(rtc_data[5]) + 100; 75 76 return ret; 77 } 78 79 static int palmas_rtc_set_time(struct device *dev, struct rtc_time *tm) 80 { 81 unsigned char rtc_data[PALMAS_NUM_TIME_REGS]; 82 struct palmas *palmas = dev_get_drvdata(dev->parent); 83 int ret; 84 85 rtc_data[0] = bin2bcd(tm->tm_sec); 86 rtc_data[1] = bin2bcd(tm->tm_min); 87 rtc_data[2] = bin2bcd(tm->tm_hour); 88 rtc_data[3] = bin2bcd(tm->tm_mday); 89 rtc_data[4] = bin2bcd(tm->tm_mon + 1); 90 rtc_data[5] = bin2bcd(tm->tm_year - 100); 91 92 /* Stop RTC while updating the RTC time registers */ 93 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG, 94 PALMAS_RTC_CTRL_REG_STOP_RTC, 0); 95 if (ret < 0) { 96 dev_err(dev, "RTC stop failed, err = %d\n", ret); 97 return ret; 98 } 99 100 ret = palmas_bulk_write(palmas, PALMAS_RTC_BASE, PALMAS_SECONDS_REG, 101 rtc_data, PALMAS_NUM_TIME_REGS); 102 if (ret < 0) { 103 dev_err(dev, "RTC_SECONDS reg write failed, err = %d\n", ret); 104 return ret; 105 } 106 107 /* Start back RTC */ 108 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG, 109 PALMAS_RTC_CTRL_REG_STOP_RTC, PALMAS_RTC_CTRL_REG_STOP_RTC); 110 if (ret < 0) 111 dev_err(dev, "RTC start failed, err = %d\n", ret); 112 return ret; 113 } 114 115 static int palmas_rtc_alarm_irq_enable(struct device *dev, unsigned enabled) 116 { 117 struct palmas *palmas = dev_get_drvdata(dev->parent); 118 u8 val; 119 120 val = enabled ? PALMAS_RTC_INTERRUPTS_REG_IT_ALARM : 0; 121 return palmas_write(palmas, PALMAS_RTC_BASE, 122 PALMAS_RTC_INTERRUPTS_REG, val); 123 } 124 125 static int palmas_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 126 { 127 unsigned char alarm_data[PALMAS_NUM_TIME_REGS]; 128 u32 int_val; 129 struct palmas *palmas = dev_get_drvdata(dev->parent); 130 int ret; 131 132 ret = palmas_bulk_read(palmas, PALMAS_RTC_BASE, 133 PALMAS_ALARM_SECONDS_REG, 134 alarm_data, PALMAS_NUM_TIME_REGS); 135 if (ret < 0) { 136 dev_err(dev, "RTC_ALARM_SECONDS read failed, err = %d\n", ret); 137 return ret; 138 } 139 140 alm->time.tm_sec = bcd2bin(alarm_data[0]); 141 alm->time.tm_min = bcd2bin(alarm_data[1]); 142 alm->time.tm_hour = bcd2bin(alarm_data[2]); 143 alm->time.tm_mday = bcd2bin(alarm_data[3]); 144 alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1; 145 alm->time.tm_year = bcd2bin(alarm_data[5]) + 100; 146 147 ret = palmas_read(palmas, PALMAS_RTC_BASE, PALMAS_RTC_INTERRUPTS_REG, 148 &int_val); 149 if (ret < 0) { 150 dev_err(dev, "RTC_INTERRUPTS reg read failed, err = %d\n", ret); 151 return ret; 152 } 153 154 if (int_val & PALMAS_RTC_INTERRUPTS_REG_IT_ALARM) 155 alm->enabled = 1; 156 return ret; 157 } 158 159 static int palmas_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 160 { 161 unsigned char alarm_data[PALMAS_NUM_TIME_REGS]; 162 struct palmas *palmas = dev_get_drvdata(dev->parent); 163 int ret; 164 165 ret = palmas_rtc_alarm_irq_enable(dev, 0); 166 if (ret < 0) { 167 dev_err(dev, "Disable RTC alarm failed\n"); 168 return ret; 169 } 170 171 alarm_data[0] = bin2bcd(alm->time.tm_sec); 172 alarm_data[1] = bin2bcd(alm->time.tm_min); 173 alarm_data[2] = bin2bcd(alm->time.tm_hour); 174 alarm_data[3] = bin2bcd(alm->time.tm_mday); 175 alarm_data[4] = bin2bcd(alm->time.tm_mon + 1); 176 alarm_data[5] = bin2bcd(alm->time.tm_year - 100); 177 178 ret = palmas_bulk_write(palmas, PALMAS_RTC_BASE, 179 PALMAS_ALARM_SECONDS_REG, alarm_data, PALMAS_NUM_TIME_REGS); 180 if (ret < 0) { 181 dev_err(dev, "ALARM_SECONDS_REG write failed, err = %d\n", ret); 182 return ret; 183 } 184 185 if (alm->enabled) 186 ret = palmas_rtc_alarm_irq_enable(dev, 1); 187 return ret; 188 } 189 190 static int palmas_clear_interrupts(struct device *dev) 191 { 192 struct palmas *palmas = dev_get_drvdata(dev->parent); 193 unsigned int rtc_reg; 194 int ret; 195 196 ret = palmas_read(palmas, PALMAS_RTC_BASE, PALMAS_RTC_STATUS_REG, 197 &rtc_reg); 198 if (ret < 0) { 199 dev_err(dev, "RTC_STATUS read failed, err = %d\n", ret); 200 return ret; 201 } 202 203 ret = palmas_write(palmas, PALMAS_RTC_BASE, PALMAS_RTC_STATUS_REG, 204 rtc_reg); 205 if (ret < 0) { 206 dev_err(dev, "RTC_STATUS write failed, err = %d\n", ret); 207 return ret; 208 } 209 return 0; 210 } 211 212 static irqreturn_t palmas_rtc_interrupt(int irq, void *context) 213 { 214 struct palmas_rtc *palmas_rtc = context; 215 struct device *dev = palmas_rtc->dev; 216 int ret; 217 218 ret = palmas_clear_interrupts(dev); 219 if (ret < 0) { 220 dev_err(dev, "RTC interrupt clear failed, err = %d\n", ret); 221 return IRQ_NONE; 222 } 223 224 rtc_update_irq(palmas_rtc->rtc, 1, RTC_IRQF | RTC_AF); 225 return IRQ_HANDLED; 226 } 227 228 static struct rtc_class_ops palmas_rtc_ops = { 229 .read_time = palmas_rtc_read_time, 230 .set_time = palmas_rtc_set_time, 231 .read_alarm = palmas_rtc_read_alarm, 232 .set_alarm = palmas_rtc_set_alarm, 233 .alarm_irq_enable = palmas_rtc_alarm_irq_enable, 234 }; 235 236 static int palmas_rtc_probe(struct platform_device *pdev) 237 { 238 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); 239 struct palmas_rtc *palmas_rtc = NULL; 240 int ret; 241 242 palmas_rtc = devm_kzalloc(&pdev->dev, sizeof(struct palmas_rtc), 243 GFP_KERNEL); 244 if (!palmas_rtc) 245 return -ENOMEM; 246 247 /* Clear pending interrupts */ 248 ret = palmas_clear_interrupts(&pdev->dev); 249 if (ret < 0) { 250 dev_err(&pdev->dev, "clear RTC int failed, err = %d\n", ret); 251 return ret; 252 } 253 254 palmas_rtc->dev = &pdev->dev; 255 platform_set_drvdata(pdev, palmas_rtc); 256 257 /* Start RTC */ 258 ret = palmas_update_bits(palmas, PALMAS_RTC_BASE, PALMAS_RTC_CTRL_REG, 259 PALMAS_RTC_CTRL_REG_STOP_RTC, 260 PALMAS_RTC_CTRL_REG_STOP_RTC); 261 if (ret < 0) { 262 dev_err(&pdev->dev, "RTC_CTRL write failed, err = %d\n", ret); 263 return ret; 264 } 265 266 palmas_rtc->irq = platform_get_irq(pdev, 0); 267 268 device_init_wakeup(&pdev->dev, 1); 269 palmas_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 270 &palmas_rtc_ops, THIS_MODULE); 271 if (IS_ERR(palmas_rtc->rtc)) { 272 ret = PTR_ERR(palmas_rtc->rtc); 273 dev_err(&pdev->dev, "RTC register failed, err = %d\n", ret); 274 return ret; 275 } 276 277 ret = devm_request_threaded_irq(&pdev->dev, palmas_rtc->irq, NULL, 278 palmas_rtc_interrupt, 279 IRQF_TRIGGER_LOW | IRQF_ONESHOT | 280 IRQF_EARLY_RESUME, 281 dev_name(&pdev->dev), palmas_rtc); 282 if (ret < 0) { 283 dev_err(&pdev->dev, "IRQ request failed, err = %d\n", ret); 284 return ret; 285 } 286 287 return 0; 288 } 289 290 static int palmas_rtc_remove(struct platform_device *pdev) 291 { 292 palmas_rtc_alarm_irq_enable(&pdev->dev, 0); 293 return 0; 294 } 295 296 #ifdef CONFIG_PM_SLEEP 297 static int palmas_rtc_suspend(struct device *dev) 298 { 299 struct palmas_rtc *palmas_rtc = dev_get_drvdata(dev); 300 301 if (device_may_wakeup(dev)) 302 enable_irq_wake(palmas_rtc->irq); 303 return 0; 304 } 305 306 static int palmas_rtc_resume(struct device *dev) 307 { 308 struct palmas_rtc *palmas_rtc = dev_get_drvdata(dev); 309 310 if (device_may_wakeup(dev)) 311 disable_irq_wake(palmas_rtc->irq); 312 return 0; 313 } 314 #endif 315 316 static const struct dev_pm_ops palmas_rtc_pm_ops = { 317 SET_SYSTEM_SLEEP_PM_OPS(palmas_rtc_suspend, palmas_rtc_resume) 318 }; 319 320 #ifdef CONFIG_OF 321 static struct of_device_id of_palmas_rtc_match[] = { 322 { .compatible = "ti,palmas-rtc"}, 323 { }, 324 }; 325 MODULE_DEVICE_TABLE(of, of_palmas_rtc_match); 326 #endif 327 328 static struct platform_driver palmas_rtc_driver = { 329 .probe = palmas_rtc_probe, 330 .remove = palmas_rtc_remove, 331 .driver = { 332 .owner = THIS_MODULE, 333 .name = "palmas-rtc", 334 .pm = &palmas_rtc_pm_ops, 335 .of_match_table = of_match_ptr(of_palmas_rtc_match), 336 }, 337 }; 338 339 module_platform_driver(palmas_rtc_driver); 340 341 MODULE_ALIAS("platform:palmas_rtc"); 342 MODULE_DESCRIPTION("TI PALMAS series RTC driver"); 343 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>"); 344 MODULE_LICENSE("GPL v2"); 345