1 /* 2 * Real Time Clock driver for Marvell 88PM80x PMIC 3 * 4 * Copyright (c) 2012 Marvell International Ltd. 5 * Wenzeng Chen<wzch@marvell.com> 6 * Qiao Zhou <zhouqiao@marvell.com> 7 * 8 * This file is subject to the terms and conditions of the GNU General 9 * Public License. See the file "COPYING" in the main directory of this 10 * archive for more details. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/slab.h> 25 #include <linux/regmap.h> 26 #include <linux/mfd/core.h> 27 #include <linux/mfd/88pm80x.h> 28 #include <linux/rtc.h> 29 30 #define PM800_RTC_COUNTER1 (0xD1) 31 #define PM800_RTC_COUNTER2 (0xD2) 32 #define PM800_RTC_COUNTER3 (0xD3) 33 #define PM800_RTC_COUNTER4 (0xD4) 34 #define PM800_RTC_EXPIRE1_1 (0xD5) 35 #define PM800_RTC_EXPIRE1_2 (0xD6) 36 #define PM800_RTC_EXPIRE1_3 (0xD7) 37 #define PM800_RTC_EXPIRE1_4 (0xD8) 38 #define PM800_RTC_TRIM1 (0xD9) 39 #define PM800_RTC_TRIM2 (0xDA) 40 #define PM800_RTC_TRIM3 (0xDB) 41 #define PM800_RTC_TRIM4 (0xDC) 42 #define PM800_RTC_EXPIRE2_1 (0xDD) 43 #define PM800_RTC_EXPIRE2_2 (0xDE) 44 #define PM800_RTC_EXPIRE2_3 (0xDF) 45 #define PM800_RTC_EXPIRE2_4 (0xE0) 46 47 #define PM800_POWER_DOWN_LOG1 (0xE5) 48 #define PM800_POWER_DOWN_LOG2 (0xE6) 49 50 struct pm80x_rtc_info { 51 struct pm80x_chip *chip; 52 struct regmap *map; 53 struct rtc_device *rtc_dev; 54 struct device *dev; 55 56 int irq; 57 }; 58 59 static irqreturn_t rtc_update_handler(int irq, void *data) 60 { 61 struct pm80x_rtc_info *info = (struct pm80x_rtc_info *)data; 62 int mask; 63 64 mask = PM800_ALARM | PM800_ALARM_WAKEUP; 65 regmap_update_bits(info->map, PM800_RTC_CONTROL, mask | PM800_ALARM1_EN, 66 mask); 67 rtc_update_irq(info->rtc_dev, 1, RTC_AF); 68 return IRQ_HANDLED; 69 } 70 71 static int pm80x_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 72 { 73 struct pm80x_rtc_info *info = dev_get_drvdata(dev); 74 75 if (enabled) 76 regmap_update_bits(info->map, PM800_RTC_CONTROL, 77 PM800_ALARM1_EN, PM800_ALARM1_EN); 78 else 79 regmap_update_bits(info->map, PM800_RTC_CONTROL, 80 PM800_ALARM1_EN, 0); 81 return 0; 82 } 83 84 /* 85 * Calculate the next alarm time given the requested alarm time mask 86 * and the current time. 87 */ 88 static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, 89 struct rtc_time *alrm) 90 { 91 unsigned long next_time; 92 unsigned long now_time; 93 94 next->tm_year = now->tm_year; 95 next->tm_mon = now->tm_mon; 96 next->tm_mday = now->tm_mday; 97 next->tm_hour = alrm->tm_hour; 98 next->tm_min = alrm->tm_min; 99 next->tm_sec = alrm->tm_sec; 100 101 now_time = rtc_tm_to_time64(now); 102 next_time = rtc_tm_to_time64(next); 103 104 if (next_time < now_time) { 105 /* Advance one day */ 106 next_time += 60 * 60 * 24; 107 rtc_time64_to_tm(next_time, next); 108 } 109 } 110 111 static int pm80x_rtc_read_time(struct device *dev, struct rtc_time *tm) 112 { 113 struct pm80x_rtc_info *info = dev_get_drvdata(dev); 114 unsigned char buf[4]; 115 unsigned long ticks, base, data; 116 regmap_raw_read(info->map, PM800_RTC_EXPIRE2_1, buf, 4); 117 base = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 118 (buf[1] << 8) | buf[0]; 119 dev_dbg(info->dev, "%x-%x-%x-%x\n", buf[0], buf[1], buf[2], buf[3]); 120 121 /* load 32-bit read-only counter */ 122 regmap_raw_read(info->map, PM800_RTC_COUNTER1, buf, 4); 123 data = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 124 (buf[1] << 8) | buf[0]; 125 ticks = base + data; 126 dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n", 127 base, data, ticks); 128 rtc_time64_to_tm(ticks, tm); 129 return 0; 130 } 131 132 static int pm80x_rtc_set_time(struct device *dev, struct rtc_time *tm) 133 { 134 struct pm80x_rtc_info *info = dev_get_drvdata(dev); 135 unsigned char buf[4]; 136 unsigned long ticks, base, data; 137 138 ticks = rtc_tm_to_time64(tm); 139 140 /* load 32-bit read-only counter */ 141 regmap_raw_read(info->map, PM800_RTC_COUNTER1, buf, 4); 142 data = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 143 (buf[1] << 8) | buf[0]; 144 base = ticks - data; 145 dev_dbg(info->dev, "set base:0x%lx, RO count:0x%lx, ticks:0x%lx\n", 146 base, data, ticks); 147 buf[0] = base & 0xFF; 148 buf[1] = (base >> 8) & 0xFF; 149 buf[2] = (base >> 16) & 0xFF; 150 buf[3] = (base >> 24) & 0xFF; 151 regmap_raw_write(info->map, PM800_RTC_EXPIRE2_1, buf, 4); 152 153 return 0; 154 } 155 156 static int pm80x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 157 { 158 struct pm80x_rtc_info *info = dev_get_drvdata(dev); 159 unsigned char buf[4]; 160 unsigned long ticks, base, data; 161 int ret; 162 163 regmap_raw_read(info->map, PM800_RTC_EXPIRE2_1, buf, 4); 164 base = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 165 (buf[1] << 8) | buf[0]; 166 dev_dbg(info->dev, "%x-%x-%x-%x\n", buf[0], buf[1], buf[2], buf[3]); 167 168 regmap_raw_read(info->map, PM800_RTC_EXPIRE1_1, buf, 4); 169 data = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 170 (buf[1] << 8) | buf[0]; 171 ticks = base + data; 172 dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n", 173 base, data, ticks); 174 175 rtc_time64_to_tm(ticks, &alrm->time); 176 regmap_read(info->map, PM800_RTC_CONTROL, &ret); 177 alrm->enabled = (ret & PM800_ALARM1_EN) ? 1 : 0; 178 alrm->pending = (ret & (PM800_ALARM | PM800_ALARM_WAKEUP)) ? 1 : 0; 179 return 0; 180 } 181 182 static int pm80x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 183 { 184 struct pm80x_rtc_info *info = dev_get_drvdata(dev); 185 struct rtc_time now_tm, alarm_tm; 186 unsigned long ticks, base, data; 187 unsigned char buf[4]; 188 int mask; 189 190 regmap_update_bits(info->map, PM800_RTC_CONTROL, PM800_ALARM1_EN, 0); 191 192 regmap_raw_read(info->map, PM800_RTC_EXPIRE2_1, buf, 4); 193 base = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 194 (buf[1] << 8) | buf[0]; 195 dev_dbg(info->dev, "%x-%x-%x-%x\n", buf[0], buf[1], buf[2], buf[3]); 196 197 /* load 32-bit read-only counter */ 198 regmap_raw_read(info->map, PM800_RTC_COUNTER1, buf, 4); 199 data = ((unsigned long)buf[3] << 24) | (buf[2] << 16) | 200 (buf[1] << 8) | buf[0]; 201 ticks = base + data; 202 dev_dbg(info->dev, "get base:0x%lx, RO count:0x%lx, ticks:0x%lx\n", 203 base, data, ticks); 204 205 rtc_time64_to_tm(ticks, &now_tm); 206 dev_dbg(info->dev, "%s, now time : %lu\n", __func__, ticks); 207 rtc_next_alarm_time(&alarm_tm, &now_tm, &alrm->time); 208 /* get new ticks for alarm in 24 hours */ 209 ticks = rtc_tm_to_time64(&alarm_tm); 210 dev_dbg(info->dev, "%s, alarm time: %lu\n", __func__, ticks); 211 data = ticks - base; 212 213 buf[0] = data & 0xff; 214 buf[1] = (data >> 8) & 0xff; 215 buf[2] = (data >> 16) & 0xff; 216 buf[3] = (data >> 24) & 0xff; 217 regmap_raw_write(info->map, PM800_RTC_EXPIRE1_1, buf, 4); 218 if (alrm->enabled) { 219 mask = PM800_ALARM | PM800_ALARM_WAKEUP | PM800_ALARM1_EN; 220 regmap_update_bits(info->map, PM800_RTC_CONTROL, mask, mask); 221 } else { 222 mask = PM800_ALARM | PM800_ALARM_WAKEUP | PM800_ALARM1_EN; 223 regmap_update_bits(info->map, PM800_RTC_CONTROL, mask, 224 PM800_ALARM | PM800_ALARM_WAKEUP); 225 } 226 return 0; 227 } 228 229 static const struct rtc_class_ops pm80x_rtc_ops = { 230 .read_time = pm80x_rtc_read_time, 231 .set_time = pm80x_rtc_set_time, 232 .read_alarm = pm80x_rtc_read_alarm, 233 .set_alarm = pm80x_rtc_set_alarm, 234 .alarm_irq_enable = pm80x_rtc_alarm_irq_enable, 235 }; 236 237 #ifdef CONFIG_PM_SLEEP 238 static int pm80x_rtc_suspend(struct device *dev) 239 { 240 return pm80x_dev_suspend(dev); 241 } 242 243 static int pm80x_rtc_resume(struct device *dev) 244 { 245 return pm80x_dev_resume(dev); 246 } 247 #endif 248 249 static SIMPLE_DEV_PM_OPS(pm80x_rtc_pm_ops, pm80x_rtc_suspend, pm80x_rtc_resume); 250 251 static int pm80x_rtc_probe(struct platform_device *pdev) 252 { 253 struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent); 254 struct pm80x_rtc_pdata *pdata = dev_get_platdata(&pdev->dev); 255 struct pm80x_rtc_info *info; 256 struct device_node *node = pdev->dev.of_node; 257 int ret; 258 259 if (!pdata && !node) { 260 dev_err(&pdev->dev, 261 "pm80x-rtc requires platform data or of_node\n"); 262 return -EINVAL; 263 } 264 265 if (!pdata) { 266 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 267 if (!pdata) { 268 dev_err(&pdev->dev, "failed to allocate memory\n"); 269 return -ENOMEM; 270 } 271 } 272 273 info = 274 devm_kzalloc(&pdev->dev, sizeof(struct pm80x_rtc_info), GFP_KERNEL); 275 if (!info) 276 return -ENOMEM; 277 info->irq = platform_get_irq(pdev, 0); 278 if (info->irq < 0) { 279 dev_err(&pdev->dev, "No IRQ resource!\n"); 280 ret = -EINVAL; 281 goto out; 282 } 283 284 info->chip = chip; 285 info->map = chip->regmap; 286 if (!info->map) { 287 dev_err(&pdev->dev, "no regmap!\n"); 288 ret = -EINVAL; 289 goto out; 290 } 291 292 info->dev = &pdev->dev; 293 dev_set_drvdata(&pdev->dev, info); 294 295 info->rtc_dev = devm_rtc_allocate_device(&pdev->dev); 296 if (IS_ERR(info->rtc_dev)) 297 return PTR_ERR(info->rtc_dev); 298 299 ret = pm80x_request_irq(chip, info->irq, rtc_update_handler, 300 IRQF_ONESHOT, "rtc", info); 301 if (ret < 0) { 302 dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n", 303 info->irq, ret); 304 goto out; 305 } 306 307 info->rtc_dev->ops = &pm80x_rtc_ops; 308 info->rtc_dev->range_max = U32_MAX; 309 310 ret = rtc_register_device(info->rtc_dev); 311 if (ret) { 312 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); 313 goto out_rtc; 314 } 315 /* 316 * enable internal XO instead of internal 3.25MHz clock since it can 317 * free running in PMIC power-down state. 318 */ 319 regmap_update_bits(info->map, PM800_RTC_CONTROL, PM800_RTC1_USE_XO, 320 PM800_RTC1_USE_XO); 321 322 /* remember whether this power up is caused by PMIC RTC or not */ 323 info->rtc_dev->dev.platform_data = &pdata->rtc_wakeup; 324 325 device_init_wakeup(&pdev->dev, 1); 326 327 return 0; 328 out_rtc: 329 pm80x_free_irq(chip, info->irq, info); 330 out: 331 return ret; 332 } 333 334 static int pm80x_rtc_remove(struct platform_device *pdev) 335 { 336 struct pm80x_rtc_info *info = platform_get_drvdata(pdev); 337 pm80x_free_irq(info->chip, info->irq, info); 338 return 0; 339 } 340 341 static struct platform_driver pm80x_rtc_driver = { 342 .driver = { 343 .name = "88pm80x-rtc", 344 .pm = &pm80x_rtc_pm_ops, 345 }, 346 .probe = pm80x_rtc_probe, 347 .remove = pm80x_rtc_remove, 348 }; 349 350 module_platform_driver(pm80x_rtc_driver); 351 352 MODULE_LICENSE("GPL"); 353 MODULE_DESCRIPTION("Marvell 88PM80x RTC driver"); 354 MODULE_AUTHOR("Qiao Zhou <zhouqiao@marvell.com>"); 355 MODULE_ALIAS("platform:88pm80x-rtc"); 356