drivers/rtc/rtc-digicolor.c

   1 /*
   2  * Real Time Clock driver for Conexant Digicolor
   3  *
   4  * Copyright (C) 2015 Paradox Innovation Ltd.
   5  *
   6  * Author: Baruch Siach <baruch@tkos.co.il>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2 of the License, or (at your
  11  * option) any later version.
  12  */
  13
  14 #include <linux/io.h>
  15 #include <linux/iopoll.h>
  16 #include <linux/delay.h>
  17 #include <linux/module.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/rtc.h>
  20 #include <linux/of.h>
  21
  22 #define DC_RTC_CONTROL          0x0
  23 #define DC_RTC_TIME             0x8
  24 #define DC_RTC_REFERENCE        0xc
  25 #define DC_RTC_ALARM            0x10
  26 #define DC_RTC_INTFLAG_CLEAR    0x14
  27 #define DC_RTC_INTENABLE        0x16
  28
  29 #define DC_RTC_CMD_MASK         0xf
  30 #define DC_RTC_GO_BUSY          BIT(7)
  31
  32 #define CMD_NOP                 0
  33 #define CMD_RESET               1
  34 #define CMD_WRITE               3
  35 #define CMD_READ                4
  36
  37 #define CMD_DELAY_US            (10*1000)
  38 #define CMD_TIMEOUT_US          (500*CMD_DELAY_US)
  39
  40 struct dc_rtc {
  41         struct rtc_device       *rtc_dev;
  42         void __iomem            *regs;
  43 };
  44
  45 static int dc_rtc_cmds(struct dc_rtc *rtc, const u8 *cmds, int len)
  46 {
  47         u8 val;
  48         int i, ret;
  49
  50         for (i = 0; i < len; i++) {
  51                 writeb_relaxed((cmds[i] & DC_RTC_CMD_MASK) | DC_RTC_GO_BUSY,
  52                                rtc->regs + DC_RTC_CONTROL);
  53                 ret = readb_relaxed_poll_timeout(
  54                         rtc->regs + DC_RTC_CONTROL, val,
  55                         !(val & DC_RTC_GO_BUSY), CMD_DELAY_US, CMD_TIMEOUT_US);
  56                 if (ret < 0)
  57                         return ret;
  58         }
  59
  60         return 0;
  61 }
  62
  63 static int dc_rtc_read(struct dc_rtc *rtc, unsigned long *val)
  64 {
  65         static const u8 read_cmds[] = {CMD_READ, CMD_NOP};
  66         u32 reference, time1, time2;
  67         int ret;
  68
  69         ret = dc_rtc_cmds(rtc, read_cmds, ARRAY_SIZE(read_cmds));
  70         if (ret < 0)
  71                 return ret;
  72
  73         reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
  74         time1 = readl_relaxed(rtc->regs + DC_RTC_TIME);
  75         /* Read twice to ensure consistency */
  76         while (1) {
  77                 time2 = readl_relaxed(rtc->regs + DC_RTC_TIME);
  78                 if (time1 == time2)
  79                         break;
  80                 time1 = time2;
  81         }
  82
  83         *val = reference + time1;
  84         return 0;
  85 }
  86
  87 static int dc_rtc_write(struct dc_rtc *rtc, u32 val)
  88 {
  89         static const u8 write_cmds[] = {CMD_WRITE, CMD_NOP, CMD_RESET, CMD_NOP};
  90
  91         writel_relaxed(val, rtc->regs + DC_RTC_REFERENCE);
  92         return dc_rtc_cmds(rtc, write_cmds, ARRAY_SIZE(write_cmds));
  93 }
  94
  95 static int dc_rtc_read_time(struct device *dev, struct rtc_time *tm)
  96 {
  97         struct dc_rtc *rtc = dev_get_drvdata(dev);
  98         unsigned long now;
  99         int ret;
 100
 101         ret = dc_rtc_read(rtc, &now);
 102         if (ret < 0)
 103                 return ret;
 104         rtc_time64_to_tm(now, tm);
 105
 106         return 0;
 107 }
 108
 109 static int dc_rtc_set_mmss(struct device *dev, unsigned long secs)
 110 {
 111         struct dc_rtc *rtc = dev_get_drvdata(dev);
 112
 113         return dc_rtc_write(rtc, secs);
 114 }
 115
 116 static int dc_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 117 {
 118         struct dc_rtc *rtc = dev_get_drvdata(dev);
 119         u32 alarm_reg, reference;
 120         unsigned long now;
 121         int ret;
 122
 123         alarm_reg = readl_relaxed(rtc->regs + DC_RTC_ALARM);
 124         reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
 125         rtc_time64_to_tm(reference + alarm_reg, &alarm->time);
 126
 127         ret = dc_rtc_read(rtc, &now);
 128         if (ret < 0)
 129                 return ret;
 130
 131         alarm->pending = alarm_reg + reference > now;
 132         alarm->enabled = readl_relaxed(rtc->regs + DC_RTC_INTENABLE);
 133
 134         return 0;
 135 }
 136
 137 static int dc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 138 {
 139         struct dc_rtc *rtc = dev_get_drvdata(dev);
 140         time64_t alarm_time;
 141         u32 reference;
 142
 143         alarm_time = rtc_tm_to_time64(&alarm->time);
 144
 145         reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
 146         writel_relaxed(alarm_time - reference, rtc->regs + DC_RTC_ALARM);
 147
 148         writeb_relaxed(!!alarm->enabled, rtc->regs + DC_RTC_INTENABLE);
 149
 150         return 0;
 151 }
 152
 153 static int dc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 154 {
 155         struct dc_rtc *rtc = dev_get_drvdata(dev);
 156
 157         writeb_relaxed(!!enabled, rtc->regs + DC_RTC_INTENABLE);
 158
 159         return 0;
 160 }
 161
 162 static const struct rtc_class_ops dc_rtc_ops = {
 163         .read_time              = dc_rtc_read_time,
 164         .set_mmss               = dc_rtc_set_mmss,
 165         .read_alarm             = dc_rtc_read_alarm,
 166         .set_alarm              = dc_rtc_set_alarm,
 167         .alarm_irq_enable       = dc_rtc_alarm_irq_enable,
 168 };
 169
 170 static irqreturn_t dc_rtc_irq(int irq, void *dev_id)
 171 {
 172         struct dc_rtc *rtc = dev_id;
 173
 174         writeb_relaxed(1, rtc->regs + DC_RTC_INTFLAG_CLEAR);
 175         rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
 176
 177         return IRQ_HANDLED;
 178 }
 179
 180 static int __init dc_rtc_probe(struct platform_device *pdev)
 181 {
 182         struct resource *res;
 183         struct dc_rtc *rtc;
 184         int irq, ret;
 185
 186         rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
 187         if (!rtc)
 188                 return -ENOMEM;
 189
 190         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 191         rtc->regs = devm_ioremap_resource(&pdev->dev, res);
 192         if (IS_ERR(rtc->regs))
 193                 return PTR_ERR(rtc->regs);
 194
 195         irq = platform_get_irq(pdev, 0);
 196         if (irq < 0)
 197                 return irq;
 198         ret = devm_request_irq(&pdev->dev, irq, dc_rtc_irq, 0, pdev->name, rtc);
 199         if (ret < 0)
 200                 return ret;
 201
 202         platform_set_drvdata(pdev, rtc);
 203         rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, pdev->name,
 204                                                 &dc_rtc_ops, THIS_MODULE);
 205         if (IS_ERR(rtc->rtc_dev))
 206                 return PTR_ERR(rtc->rtc_dev);
 207
 208         return 0;
 209 }
 210
 211 static const struct of_device_id dc_dt_ids[] = {
 212         { .compatible = "cnxt,cx92755-rtc" },
 213         { /* sentinel */ }
 214 };
 215 MODULE_DEVICE_TABLE(of, dc_dt_ids);
 216
 217 static struct platform_driver dc_rtc_driver = {
 218         .driver = {
 219                 .name = "digicolor_rtc",
 220                 .of_match_table = of_match_ptr(dc_dt_ids),
 221         },
 222 };
 223 module_platform_driver_probe(dc_rtc_driver, dc_rtc_probe);
 224
 225 MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
 226 MODULE_DESCRIPTION("Conexant Digicolor Realtime Clock Driver (RTC)");
 227 MODULE_LICENSE("GPL");