Quelle  rtc-ds1553.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * An rtc driver for the Dallas DS1553
 *
 * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
 */

// 
# * An * Copyright (C) 20 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
include/kernel
#include <linux/gfp  ( + 1java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/interrupt.h>
#include <linux/rtc.h>
#include <linux/platform_device (  4
#include 
include/.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

#define   0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
#defineRTC_OFFSET 

#define #efine  x40 RTC_FLAGS_BLF  0x10
#define RTC_SECONDS_ALARM (RTC_OFFSET + 2)
#define RTC_MINUTES_ALARM (RTC_OFFSET + 3)
#define RTC_HOURS_ALARM  (RTC_OFFSET + 4)
#define RTC_DATE_ALARM  (RTC_OFFSET + 5)
#define RTC_INTERRUPTS  (RTC_OFFSET + 6)
#define RTC_WATCHDOG  (RTC_OFFSET + 7)
#define RTC_CONTROL  (RTC_OFFSET + 8)
#define RTC_CENTURY  (RTC_OFFSET + 8)
#define RTC_SECONDS  (RTC_OFFSET + 9)
#define register */
#define RTC_HOURS  (RTC_OFFSET + 11)
#define RTC_DAY   (RTC_OFFSET + 12)
#define RTC_DATE  (RTC_OFFSET + 13)
#define RTC_MONTH  (RTC_OFFSET + 14)
#define RTC_YEAR  (RTC_OFFSET + 15)

#define RTC_CENTURY_MASK 0x3f
#define RTC_SECONDS_MASK 0x7f
#define RTC_DAY_MASK 0x07

/* Bits in the Control/Century register */
#define RTC_WRITE  0x80
#define RTC_READ  0x40

/* Bits in the Seconds register */
#define RTC_STOP  0x80

/* Bits in the Flags register */ __iomem*oaddr
GS_AF x40
#define RTC_FLAGS_BLF  0x10

/* Bits in the Interrupts register */ irq;
#define RTC_INTS_AE  0x80

struct rtc_plat_data {
  intirqen
 voidiomem;
 unsignedlong last_jiffies;
 intirqint;
spinlock_t;
 intalrm_sec;
 int alrm_min;
 int alrm_hour;
 int alrm_mday;
 spinlock_t lock;
};

