drivers/rtc/rtc-ricoh619.c

   1 /*
   2  * drivers/rtc/rtc-ricoh619.c
   3  *
   4  * Real time clock driver for RICOH RC5T619 power management chip.
   5  *
   6  * Copyright (C) 2012-2013 RICOH COMPANY,LTD
   7  *
   8  * Based on code
   9  *  Copyright (C) 2011 NVIDIA Corporation
  10  *
  11  * this program is free software; you can redistribute it and/or modify
  12  * it under the terms of the gnu general public license as published by
  13  * the free software foundation; either version 2 of the license, or
  14  * (at your option) any later version.
  15  *
  16  * this program is distributed in the hope that it will be useful, but without
  17  * any warranty; without even the implied warranty of merchantability or
  18  * fitness for a particular purpose.  see the gnu general public license for
  19  * more details.
  20  *
  21  * you should have received a copy of the gnu general public license
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  *
  24  */
  25
  26 /* #define debug                1 */
  27 /* #define verbose_debug        1 */
  28
  29 #include <linux/device.h>
  30 #include <linux/err.h>
  31 #include <linux/init.h>
  32 #include <linux/kernel.h>
  33 #include <linux/module.h>
  34 #include <linux/mfd/ricoh619.h>
  35 #include <linux/rtc/rtc-ricoh619.h>
  36 #include <linux/platform_device.h>
  37 #include <linux/rtc.h>
  38 #include <linux/slab.h>
  39 #include <linux/irqdomain.h>
  40
  41
  42 struct ricoh619_rtc {
  43         int                     irq;
  44         struct rtc_device       *rtc;
  45         bool            irq_en;
  46 };
  47
  48 static int ricoh619_read_regs(struct device *dev, int reg, int len,
  49         uint8_t *val)
  50 {
  51         int ret;
  52
  53         ret = ricoh619_bulk_reads(dev->parent, reg, len, val);
  54         if (ret < 0) {
  55                 dev_err(dev->parent, "\n %s failed reading from 0x%02x\n",
  56                         __func__, reg);
  57                 WARN_ON(1);
  58         }
  59         return ret;
  60 }
  61
  62 static int ricoh619_write_regs(struct device *dev, int reg, int len,
  63         uint8_t *val)
  64 {
  65         int ret;
  66         ret = ricoh619_bulk_writes(dev->parent, reg, len, val);
  67         if (ret < 0) {
  68                 dev_err(dev->parent, "\n %s failed writing\n", __func__);
  69                 WARN_ON(1);
  70         }
  71
  72         return ret;
  73 }
  74
  75 // 0=OK, -EINVAL= FAIL
  76 static int ricoh619_rtc_valid_tm(struct device *dev, struct rtc_time *tm)
  77 {
  78         if (tm->tm_year > 199 || tm->tm_year < 70
  79                 || tm->tm_mon > 11 || tm->tm_mon < 0
  80                 || tm->tm_mday < 1
  81                 || tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + os_ref_year)
  82                 || tm->tm_hour >= 24 || tm->tm_hour < 0
  83                 || tm->tm_min < 0 || tm->tm_min >= 60
  84                 || tm->tm_sec < 0 || tm->tm_sec >= 60
  85                 )
  86         {
  87                 dev_err(dev->parent, "PMU: %s *** Returning error due to time, %d/%d/%d %d:%d:%d *****\n",
  88                         __func__, tm->tm_mon, tm->tm_mday, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec);
  89
  90                 return -EINVAL;
  91         }
  92
  93         return 0;
  94 }
  95
  96 static u8 dec2bcd(u8 dec)
  97 {
  98         return ((dec/10)<<4)+(dec%10);
  99 }
 100
 101 static u8 bcd2dec(u8 bcd)
 102 {
 103         return (bcd >> 4)*10+(bcd & 0xf);
 104 }
 105
 106 static void convert_bcd_to_decimal(u8 *buf, u8 len)
 107 {
 108         int i = 0;
 109         for (i = 0; i < len; i++)
 110                 buf[i] = bcd2dec(buf[i]);
 111 }
 112
 113 static void convert_decimal_to_bcd(u8 *buf, u8 len)
 114 {
 115         int i = 0;
 116         for (i = 0; i < len; i++)
 117                 buf[i] = dec2bcd(buf[i]);
 118 }
 119
 120 static void print_time(struct device *dev, struct rtc_time *tm)
 121 {
 122         dev_info(dev, "PMU: %s *** rtc-time : %d/%d/%d %d:%d:%d *****\n",
 123                 __func__, (tm->tm_mon), tm->tm_mday, (tm->tm_year + os_ref_year), tm->tm_hour, tm->tm_min,tm->tm_sec);
 124 }
 125
 126 static int ricoh619_rtc_periodic_disable(struct device *dev)
 127 {
 128         int err;
 129         uint8_t reg_data;
 130
 131         // disable function
 132         err = ricoh619_read_regs(dev, rtc_ctrl1, 1, &reg_data);
 133         if(err < 0)
 134         {
 135                 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
 136                 return err;
 137         }
 138         reg_data &= 0xf8;
 139         err = ricoh619_write_regs(dev, rtc_ctrl1, 1, &reg_data);
 140         if(err < 0)
 141         {
 142                 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
 143                 return err;
 144         }
 145
 146         // clear alarm flag and CTFG
 147         err = ricoh619_read_regs(dev, rtc_ctrl2, 1, &reg_data);
 148         if(err < 0)
 149         {
 150                 dev_err(dev->parent, "read rtc_ctrl2 error=0x%x\n", err);
 151                 return err;
 152         }
 153         reg_data &= ~0x85;// 1000-0101
 154         err = ricoh619_write_regs(dev, rtc_ctrl2, 1, &reg_data);
 155         if(err < 0)
 156         {
 157                 dev_err(dev->parent, "read rtc_ctrl2 error=0x%x\n", err);
 158                 return err;
 159         }
 160
 161         return 0;
 162 }
 163
 164 static int ricoh619_rtc_clk_adjust(struct device *dev, uint8_t clk)
 165 {
 166         return ricoh619_write_regs(dev, rtc_adjust, 1, &clk);
 167 }
 168
 169 static int ricoh619_rtc_Pon_get_clr(struct device *dev, uint8_t *Pon_f)
 170 {
 171         int err;
 172         uint8_t reg_data;
 173
 174         err = ricoh619_read_regs(dev, rtc_ctrl2,1,&reg_data);
 175         if(err < 0)
 176         {
 177                 dev_err(dev->parent, "rtc_ctrl1 read err=0x%x\n", err);
 178                 return err;
 179         }
 180 //      printk("%s,PON=1 -- CTRL2=0x%x\n", __func__, reg_data);
 181
 182         if(reg_data & 0x10)
 183         {
 184                 *Pon_f = 1;
 185                 //clear VDET PON
 186                 reg_data &= ~0x5b;// 0101-1011
 187                 reg_data |= 0x20; // 0010-0000
 188                 err = ricoh619_write_regs(dev, rtc_ctrl2, 1,&reg_data);
 189                 if(err < 0)
 190                 {
 191                         dev_err(dev->parent, "rtc_ctrl1 write err=0x%x\n", err);
 192                 }
 193         }
 194         else
 195         {
 196                 *Pon_f = 0;
 197         }
 198
 199
 200         return err;
 201 }
 202
 203 // 0-12hour, 1-24hour
 204 /*
 205 static int ricoh619_rtc_hour_mode_get(struct device *dev, uint8_t *mode)
 206 {
 207         int err;
 208
 209         err = ricoh619_read_regs(dev, rtc_ctrl1, 1, mode);
 210         if(err < 0)
 211                 dev_err(dev->parent, "read rtc ctrl1 error\n");
 212
 213         if(*mode & 0x20)
 214                 *mode = 1;
 215         else
 216                 *mode = 0;
 217
 218         return err;
 219 }
 220 */
 221 // 0-12hour, 1-24hour
 222 static int ricoh619_rtc_hour_mode_set(struct device *dev, int mode)
 223 {
 224         uint8_t reg_data;
 225         int err;
 226
 227         err = ricoh619_read_regs(dev, rtc_ctrl1, 1, &reg_data);
 228         if(err < 0)
 229         {
 230                 dev_err(dev->parent, "read rtc_ctrl1 error\n");
 231                 return err;
 232         }
 233         if(mode == 0)
 234                 reg_data &= 0xDF;
 235         else
 236                 reg_data |= 0x20;
 237         err = ricoh619_write_regs(dev, rtc_ctrl1, 1, &reg_data);
 238         if(err < 0)
 239         {
 240                 dev_err(dev->parent, "write rtc_ctrl1 error\n");
 241         }
 242
 243         return err;
 244 }
 245
 246
 247 static int ricoh619_rtc_read_time(struct device *dev, struct rtc_time *tm)
 248 {
 249         u8 buff[7];
 250         int err;
 251         int cent_flag;
 252
 253         err = ricoh619_read_regs(dev, rtc_seconds_reg, sizeof(buff), buff);
 254
 255         if (err < 0) {
 256                 dev_err(dev->parent, "PMU: %s *** failed to read time *****\n", __func__);
 257                 return err;
 258         }
 259
 260         if (buff[5] & 0x80)
 261                 cent_flag = 1;
 262         else
 263                 cent_flag = 0;
 264
 265         buff[5] = buff[5]&0x1f; //bit5 19_20
 266         convert_bcd_to_decimal(buff, sizeof(buff));
 267
 268         tm->tm_sec  = buff[0];
 269         tm->tm_min  = buff[1];
 270         tm->tm_hour = buff[2];  //bit5 PA_H20
 271         tm->tm_wday = buff[3];
 272         tm->tm_mday = buff[4];
 273         tm->tm_mon  = buff[5];  //for print
 274         tm->tm_year = buff[6] + 100 * cent_flag;
 275         print_time(dev, tm);    //for print
 276         tm->tm_mon  = buff[5] - 1;  //back to system 0-11
 277
 278 //      printk(KERN_INFO "PMU: %s year=%d mon=%d day=% hour=%d min =%d sec=%d\n", __func__,
 279 //      tm->tm_year,tm->tm_mon  ,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec );
 280
 281         return 0;
 282 }
 283
 284 static int ricoh619_rtc_set_time(struct device *dev, struct rtc_time *tm)
 285 {
 286         u8 buff[7];
 287         int err;
 288         int cent_flag;
 289
 290 //      printk(KERN_INFO "PMU: %s year=%d mon=%d day=% hour=%d min =%d sec=%d\n", __func__,
 291 //      tm->tm_year,tm->tm_mon  ,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec );
 292
 293         if(ricoh619_rtc_valid_tm(dev, tm) != 0)
 294         {
 295                 return -EINVAL;
 296         }
 297
 298         if (tm->tm_year >= 100)
 299                 cent_flag = 1;
 300         else
 301                 cent_flag = 0;
 302
 303         tm->tm_mon = tm->tm_mon + 1;
 304         buff[0] = tm->tm_sec;
 305         buff[1] = tm->tm_min;
 306         buff[2] = tm->tm_hour;
 307         buff[3] = tm->tm_wday;
 308         buff[4] = tm->tm_mday;
 309         buff[5] = tm->tm_mon; //system set 0-11
 310         buff[6] = tm->tm_year - 100 * cent_flag;
 311         print_time(dev, tm);    // RTC_TEST
 312
 313         convert_decimal_to_bcd(buff, sizeof(buff));
 314
 315         if (1 == cent_flag)
 316                 buff[5] |= 0x80;
 317
 318         err = ricoh619_write_regs(dev, rtc_seconds_reg, sizeof(buff), buff);
 319         if (err < 0) {
 320                 dev_err(dev->parent, "\n failed to program new time\n");
 321                 return err;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static int ricoh619_rtc_alarm_is_enabled(struct device *dev,  uint8_t *enabled)
 328 {
 329         int err;
 330         uint8_t reg_data;
 331
 332         err = 0;
 333         err = ricoh619_read_regs(dev, rtc_ctrl1,1,&reg_data);
 334         if(err<0)
 335         {
 336                 dev_err(dev->parent, "read rtc_ctrl1 error 0x%x\n", err);
 337                 *enabled = 0;
 338         }
 339         else
 340         {
 341                 if(reg_data & 0x40)
 342                         *enabled = 1;
 343                 else
 344                         *enabled = 0;
 345         }
 346         return err;
 347 }
 348
 349 // 0-disable, 1-enable
 350 static int ricoh619_rtc_alarm_enable(struct device *dev, unsigned int enabled)
 351 {
 352         struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
 353         int err;
 354         uint8_t reg_data;
 355
 356 //      printk(KERN_INFO "PMU: %s :%d\n", __func__,enabled);
 357
 358         err = 0;
 359         if(enabled)
 360         {
 361                 rtc->irq_en = 1;
 362                 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,&reg_data);
 363                 if(err < 0)
 364                 {
 365                         dev_err(dev->parent, "read rtc_ctrl1 error =%d\n", err);
 366                         goto ERR;
 367                 }
 368                 reg_data |= 0x40;// set DALE
 369                 err = ricoh619_write_regs(dev, rtc_ctrl1, 1,&reg_data);
 370                 if(dev < 0)
 371                         dev_err(dev->parent, "write rtc_ctrl1 error =%d\n", err);
 372         }
 373         else
 374         {
 375                 rtc->irq_en = 0;
 376                 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,&reg_data);
 377                 if(err < 0)
 378                 {
 379                         dev_err(dev->parent, "read rtc_ctrl1 error =%d\n", err);
 380                         goto ERR;
 381                 }
 382                 reg_data &= 0xbf;// clear DALE
 383                 err = ricoh619_write_regs(dev, rtc_ctrl1, 1,&reg_data);
 384                 if(dev < 0)
 385                         dev_err(dev->parent, "write rtc_ctrl1 error =%d\n", err);
 386         }
 387
 388 ERR:
 389         return err;
 390 }
 391
 392 static int ricoh619_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 393 {
 394         u8 buff[6];
 395         u8 buff_cent;
 396         int err;
 397         int cent_flag;
 398         unsigned char enabled_flag;
 399
 400 //      printk(KERN_INFO "PMU: %s\n", __func__);
 401
 402         err = 0;
 403
 404         alrm->time.tm_sec  = 0;
 405         alrm->time.tm_min  = 0;
 406         alrm->time.tm_hour = 0;
 407         alrm->time.tm_mday = 0;
 408         alrm->time.tm_mon  = 0;
 409         alrm->time.tm_year = 0;
 410         alrm->enabled = 0;
 411
 412         err = ricoh619_read_regs(dev, rtc_month_reg, 1, &buff_cent);
 413         if (err < 0) {
 414                 dev_err(dev->parent, "PMU: %s *** failed to read time *****\n", __func__);
 415                 return err;
 416         }
 417         if (buff_cent & 0x80)
 418                 cent_flag = 1;
 419         else
 420                 cent_flag = 0;
 421
 422         err = ricoh619_read_regs(dev, rtc_alarm_y_sec, sizeof(buff), buff);
 423         if(err <0)
 424         {
 425                 dev_err(dev->parent, "RTC: %s *** read rtc_alarm timer error =%d\n", __func__, err);
 426                 return err;
 427         }
 428
 429         err = ricoh619_read_regs(dev, rtc_ctrl1, 1,&enabled_flag);
 430         if(err<0)
 431         {
 432                 dev_err(dev->parent, "RTC: %s *** read rtc_enable flag error =%d\n", __func__, err);
 433                 return err;
 434         }
 435         if(enabled_flag & 0x40)
 436                 enabled_flag = 1;
 437         else
 438                 enabled_flag = 0;
 439
 440         buff[3] &= ~0x80;       /* clear DAL_EXT */
 441
 442         buff[3] = buff[3]&0x3f;
 443         convert_bcd_to_decimal(buff, sizeof(buff));
 444
 445         alrm->time.tm_sec  = buff[0];
 446         alrm->time.tm_min  = buff[1];
 447         alrm->time.tm_hour = buff[2];
 448         alrm->time.tm_mday = buff[3];
 449         alrm->time.tm_mon = buff[4];// for print
 450         alrm->time.tm_year = buff[5] + 100 * cent_flag;
 451         dev_info(dev, "PMU: read alarm: %d/%d/%d %d:%d:%d *****\n",
 452                 (alrm->time.tm_mon), alrm->time.tm_mday, (alrm->time.tm_year + os_ref_year), alrm->time.tm_hour, alrm->time.tm_min,alrm->time.tm_sec);
 453         alrm->time.tm_mon  = buff[4] - 1;
 454         alrm->enabled = enabled_flag;
 455
 456         return 0;
 457 }
 458
 459 static int ricoh619_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 460 {
 461         struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
 462         u8 buff[6];
 463         int err;
 464         int cent_flag;
 465
 466 //      printk(KERN_INFO "PMU: %s\n", __func__);
 467         err = 0;
 468         ricoh619_rtc_alarm_enable(dev, 0);
 469         if (rtc->irq == -1)
 470         {
 471                 err = -EIO;
 472                 goto ERR;
 473         }
 474
 475         if(alrm->enabled== 0)
 476                 return 0;
 477
 478         if (alrm->time.tm_year >= 100)
 479                 cent_flag = 1;
 480         else
 481                 cent_flag = 0;
 482
 483         alrm->time.tm_mon += 1;
 484         print_time(dev->parent, &alrm->time);
 485         buff[0] = alrm->time.tm_sec;
 486         buff[1] = alrm->time.tm_min;
 487         buff[2] = alrm->time.tm_hour;
 488         buff[3] = alrm->time.tm_mday;
 489         buff[4] = alrm->time.tm_mon;
 490 //      buff[5] = alrm->time.tm_year - rtc_year_offset;
 491         buff[5] = alrm->time.tm_year - 100 * cent_flag;
 492         convert_decimal_to_bcd(buff, sizeof(buff));
 493         buff[3] |= 0x80;        /* set DAL_EXT */
 494         err = ricoh619_write_regs(dev, rtc_alarm_y_sec, sizeof(buff), buff);
 495         if (err<0) {
 496                 dev_err(dev->parent, "\n unable to set alarm\n");
 497                 err = -EBUSY;
 498                 goto ERR;
 499         }
 500
 501         ricoh619_rtc_alarm_enable(dev, alrm->enabled);
 502
 503 ERR:
 504         return err;
 505 }
 506
 507 static const struct rtc_class_ops ricoh619_rtc_ops = {
 508         .read_time      = ricoh619_rtc_read_time,
 509         .set_time       = ricoh619_rtc_set_time,
 510         .set_alarm      = ricoh619_rtc_set_alarm,
 511         .read_alarm     = ricoh619_rtc_read_alarm,
 512         .alarm_irq_enable = ricoh619_rtc_alarm_enable,
 513 };
 514
 515 static int ricoh619_rtc_alarm_flag_clr(struct device *dev)
 516 {
 517         int err;
 518         uint8_t reg_data;
 519
 520         /* clear alarm-D status bits.*/
 521         err = ricoh619_read_regs(dev, rtc_ctrl2, 1, &reg_data);
 522         if (err<0)
 523                 dev_err(dev->parent, "unable to read rtc_ctrl2 reg\n");
 524
 525         /* to clear alarm-D flag, and set adjustment parameter */
 526         reg_data &= ~0x81;
 527         err = ricoh619_write_regs(dev, rtc_ctrl2, 1, &reg_data);
 528         if (err<0)
 529                 dev_err(dev->parent, "unable to program rtc_status reg\n");
 530         return err;
 531 }
 532 static irqreturn_t ricoh619_rtc_irq(int irq, void *data)
 533 {
 534         struct device *dev = data;
 535         struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
 536
 537 //      printk(KERN_INFO "PMU: %s\n", __func__);
 538
 539         ricoh619_rtc_alarm_flag_clr(dev);
 540
 541         rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
 542         return IRQ_HANDLED;
 543 }
 544
 545 #ifdef CONFIG_OF
 546 static struct ricoh619_rtc_platform_data *ricoh619_rtc_dt_init(struct platform_device *pdev)
 547 {
 548         struct device_node *nproot = pdev->dev.parent->of_node;
 549         struct device_node *np;
 550         struct ricoh619_rtc_platform_data *pdata;
 551
 552         if (!nproot)
 553                 return pdev->dev.platform_data;
 554
 555         np = of_find_node_by_name(nproot, "rtc");
 556         if (!np) {
 557                 dev_err(&pdev->dev, "failed to find rtc node\n");
 558                 return NULL;
 559         }
 560
 561         pdata = devm_kzalloc(&pdev->dev,
 562                         sizeof(struct ricoh619_rtc_platform_data),
 563                         GFP_KERNEL);
 564
 565         of_property_read_u32(np, "ricoh,rtc-tm-year", &pdata->time.tm_year);
 566         of_property_read_u32(np, "ricoh,rtc-tm-month", &pdata->time.tm_mon);
 567         of_property_read_u32(np, "ricoh,rtc-tm-mday", &pdata->time.tm_mday);
 568         of_property_read_u32(np, "ricoh,rtc-tm-hour", &pdata->time.tm_hour);
 569         of_property_read_u32(np, "ricoh,rtc-tm-min", &pdata->time.tm_min);
 570         of_property_read_u32(np, "ricoh,rtc-tm-sec", &pdata->time.tm_sec);
 571         of_node_put(np);
 572
 573         return pdata;
 574 }
 575 #else
 576 static struct ricoh619_rtc_platform_data *
 577 ricoh619_rtc_dt_init(struct platform_device *pdev)
 578 {
 579         return pdev->dev.platform_data;
 580 }
 581 #endif
 582
 583 static int ricoh619_rtc_probe(struct platform_device *pdev)
 584 {
 585         struct ricoh619_rtc_platform_data *pdata;
 586         struct ricoh619 *ricoh619 = dev_get_drvdata(pdev->dev.parent);
 587         struct ricoh619_rtc *rtc;
 588         struct rtc_time tm;
 589         uint8_t Pon_flag,Alarm_flag;
 590         int err;
 591         uint8_t buff[6];
 592
 593 //      printk(KERN_INFO "******PMU RTC: Version 2014-01-01 REDS!******\n");
 594
 595         pdata = ricoh619_rtc_dt_init(pdev);
 596         if (!pdata) {
 597                 dev_err(&pdev->dev, "platform data isn't assigned to "
 598                         "rtc\n");
 599                 return -EINVAL;
 600         }
 601          printk("%s,line=%d\n", __func__,__LINE__);
 602
 603         rtc = devm_kzalloc(ricoh619->dev,sizeof(*rtc), GFP_KERNEL);
 604         if(IS_ERR(rtc))
 605         {
 606                 err = PTR_ERR(rtc);
 607                 dev_err(&pdev->dev, "no enough memory for ricoh619_rtc using\n");
 608                 return -ENOMEM;
 609         }
 610
 611         dev_set_drvdata(&pdev->dev, rtc);
 612         if(IS_ERR(rtc->rtc))
 613         {
 614                 err = PTR_ERR(rtc->rtc);
 615                 goto fail;
 616         }
 617
 618         rtc->irq  = irq_create_mapping(ricoh619->irq_domain, RICOH619_IRQ_DALE);
 619         if(rtc->irq  < 0)
 620         {
 621                 dev_err(&pdev->dev, "\n no irq specified, wakeup is disabled\n");
 622                 rtc->irq = -1;
 623                 rtc->irq_en = 0;
 624         }
 625         else
 626                 rtc->irq_en = 1;
 627         //get interrupt flag
 628         err = ricoh619_rtc_alarm_is_enabled(&pdev->dev, &Alarm_flag);
 629         if (err<0)
 630         {
 631                 dev_err(&pdev->dev, "5T619 RTC: Disable alarm interrupt error\n");
 632                 goto fail;
 633
 634         }
 635
 636         // get PON flag
 637         err = ricoh619_rtc_Pon_get_clr(&pdev->dev, &Pon_flag);
 638         if (err<0)
 639         {
 640                 dev_err(&pdev->dev, "5T619 RTC: get PON flag error\n");
 641                 goto fail;
 642         }
 643
 644         // disable rtc periodic function
 645         err = ricoh619_rtc_periodic_disable(&pdev->dev);
 646         if (err<0)
 647         {
 648                 dev_err(&pdev->dev, "5T619 RTC: disable rtc periodic int error\n");
 649                 goto fail;
 650         }
 651
 652         // clearing RTC Adjust register
 653         err = ricoh619_rtc_clk_adjust(&pdev->dev, 0);
 654         if (err<0)
 655         {
 656                 dev_err(&pdev->dev, "unable to program rtc_adjust reg\n");
 657                 err = -EBUSY;
 658                 goto fail;
 659         }
 660
 661         //disable interrupt
 662         err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
 663         if (err<0)
 664         {
 665                 dev_err(&pdev->dev, "5T619 RTC: Disable alarm interrupt error\n");
 666                 goto fail;
 667         }
 668
 669         // PON=1
 670         if(Pon_flag)
 671         {
 672                 Alarm_flag = 0;
 673                 // clear int flag
 674                 err = ricoh619_rtc_alarm_flag_clr(&pdev->dev);
 675                 if (err<0)
 676                 {
 677                         dev_err(&pdev->dev, "5T619 RTC: Pon=1 clear alarm flag error\n");
 678                         goto fail;
 679                 }
 680
 681                 // using 24h-mode
 682                 err = ricoh619_rtc_hour_mode_set(&pdev->dev,1);
 683                 if (err<0)
 684                 {
 685                         dev_err(&pdev->dev, "5T619 RTC: Pon=1 set 24h-mode error\n");
 686                         goto fail;
 687                 }
 688
 689                 // setting the default year
 690 //              printk(KERN_INFO "PMU: %s Set default time\n", __func__);
 691
 692                 pdata->time.tm_sec=0;
 693                 pdata->time.tm_min=0;
 694                 pdata->time.tm_hour=0;
 695                 pdata->time.tm_wday=6;
 696                 pdata->time.tm_mday=1;
 697                 pdata->time.tm_mon=1;
 698                 pdata->time.tm_year=2012;
 699                 pdata->time.tm_year -= os_ref_year;
 700                 if(ricoh619_rtc_valid_tm(&pdev->dev, &(pdata->time)) == 0)
 701                 {
 702                         tm.tm_sec   = pdata->time.tm_sec;
 703                         tm.tm_min  = pdata->time.tm_min;
 704                         tm.tm_hour = pdata->time.tm_hour;
 705                         tm.tm_wday= pdata->time.tm_wday;
 706                         tm.tm_mday= pdata->time.tm_mday;
 707                         tm.tm_mon  = pdata->time.tm_mon-1;
 708                         tm.tm_year = pdata->time.tm_year;
 709                 }
 710                 else
 711                 {
 712                         // using the ricoh default time instead of board default time
 713                         dev_err(&pdev->dev, "board rtc default is erro\n");
 714                         tm.tm_sec  = 0;
 715                         tm.tm_min  = 0;
 716                         tm.tm_hour = 0;
 717                         tm.tm_wday = 4;
 718                         tm.tm_mday = 1;
 719                         tm.tm_mon  = 0;
 720                         tm.tm_year = 70;
 721                 }
 722
 723                 // set default alarm time
 724                 if (tm.tm_year >= 100)
 725                         buff[5] = tm.tm_year-100-1;
 726                 else
 727                         buff[5] = tm.tm_year-1;
 728                 buff[0] = tm.tm_sec;
 729                 buff[1] = tm.tm_min;
 730                 buff[2] = tm.tm_hour;
 731                 buff[3] = tm.tm_mday;
 732                 buff[4] = tm.tm_mon +1;
 733
 734                 err = ricoh619_rtc_set_time(&pdev->dev, &tm);
 735                 if (err<0)
 736                 {
 737                         dev_err(&pdev->dev, "5t619 RTC:\n failed to set time\n");
 738                         goto fail;
 739                 }
 740
 741                 convert_decimal_to_bcd(buff, sizeof(buff));
 742                 buff[3] |= 0x80;        /* set DAL_EXT */
 743
 744                 err = ricoh619_write_regs(&pdev->dev, rtc_alarm_y_sec, sizeof(buff), buff);
 745                 if (err<0)
 746                         printk( "\n unable to set alarm\n");
 747
 748         }
 749
 750         device_init_wakeup(&pdev->dev, 1);
 751
 752 //      printk(KERN_INFO "PMU: %s register rtc device \n", __func__);
 753         rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
 754                                        &ricoh619_rtc_ops, THIS_MODULE);
 755
 756         // set interrupt and enable it
 757         if(rtc->irq != -1) {
 758                 err = devm_request_threaded_irq(&pdev->dev,rtc->irq, NULL, ricoh619_rtc_irq,
 759                                         IRQF_ONESHOT, "rtc_ricoh619", &pdev->dev);
 760                 if (err<0)
 761                 {
 762                         dev_err(&pdev->dev, "request IRQ:%d fail\n", rtc->irq);
 763                         rtc->irq = -1;
 764                         err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
 765                         if (err<0)
 766                         {
 767                                 dev_err(&pdev->dev, "5T619 RTC: enable rtc alarm error\n");
 768                                 goto fail;
 769                         }
 770                 }
 771                 else{
 772                         // enable wake
 773                         enable_irq_wake(rtc->irq);
 774                         // enable alarm_d
 775                         err = ricoh619_rtc_alarm_enable(&pdev->dev, Alarm_flag);
 776                         if (err<0)
 777                         {
 778                                 dev_err(&pdev->dev, "failed rtc setup\n");
 779                                 err = -EBUSY;
 780                                 goto fail;
 781                         }
 782                 }
 783         }
 784         else
 785         {
 786                 // system don't want to using alarm interrupt, so close it
 787                 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
 788                 if (err<0)
 789                 {
 790                         dev_err(&pdev->dev, "5T619 RTC: Disable rtc alarm error\n");
 791                         goto fail;
 792                 }
 793                 dev_err(&pdev->dev, "ricoh619 interrupt is disabled\n");
 794         }
 795         printk(KERN_INFO "RICOH619 RTC Register Success\n");
 796
 797         ricoh619_read_regs(&pdev->dev, rtc_ctrl1, 1,&buff[0]);
 798         ricoh619_read_regs(&pdev->dev, rtc_ctrl2, 1,&buff[1]);
 799 //      printk(KERN_INFO "0xAE:%x 0xAF:%x\n",buff[0],buff[1]);
 800         return 0;
 801
 802 fail:
 803         if (!IS_ERR_OR_NULL(rtc->rtc))
 804                 rtc_device_unregister(rtc->rtc);
 805         kfree(rtc);
 806         return err;
 807 }
 808
 809 static int ricoh619_rtc_remove(struct platform_device *pdev)
 810 {
 811         struct ricoh619_rtc *rtc = dev_get_drvdata(&pdev->dev);
 812
 813         rtc_device_unregister(rtc->rtc);
 814         kfree(rtc);
 815         return 0;
 816 }
 817
 818 #ifdef CONFIG_OF
 819 static const struct of_device_id ricoh619_rtc_dt_match[] = {
 820         { .compatible = "ricoh,ricoh619-rtc", },
 821         {},
 822 };
 823 MODULE_DEVICE_TABLE(of, ricoh619_rtc_dt_match);
 824 #endif
 825
 826 static struct platform_driver ricoh619_rtc_driver = {
 827         .driver = {
 828                 .name   = "ricoh619-rtc",
 829                 .owner  = THIS_MODULE,
 830                 .of_match_table = of_match_ptr(ricoh619_rtc_dt_match),
 831         },
 832         .probe  = ricoh619_rtc_probe,
 833         .remove = ricoh619_rtc_remove,
 834 };
 835
 836 static int __init ricoh619_rtc_init(void)
 837 {
 838         return platform_driver_register(&ricoh619_rtc_driver);
 839 }
 840 subsys_initcall_sync(ricoh619_rtc_init);
 841
 842 static void __exit ricoh619_rtc_exit(void)
 843 {
 844         platform_driver_unregister(&ricoh619_rtc_driver);
 845 }
 846 module_exit(ricoh619_rtc_exit);
 847
 848 MODULE_DESCRIPTION("RICOH RICOH619 RTC driver");
 849 MODULE_ALIAS("platform:rtc_ricoh619");
 850 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
 851 MODULE_LICENSE("GPL");
 852