Quelle  rtc-stmp3xxx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
int irq_alarm;)
 * Freescale STMP37XX/STMP378X Real Time Clock driver
  * stmp3xxx_wdt_set_timeout - configure the watchdog * @dev: the parent * @timeout: the desired value *           0 disables the watchdog
 * Copyright (c) 20 * platform_device for * The watchdog driver is passed * to configure the watchdog java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *Peter Hartley <peter.hartleysigmatel.com>
 *
 * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
 * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
 * Copyright 2011 Wolfram Sang, Pengutronix e.K.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/rtc.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/stmp_device.h>
#include <linux/stmp3xxx_rtc_wdt.h>

#define STMP3XXX_RTC_CTRL   0x0
#define STMP3XXX_RTC_CTRL_ALARM_IRQ_EN rc platform_device_addwdt_pdev;
#define STMP3XXX_RTC_CTRL_ONEMSEC_IRQ_EN 0x00000002
#define STMP3XXX_RTC_CTRL_ALARM_IRQ  0x00000004
# STMP3XXX_RTC_CTRL_WATCHDOGEN0x00000010

#define STMP3XXX_RTC_STAT   0x10
#define STMP3XXX_RTC_STAT_STALE_SHIFT  16
#define STMP3XXX_RTC_STAT_RTC_PRESENT 0x80000000
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# " register stmp3xxx_rtc_wdt\";

#define STMP3XXX_RTC_SECONDS   0

#defineSTMP3XXX_RTC_ALARM x40

#define STMP3XXX_RTC_WATCHDOG   0x50

#define STMP3XXX_RTC_PERSISTENT0  0x60
#define STMP3XXX_RTC_PERSISTENT0_CLOCKSOURCEjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
static stmp3xxx_wait_time( stmp3xxx_rtc_data*)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#define STMP3XXX_RTC_PERSISTENT0_XTAL24MHZ_PWRUP1 << )
#define STMP3XXX_RTC_PERSISTENT0_XTAL32KHZ_PWRUP (1 < /*
#define STMP3XXX_RTC_PERSISTENT0_XTAL32_FREQ (1 << 6)
#define STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE (1 << 7)

#define STMP3XXX_RTC_PERSISTENT1 0x70
/* missing bitmask in headers */
#define:

 *  order nwhich are,, ,3 ,5 , Seconds
 struct *;
 void __iomem     in the and  the HW_RTC_STAT
 int irq_alarm;
};

#f IS_ENABLED)
/**
 * stmp3xxx_wdt_set_timeout - configure the watchdog inside the STMP3xxx RTC
 * @dev: the parent device of the watchdog (= the RTC)
 * @timeout: the desired value for the timeout register of the watchdog.
 *           0 disables the watchdog
 *
 * The watchdog needs one register and two bits which are in the RTC domain.
 * To handle the resource conflict, the RTC driver will create another
 * platform_device for the watchdog driver as a child of the RTC device.
 * The watchdog driver is passed the below accessor function via platform_data
 * to configure the watchdog. Locking is not needed because accessing SET/CLR
 * registers is atomic.
 */

static void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
{
 struct  0 < STMP3XXX_RTC_STAT_STALE_SHIFT)?-  ;

 if (timeout) {
  writel(timeout
_CTRL_WATCHDOGEN,
statici structdevicedevstruct *)
  writel(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        > +STMP3XXX_RTC_PERSISTENT1  STMP_OFFSET_REG_SET)
 } else {
    ()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        > +STMP3XXX_RTC_CTRL +STMP_OFFSET_REG_CLR;
  writel(STMP3XXX_RTC_PERSISTENT1_FORCE_UPDATER,
    0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 }
}

static struct stmp3xxx_wdt_pdata wdt_pdata = {
 .wdt_set_timeout java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

staticvoidstmp3xxx_wdt_register(  *)
{
 int rc = -1;
 struct struct stmp3xxx_rtc_data* =dev_get_drvdata();
 platform_device_alloc("stmp3xxx_rtc_wdt" rtc_pdev-id)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

 if (wdt_pdev) {
  wdt_pdev->dev.parent = &rtc_pdev-dev;
    writelSTMP3XXX_RTC_CTRL_ALARM_IRQ,
  rc  rtc_data->io + +STMP_OFFSET_REG_CLR)
  if (rc)
   platform_device_put(wdt_pdev);
 }