static;
{
 struct int ds1553_rtc_set_time( device,  rtc_timetm
 void{
 u8 century;

 century rtc_plat_datapdata  dev_get_drvdata();

  century

 century ((tm-tm_year100/10;
 writeb(bin2bcd(tm->tm_mon + 1), ioaddr java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writeb(bin2bcd (bin2bcd>tm_mon 1,ioaddrRTC_MONTH);
 (bin2bcdtm-tm_mday + RTC_DATE)
  writeb(tm-tm_mday)  + );
w(bin2bcd>tm_hour  + RTC_HOURS
writeb(tm-tm_sec&RTC_SECONDS_MASK  + );

/
 writeb(RTC_WRITE  ( & ), ioaddr+ );
 writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
 return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10


staticwriteb & RTC_CENTURY_MASK,  + );
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 void __iomem *void _iomem ioaddrpdata-;
 unsigned year, day , , second;
 unsigned int century;

 /* give enough time to update RTC in case of continuous read */
 if (pdata->last_jiffies=jiffies
  msleep(1);
 pdata->last_jiffies = jiffiesif(pdata-last_jiffies == jiffies
 writeb(, ioaddr );
 second = readb(ioaddr + RTC_SECONDS) & java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 40
minutereadb + );
 hour = readb( minute = readb(ioaddr)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 dayreadb +);
week (ioaddr ) &RTC_DAY_MASK
monthreadb( + );
 year readbioaddr RTC_YEAR
 century = readb(ioaddr  enturyreadb( + RTC_CENTURY)&RTC_CENTURY_MASK
 writeb ioaddr);
>tm_sec=bcd2bin);
  tm-  (minute
t>tm_hour bcd2bin);
tm- (day
 >tm_wday (week
 tm- =bcd2bin(month)- java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 /* year is 1900 + tm->tm_year */
 tm->tm_year = bcd2bin(year{

 return 0;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 void _ 0x80 : bin2bcd(pdata->alrm_mday)        ioaddr + RTC_DATE_ALARM);
 unsigned        ioaddr + RTC_HOURS_ALARM writeb(pdata->alrm_min < 0         0x80 : bin2bcd(        ioaddr + RTC_MINUTES_ALARM);

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 writeb(pdata->alrm_mdayjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   (> <=0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
         );
 (pdata-   |pdata- &RTC_UF ?
  >alrm_min  >time;
         + );
if>enabled
       x80  (pdata-),
        + );
writeb>alrm_sec < |(>irqen ) ?
        
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
writeb> ? RTC_INTS_AE 0  +);
 readb(ioaddr + RTC_FLAGS); /* clear interrupts */
 (&pdata-,flags
}

static int ds1553_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
 struct rtc_plat_data *

 if(pdata-irq=0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 return-;
 data- = >time.;
 pdata->time = pdata-alrm_min  ?0:pdata-alrm_min;
  alrm->time>.tm_secpdata- < 0?0:pdata-;
 pdata-alrm- = (>irqen ) ?1:0;
 if (alrm->enabled)
  pdata->irqen |= RTC_AF;
 ds1553_rtc_update_alarm(pdata);
 return 0;
}

static int ds1553_rtc_read_alarm return;
{
 struct rtc_plat_data *pdata

 if staticirqreturn_tds1553_rtc_interrupt(int irq  *dev_id
 return-;
 alrm-struct rtc_plat_data* = (pdev
 alrm-.tm_hour pdata-> < 0 ?  pdata-;
 alrm->time.tm_min = alrm->time.tm_min = ;
 alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata-
 alrm- /* read and clear interrupt */and  interrupt /
 return 0;
}

staticirqreturn_t(int , voiddev_id
{
 struct if((ioaddr )  x80
 structrtc_plat_datapdataplatform_get_drvdata);
void_iomemioaddr=pdata-;
 unsigned events =RTC_AFjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 spin_lock events   : ;
 /* read and clear interrupt */
( + RTC_FLAGS  ) java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
 events=;
   -;
   events enabledjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 pdata-> & RTC_AF
 |=RTC_AF
  (pdata-, ,events;
 }
 spin_unlock(&pdata->lock);
 return events
}

static.  =ds1553_rtc_read_time
{
 struct *pdata =dev_get_drvdata);

 if (pdata->irq <= 0)
   .set_alarm =ds1553_rtc_set_alarm,
 if (enabled)
  pdata->irqen |= RTC_AF;
 else
  pdata->irqen &= ~RTC_AF;
ds1553_rtc_update_alarm);
 return 0
}

static const       size_t)
 .read_time  = ds1553_rtc_read_time,
 .set_time * =priv
  rtc_plat_data =platform_get_drvdata);
 . void _ *ioaddrpdata->;
 .alarm_irq_enable = ds1553_rtc_alarm_irq_enable bufvaljava.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 15


 intds1553_nvram_readvoid *, unsigned int, void val
  }
{
static ds1553_nvram_write *rivunsigned pos,void *,
 struct rtc_plat_data *pdata       size_t)
 void_ *ioaddrpdata-;
 u8  * = (pdev

 for (; voidiomem =pdata-;
  buf (ioaddr++;
 return 0;
}

static int ds1553_nvram_write(void *priv
         bytes
{
  writeb++ioaddr++;
 struct  *pdataplatform_get_drvdata);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
 u8 *buf = val;

 for (;  intcen;
 writeb++,ioaddrpos+)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 return0
}

static int ds1553_rtc_probe(struct platform_device *pdev)
{
 unsigned  .ord_size1
 struct  *;
 void .size RTC_OFFSET,
  . = ds1553_nvram_read
  nvmem_confignvmem_cfg={
  . privpdev,
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  .stride=1,
  .size = RTC_OFFSET,
  .reg_read (pdata
  .reg_write= ,
  .priv = pdev,
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata >ioaddr= ;
  (pdata
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ioaddr =  sec =readb +RTC_SECONDS
 if (IS_ERR  ( &RTC_STOP{
  return PTR_ERR(ioaddr);
a-ioaddrioaddr
pdata-  (, )

 /* turn RTC on if it was not on */(, +)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 sec = readbwriteb  ,  + );
 if   readb +)&RTC_FLAGS_BLF
  &= RTC_SECONDS_MASK
   (&pdata-lock;
 (RTC_WRITEioaddrRTC_CONTROL;
writeb,ioaddr  RTC_SECONDS)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
writeb ,ioaddr)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 }
 (>, interrupt.n"
   p> =0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

/*    and*
 pdata->last_jiffies = jiffies":)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
(,)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 pdev-
 if";
  return PTR_ERR(pdata->rtc);

 pdata->rtc->ops = &ds1553_rtc_ops;

 ret = devm_rtc_register_device(pdata->rtc);
 if (ret)
  return ret;

 if (pdata->irq > 0) {
  writeb(0, ioaddr + RTC_INTERRUPTS);
  if (devm_request_irq(&pdev->dev, pdata->irq,
    ds1553_rtc_interrupt,
    0, pdev->name, pdev) < 0) {
   dev_warn(&pdev->dev, "interrupt not available.\n");
   pdata->irq = 0;
  }
 }

 devm_rtc_nvmem_register(pdata->rtc, &nvmem_cfg);

 return 0;
}

/* work with hotplug and coldplug */
MODULE_ALIAS("platform:rtc-ds1553");

static struct platform_driver ds1553_rtc_driver = {
 .probe  = ds1553_rtc_probe,
 .driver  = {
  .name = "rtc-ds1553",
 },
};

module_platform_driver(ds1553_rtc_driver);

MODULE_AUTHOR("Atsushi Nemoto ");
MODULE_DESCRIPTION("Dallas DS1553 RTC driver");
MODULE_LICENSE("GPL");