drivers/rtc/rtc-rpi.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /**
   3  * rtc-rpi.c
   4  *
   5  * RTC driver using firmware mailbox
   6  * Supports battery backed RTC and wake alarms
   7  *
   8  * Based on rtc-meson-vrtc by Neil Armstrong
   9  *
  10  * Copyright (c) 2023, Raspberry Pi Ltd.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/rtc.h>
  16 #include <linux/of.h>
  17 #include <soc/bcm2835/raspberrypi-firmware.h>
  18
  19 struct rpi_rtc_data {
  20         struct rtc_device *rtc;
  21         struct rpi_firmware *fw;
  22         u32 bbat_vchg_microvolts;
  23 };
  24
  25 #define RPI_FIRMWARE_GET_RTC_REG 0x00030087
  26 #define RPI_FIRMWARE_SET_RTC_REG 0x00038087
  27
  28 enum {
  29         RTC_TIME,
  30         RTC_ALARM,
  31         RTC_ALARM_PENDING,
  32         RTC_ALARM_ENABLE,
  33         RTC_BBAT_CHG_VOLTS,
  34         RTC_BBAT_CHG_VOLTS_MIN,
  35         RTC_BBAT_CHG_VOLTS_MAX,
  36         RTC_BBAT_VOLTS
  37 };
  38
  39 static int rpi_rtc_read_time(struct device *dev, struct rtc_time *tm)
  40 {
  41         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
  42         u32 data[2] = {RTC_TIME};
  43         int err;
  44
  45         err = rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_GET_RTC_REG,
  46                                     &data, sizeof(data));
  47         rtc_time64_to_tm(data[1], tm);
  48         return err;
  49 }
  50
  51 static int rpi_rtc_set_time(struct device *dev, struct rtc_time *tm)
  52 {
  53         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
  54         u32 data[2] = {RTC_TIME, rtc_tm_to_time64(tm)};
  55
  56         return rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_SET_RTC_REG,
  57                                      &data, sizeof(data));
  58 }
  59
  60 static int rpi_rtc_alarm_irq_is_enabled(struct device *dev, unsigned char *enabled)
  61 {
  62         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
  63         u32 data[2] = {RTC_ALARM_ENABLE};
  64         s32 err = 0;
  65
  66         err = rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_GET_RTC_REG,
  67                                     &data, sizeof(data));
  68         *enabled = data[1] & 0x1;
  69         return err;
  70 }
  71
  72 static int rpi_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  73 {
  74         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
  75         u32 data[2] = {RTC_ALARM_ENABLE, enabled};
  76
  77         return rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_SET_RTC_REG,
  78                                      &data, sizeof(data));
  79 }
  80
  81 static int rpi_rtc_alarm_clear_pending(struct device *dev)
  82 {
  83         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
  84         u32 data[2] = {RTC_ALARM_PENDING, 1};
  85
  86         return rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_SET_RTC_REG,
  87                                      &data, sizeof(data));
  88 }
  89
  90 static int rpi_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  91 {
  92         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
  93         u32 data[2] = {RTC_ALARM};
  94         s32 err = 0;
  95
  96         err = rpi_rtc_alarm_irq_is_enabled(dev, &alarm->enabled);
  97         if (!err)
  98                 err = rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_GET_RTC_REG,
  99                                             &data, sizeof(data));
 100         rtc_time64_to_tm(data[1], &alarm->time);
 101
 102         return err;
 103 }
 104
 105 static int rpi_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 106 {
 107         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
 108         u32 data[2] = {RTC_ALARM, rtc_tm_to_time64(&alarm->time)};
 109         int err;
 110
 111         err = rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_SET_RTC_REG,
 112                                     &data, sizeof(data));
 113
 114         if (err == 0)
 115                 err = rpi_rtc_alarm_irq_enable(dev, alarm->enabled);
 116
 117         return err;
 118 }
 119
 120 static const struct rtc_class_ops rpi_rtc_ops = {
 121         .read_time = rpi_rtc_read_time,
 122         .set_time = rpi_rtc_set_time,
 123         .read_alarm = rpi_rtc_read_alarm,
 124         .set_alarm = rpi_rtc_set_alarm,
 125         .alarm_irq_enable = rpi_rtc_alarm_irq_enable,
 126 };
 127
 128 static int rpi_rtc_set_charge_voltage(struct device *dev)
 129 {
 130         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev);
 131         u32 data[2] = {RTC_BBAT_CHG_VOLTS, vrtc->bbat_vchg_microvolts};
 132         int err;
 133
 134         err = rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_SET_RTC_REG,
 135                                     &data, sizeof(data));
 136
 137         if (err)
 138                 dev_err(dev, "failed to set trickle charge voltage to %uuV: %d\n",
 139                         vrtc->bbat_vchg_microvolts, err);
 140         else if (vrtc->bbat_vchg_microvolts)
 141                 dev_info(dev, "trickle charging enabled at %uuV\n",
 142                          vrtc->bbat_vchg_microvolts);
 143
 144         return err;
 145 }
 146
 147 static ssize_t rpi_rtc_print_uint_reg(struct device *dev, char *buf, u32 reg)
 148 {
 149         struct rpi_rtc_data *vrtc = dev_get_drvdata(dev->parent);
 150         u32 data[2] = {reg, 0};
 151         int ret = 0;
 152
 153         ret = rpi_firmware_property(vrtc->fw, RPI_FIRMWARE_GET_RTC_REG,
 154                                     &data, sizeof(data));
 155         if (ret < 0)
 156                 return ret;
 157
 158         return sprintf(buf, "%u\n", data[1]);
 159 }
 160
 161 static ssize_t charging_voltage_show(struct device *dev,
 162                                      struct device_attribute *attr,
 163                                      char *buf)
 164 {
 165         return rpi_rtc_print_uint_reg(dev, buf, RTC_BBAT_CHG_VOLTS);
 166 }
 167 static DEVICE_ATTR_RO(charging_voltage);
 168
 169 static ssize_t charging_voltage_min_show(struct device *dev,
 170                                          struct device_attribute *attr,
 171                                          char *buf)
 172 {
 173         return rpi_rtc_print_uint_reg(dev, buf, RTC_BBAT_CHG_VOLTS_MIN);
 174 }
 175 static DEVICE_ATTR_RO(charging_voltage_min);
 176
 177 static ssize_t charging_voltage_max_show(struct device *dev,
 178                                          struct device_attribute *attr,
 179                                          char *buf)
 180 {
 181         return rpi_rtc_print_uint_reg(dev, buf, RTC_BBAT_CHG_VOLTS_MAX);
 182 }
 183 static DEVICE_ATTR_RO(charging_voltage_max);
 184
 185 static ssize_t battery_voltage_show(struct device *dev,
 186                                     struct device_attribute *attr,
 187                                     char *buf)
 188 {
 189         return rpi_rtc_print_uint_reg(dev, buf, RTC_BBAT_VOLTS);
 190 }
 191 static DEVICE_ATTR_RO(battery_voltage);
 192
 193 static struct attribute *rpi_rtc_attrs[] = {
 194         &dev_attr_charging_voltage.attr,
 195         &dev_attr_charging_voltage_min.attr,
 196         &dev_attr_charging_voltage_max.attr,
 197         &dev_attr_battery_voltage.attr,
 198         NULL
 199 };
 200
 201 static const struct attribute_group rpi_rtc_sysfs_files = {
 202         .attrs = rpi_rtc_attrs,
 203 };
 204
 205 static int rpi_rtc_probe(struct platform_device *pdev)
 206 {
 207         struct rpi_rtc_data *vrtc;
 208         struct device *dev = &pdev->dev;
 209         struct device_node *np = dev->of_node;
 210         struct device_node *fw_node;
 211         struct rpi_firmware *fw;
 212         int ret;
 213
 214         fw_node = of_parse_phandle(np, "firmware", 0);
 215         if (!fw_node) {
 216                 dev_err(dev, "Missing firmware node\n");
 217                 return -ENOENT;
 218         }
 219
 220         fw = rpi_firmware_get(fw_node);
 221         if (!fw)
 222                 return -EPROBE_DEFER;
 223
 224         vrtc = devm_kzalloc(&pdev->dev, sizeof(*vrtc), GFP_KERNEL);
 225         if (!vrtc)
 226                 return -ENOMEM;
 227
 228         vrtc->fw = fw;
 229
 230         device_init_wakeup(&pdev->dev, 1);
 231
 232         platform_set_drvdata(pdev, vrtc);
 233
 234         vrtc->rtc = devm_rtc_allocate_device(&pdev->dev);
 235         if (IS_ERR(vrtc->rtc))
 236                 return PTR_ERR(vrtc->rtc);
 237
 238         set_bit(RTC_FEATURE_ALARM_WAKEUP_ONLY, vrtc->rtc->features);
 239         clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, vrtc->rtc->features);
 240
 241         vrtc->rtc->ops = &rpi_rtc_ops;
 242         ret = rtc_add_group(vrtc->rtc, &rpi_rtc_sysfs_files);
 243         if (ret)
 244                 return ret;
 245
 246         rpi_rtc_alarm_clear_pending(dev);
 247
 248         /*
 249          * Optionally enable trickle charging - if the property isn't
 250          * present (or set to zero), trickle charging is disabled.
 251          */
 252         of_property_read_u32(np, "trickle-charge-microvolt",
 253                              &vrtc->bbat_vchg_microvolts);
 254
 255         rpi_rtc_set_charge_voltage(dev);
 256
 257         return devm_rtc_register_device(vrtc->rtc);
 258 }
 259
 260 static const struct of_device_id rpi_rtc_dt_match[] = {
 261         { .compatible = "raspberrypi,rpi-rtc"},
 262         {},
 263 };
 264 MODULE_DEVICE_TABLE(of, rpi_rtc_dt_match);
 265
 266 static struct platform_driver rpi_rtc_driver = {
 267         .probe = rpi_rtc_probe,
 268         .driver = {
 269                 .name = "rpi-rtc",
 270                 .of_match_table = rpi_rtc_dt_match,
 271         },
 272 };
 273
 274 module_platform_driver(rpi_rtc_driver);
 275
 276 MODULE_DESCRIPTION("Raspberry Pi RTC driver");
 277 MODULE_LICENSE("GPL");