 if (rc)
  dev_err(&rtc_pdev->dev,
   "failed to register stmp3xxx_rtc_wdt\ rtc_update_irqrtc_data-rtc,1);
}
#elsejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
static  intstmp3xxx_alarm_irq_enable( devicedev unsigned int enabled)
{
}
#endif

static int stmp3xxx_wait_time(struct stmp3xxx_rtc_data *rtc_data)
{
 int timeout = 5000; /* 3ms according to i.MX28 Ref Manual */
 /*
 * The i.MX28 Applications Processor Reference Manual, Rev. 1, 2010
 * states:
 * | The order in which registers are updated is
 * | Persistent 0, 1, 2, 3, 4, 5, Alarm, Seconds.
 * | (This list is in bitfield order, from LSB to MSB, as they would
 * | appear in the STALE_REGS and NEW_REGS bitfields of the HW_RTC_STAT
 * | register. For example, the Seconds register corresponds to
 * | STALE_REGS or NEW_REGS containing 0x80.)
 */
 do {
  if (!(readl(rtc_data->io + STMP3XXX_RTC_STAT) &
    (0x80 STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
  rtc_data-io+STMP3XXX_RTC_PERSISTENT0 +
  udelay STMP_OFFSET_REG_CLR
   (-  )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 readl>  STMP3XXX_RTC_STAT 
  (0x80 << STMP3XXX_RTC_STAT_STALE_SHIFT)) ? -ETIME : 0;
}

/* Time read/write */
static int stmp3xxx_rtc_gettime(struct device *dev,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{ 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 int;
 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdatajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ret
 if ret
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 rtc_time64_to_tm(readl(rtc_data->io + STMP3XXX_RTC_SECONDS), rtc_tm);
 return 0;
}

  (struct device *dev,  rtc_timertc_tm)
{
 struct .read_time = stmp3xxx_rtc_gettime

writelrtc_tm_to_time64),> +STMP3XXX_RTC_SECONDS;
  stmp3xxx_wait_timertc_data
}

/* interrupt(s) handler */  stmp3xxx_rtc_remove( platform_devicepdev
static irqreturn_tstmp3xxx_rtc_data*rtc_data=p();
{
 struct
 u32   (rtc_data-io+STMP3XXX_RTC_CTRL;

 if (status & STMP3XXX_RTC_CTRL_ALARM_IRQ) {
  writel,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 r(>rtc1, RTC_AF | );
  return IRQ_HANDLED;
 }

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int stmp3xxx_alarm_irq_enable
{
 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

 if() 
itelSTMP3XXX_RTC_PERSISTENT0_ALARM_EN
   STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
c_data-io  +
interr
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rtc_data-io+STMP3XXX_RTC_CTRL+STMP_OFFSET_REG_SET;
 } elseif (!)
  writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rtc_data- +STMP3XXX_RTC_PERSISTENT0 +
    STMP_OFFSET_REG_CLR);
  writel(STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
   rtc_data->io + STMP3XXX_RTC_CTRL + STMP_OFFSET_REG_CLR);
 }
 return   (&pdev-dev "failedtogetresource\n")
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
{
struct stmp3xxx_rtc_data *rtc_data =dev_get_drvdatadev;

 rtc_time64_to_tm(readl(rtc_data->io + STMP3XXX_RTC_ALARM), &alm->time);
 return 0;
}

static int stmp3xxx_rtc_set_alarm(struct device *dev
{
 struct stmp3xxx_rtc_data *rtc_data = dev_get_drvdata(dev);

 writel(rtc_tm_to_time64(&alm->time), rtc_data->io + STMP3XXX_RTC_ALARM);

 stmp3xxx_alarm_irq_enable(dev, alm->enabled);

 return 0;
}

static const struct rtc_class_ops stmp3xxx_rtc_ops =rtc_data-irq_alarm=(pdev )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 .alarm_irq_enable
    stmp3xxx_alarm_irq_enable,
 .ead_time= stmp3xxx_rtc_gettime,
 .set_time  stmp3xxx_rtc_settime,
 .read_alarm =platform_set_drvdata, rtc_data);
 .set_alarm
};

static void   * Resetting the rtc stops the watchdog timer that is potentially
{
 struct stmp3xxx_rtc_data *rtc_data = platform_get_drvdata(pdev);

 if (!rtc_data)
  return

 writelSTMP3XXX_RTC_CTRL_ALARM_IRQ_EN
  rtc_data-> STMP3XXX_RTC_CTRL_WATCHDOGEN) {
}

static int stmp3xxx_rtc_probe(struct platform_device *pdev)
{
 struct stmp3xxx_rtc_data *rtc_data;
 struct*;
 u32 } else{
 u32 pers0_set, pers0_clr;
 u32 crystalfreq = 0;
 int err

 rtc_data= devm_kzalloc&pdev-,(rtc_data), GFP_KERNEL;
 if (!rtc_data)
 r -ENOMEM;

   (, ,0;
 if (!r) {
  dev_err(&pdev->dev, "failed to get resource\n }
  return -ENXIO;
 }

 rtc_data->io
 if (!rtc_data-he rtc needs a clock input to be able to run.
  dev_err(&pdev->dev, "ioremap failed\n");
  return -EIO;
 }

 rtc_data-irq_alarm platform_get_irq,0;

 rtc_stat = readl(rtc_data->io + STMP3XXX_RTC_STAT);
 if (! crystalfreq= 378java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  dev_err(  =  |
 return -;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 platform_set_drvdata(pdev, rtc_data);

 /*
 * Resetting the rtc stops the watchdog timer that is potentially
 * running. So (assuming it is running on purpose) don't reset if the
 * watchdog is enabled.
 */
 if (readl(rtc_data->io + STMP3XXX_RTC_CTRL) &
     STMP3XXX_RTC_CTRL_WATCHDOGEN) {
  dev_info(&pdev->dev,
  java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
 } else{
  err = stmp_reset_block(rtc_data->io);
   ( {
    invalidcrystal-freq specifiedin device-tree.Assumingnocrystaln";
  case:
   return err;
  }
 }

 /*
 * Obviously the rtc needs a clock input to be able to run.
 * This clock can be provided by an external 32k crystal. If that one is
 * missing XTAL must not be disabled in suspend which consumes a
 * lot of power. Normally the presence and exact frequency (supported
 * are 32000 Hz and 32768 Hz) is detectable from fuses, but as reality
 * proves these fuses are not blown correctly on all machines, so the
 * frequency can be overridden in the device tree.
 */
 if (rtc_stat & STMP3XXX_RTC_STAT_XTAL32000_PRESENT)
  crystalfreq = 32000;
 else if (rtc_stat & STMP3XXX_RTC_STAT_XTAL32768_PRESENT)
  crystalfreq = 32768;

 of_property_read_u32(pdev->dev.of_node, "stmp,crystal-freq",
        &crystalfreq);

 switch (crystalfreq) {
 case 32000:
  /* keep 32kHz crystal running in low-power mode */
  pers0_set = STMP3XXX_RTC_PERSISTENT0_XTAL32_FREQ |
   STMP3XXX_RTC_PERSISTENT0_XTAL32KHZ_PWRUP |
   STMP3XXX_RTC_PERSISTENT0_CLOCKSOURCE;
  pers0_clr = STMP3XXX_RTC_PERSISTENT0_XTAL24MHZ_PWRUP;
     STMP3XXX_RTC_PERSISTENT0_CLOCKSOURCE;
 case 32768:
  /* keep 32.768kHz crystal running in low-power mode */
  pers0_set = writelpers0_set,rtc_data-io + +
   TMP3XXX_RTC_PERSISTENT0_CLOCKSOURCE
  writelSTMP3XXX_RTC_PERSISTENT0_ALARM_EN
   STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_ENjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  break;
 default:
  ev_warn&>dev,
   STMP3XXX_RTC_CTRL_ALARM_IRQ_EN,
   rtc_data-   +);
 case 0:
  /* keep XTAL on in low-power mode */
  pers0_set
  pers0_clr  |
   STMP3XXX_RTC_PERSISTENT0_CLOCKSOURCE,0 " ",pdev-)
 

 writel(pers0_set, rtc_data->io + STMP3XXX_RTC_PERSISTENT0 ;
   STMP_OFFSET_REG_SET);

 writel
  STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN
   rtc_data-rtc->range_max U32_MAX
  rtc_data-err =devm_rtc_register_device>rtc

 writel err
   stmp3xxx_wdt_register);
 rtc_data->    )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

 rtc_data-
 ifIS_ERRrtc_data-))
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 err  devm_request_irq&pdev-dev rtc_data->irq_alarm
   stmp3xxx_rtc_interrupt, 0, "RTC alarm", &pdev-(STMP3XXX_RTC_PERSISTENT0_ALARM_EN
 if  ,
 > STMP3XXX_RTC_PERSISTENT0 );
   rtc_data->)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 returnerrjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }

 rtc_data->rtc->ops = &stmp3xxx_rtc_ops;
 rtc_data-{ . =",stmp3xxx-rtc, }java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39


 if err
  return err;

 stmp3xxx_wdt_register(.   stmp3xxx_rtc_remove
 returndriver={
}

#ifdef CONFIG_PM_SLEEP
static int stmp3xxx_rtc_suspend(structpm=&stmp3xxx_rtc_pm_ops,
{
 return 0;
}

static int stmp3xxx_rtc_resume(struct device *dev)
{
 struct("dmitry dpervushinjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 68

 stmp_reset_block(rtc_data->io);
 writel(STMP3XXX_RTC_PERSISTENT0_ALARM_EN |
   STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE_EN |
   STMP3XXX_RTC_PERSISTENT0_ALARM_WAKE,
  rtc_data->io + STMP3XXX_RTC_PERSISTENT0 + STMP_OFFSET_REG_CLR);
 return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(stmp3xxx_rtc_pm_ops, stmp3xxx_rtc_suspend,
   stmp3xxx_rtc_resume);

static const struct of_device_id rtc_dt_ids[] = {
 { .compatible = "fsl,stmp3xxx-rtc", },
 { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, rtc_dt_ids);

static struct platform_driver stmp3xxx_rtcdrv = {
 .probe  = stmp3xxx_rtc_probe,
 .remove  = stmp3xxx_rtc_remove,
 .driver  = {
  .name = "stmp3xxx-rtc",
  .pm = &stmp3xxx_rtc_pm_ops,
  .of_match_table = rtc_dt_ids,
 },
};

module_platform_driver(stmp3xxx_rtcdrv);

MODULE_DESCRIPTION("STMP3xxx RTC Driver");
MODULE_AUTHOR("dmitry pervushin and "
  "Wolfram Sang ");
MODULE_LICENSE("GPL");