Quelle  rtc-goldfish.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* drivers/rtc/rtc-goldfish.c
 *
 * Copyright (C) 2007 Google, Inc.
 * Copyright (C) 2017 Imagination Technologies Ltd.
 */

#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/goldfish.h>
#include <clocksource/timer-goldfish.h>

struct goldfish_rtc {
 void __iomem *base;
 int irq;
 struct rtc_device *rtc;
};

static int goldfish_rtc_read_alarm(struct device *dev,
       struct rtc_wkalrm *alrm)
{
 u64 rtc_alarm;
 u64 rtc_alarm_low;
 u64 rtc_alarm_high;
 void __iomem *base;
 struct goldfish_rtc *rtcdrv;

 rtcdrv = dev_get_drvdata(dev);
 base = rtcdrv->base;

 rtc_alarm_low = gf_ioread32(base + TIMER_ALARM_LOW);
 rtc_alarm_high = gf_ioread32(base + TIMER_ALARM_HIGH);
 rtc_alarm = (rtc_alarm_high << 32) | rtc_alarm_low;

 do_div(rtc_alarm, NSEC_PER_SEC);
 memset(alrm, 0, sizeof(struct rtc_wkalrm));

 rtc_time64_to_tm(rtc_alarm, &alrm->time);

 if (gf_ioread32(base + TIMER_ALARM_STATUS))
  alrm->enabled = 1;
 else
  alrm->enabled = 0;

 return 0;
}

static int goldfish_rtc_set_alarm(struct device *dev,
      struct rtc_wkalrm *alrm)
{
 struct goldfish_rtc *rtcdrv;
 u64 rtc_alarm64;
 u64 rtc_status_reg;
 void __iomem *base;

 rtcdrv = dev_get_drvdata(dev);
 base = rtcdrv->base;

 if (alrm->enabled) {
  rtc_alarm64 = rtc_tm_to_time64(&alrm->time) * NSEC_PER_SEC;
  gf_iowrite32((rtc_alarm64 >> 32), base + TIMER_ALARM_HIGH);
  gf_iowrite32(rtc_alarm64, base + TIMER_ALARM_LOW);
  gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
 } else {
  /*
 * if this function was called with enabled=0
 * then it could mean that the application is
 * trying to cancel an ongoing alarm
 */
  rtc_status_reg = gf_ioread32(base + TIMER_ALARM_STATUS);
  if (rtc_status_reg)
   gf_iowrite32(1, base + TIMER_CLEAR_ALARM);
 }

 return 0;
}

static int goldfish_rtc_alarm_irq_enable(struct device *dev,
      unsigned int enabled)
{
 void __iomem *base;
 struct goldfish_rtc *rtcdrv;

 rtcdrv = dev_get_drvdata(dev);
 base = rtcdrv->base;

 if (enabled)
  gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
 else
  gf_iowrite32(0, base + TIMER_IRQ_ENABLED);

 return 0;
}

static irqreturn_t goldfish_rtc_interrupt(int irq, void *dev_id)
{
 struct goldfish_rtc *rtcdrv = dev_id;
 void __iomem *base = rtcdrv->base;

 gf_iowrite32(1, base + TIMER_CLEAR_INTERRUPT);

 rtc_update_irq(rtcdrv->rtc, 1, RTC_IRQF | RTC_AF);

 return IRQ_HANDLED;
}

static int goldfish_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
 struct goldfish_rtc *rtcdrv;
 void __iomem *base;
 u64 time_high;
 u64 time_low;
 u64 time;

 rtcdrv = dev_get_drvdata(dev);
 base = rtcdrv->base;

 time_low = gf_ioread32(base + TIMER_TIME_LOW);
 time_high = gf_ioread32(base + TIMER_TIME_HIGH);
 time = (time_high << 32) | time_low;

 do_div(time, NSEC_PER_SEC);

 rtc_time64_to_tm(time, tm);

 return 0;
}

static int goldfish_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
 struct goldfish_rtc *rtcdrv;
 void __iomem *base;
 u64 now64;

 rtcdrv = dev_get_drvdata(dev);
 base = rtcdrv->base;

 now64 = rtc_tm_to_time64(tm) * NSEC_PER_SEC;
 gf_iowrite32((now64 >> 32), base + TIMER_TIME_HIGH);
 gf_iowrite32(now64, base + TIMER_TIME_LOW);

 return 0;
}

static const struct rtc_class_ops goldfish_rtc_ops = {
 .read_time = goldfish_rtc_read_time,
 .set_time = goldfish_rtc_set_time,
 .read_alarm = goldfish_rtc_read_alarm,
 .set_alarm = goldfish_rtc_set_alarm,
 .alarm_irq_enable = goldfish_rtc_alarm_irq_enable
};

static int goldfish_rtc_probe(struct platform_device *pdev)
{
 struct goldfish_rtc *rtcdrv;
 int err;

 rtcdrv = devm_kzalloc(&pdev->dev, sizeof(*rtcdrv), GFP_KERNEL);
 if (!rtcdrv)
  return -ENOMEM;

 platform_set_drvdata(pdev, rtcdrv);
 rtcdrv->base = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(rtcdrv->base))
  return PTR_ERR(rtcdrv->base);

 rtcdrv->irq = platform_get_irq(pdev, 0);
 if (rtcdrv->irq < 0)
  return -ENODEV;

 rtcdrv->rtc = devm_rtc_allocate_device(&pdev->dev);
 if (IS_ERR(rtcdrv->rtc))
  return PTR_ERR(rtcdrv->rtc);

 rtcdrv->rtc->ops = &goldfish_rtc_ops;
 rtcdrv->rtc->range_max = U64_MAX / NSEC_PER_SEC;

 err = devm_request_irq(&pdev->dev, rtcdrv->irq,
          goldfish_rtc_interrupt,
          0, pdev->name, rtcdrv);
 if (err)
  return err;

 return devm_rtc_register_device(rtcdrv->rtc);
}

static const struct of_device_id goldfish_rtc_of_match[] = {
 { .compatible = "google,goldfish-rtc", },
 {},
};
MODULE_DEVICE_TABLE(of, goldfish_rtc_of_match);

static struct platform_driver goldfish_rtc = {
 .probe = goldfish_rtc_probe,
 .driver = {
  .name = "goldfish_rtc",
  .of_match_table = goldfish_rtc_of_match,
 }
};

module_platform_driver(goldfish_rtc);

MODULE_DESCRIPTION("Android Goldfish Real Time Clock driver");
MODULE_LICENSE("GPL v2");