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