drivers/rtc/rtc-rk818.c

   1 /*
   2  *      Real Time Clock driver for  rk818
   3  *
   4  *  Author: zhangqing <zhangqing@rock-chips.com>
   5  *
   6  *  This program is free software; you can redistribute  it and/or modify it
   7  *  under  the terms of  the GNU General  Public License as published by the
   8  *  Free Software Foundation;  either version 2 of the  License, or (at your
   9  *  option) any later version.
  10  *
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/time.h>
  16 #include <linux/rtc.h>
  17 #include <linux/slab.h>
  18 #include <linux/bcd.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/ioctl.h>
  21 #include <linux/completion.h>
  22 #include <linux/mfd/rk818.h>
  23 #include <linux/delay.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/miscdevice.h>
  26 #include <linux/irqdomain.h>
  27
  28
  29 /* RTC Definitions */
  30 /* RTC_CTRL_REG bitfields */
  31 #define BIT_RTC_CTRL_REG_STOP_RTC_M             0x01
  32 #define BIT_RTC_CTRL_REG_ROUND_30S_M            0x02
  33 #define BIT_RTC_CTRL_REG_AUTO_COMP_M            0x04
  34 #define BIT_RTC_CTRL_REG_MODE_12_24_M           0x08
  35 #define BIT_RTC_CTRL_REG_TEST_MODE_M            0x10
  36 #define BIT_RTC_CTRL_REG_SET_32_COUNTER_M       0x20
  37 #define BIT_RTC_CTRL_REG_GET_TIME_M             0x40
  38 #define BIT_RTC_CTRL_REG_RTC_V_OPT_M            0x80
  39
  40 /* RTC_STATUS_REG bitfields */
  41 #define BIT_RTC_STATUS_REG_RUN_M                0x02
  42 #define BIT_RTC_STATUS_REG_1S_EVENT_M           0x04
  43 #define BIT_RTC_STATUS_REG_1M_EVENT_M           0x08
  44 #define BIT_RTC_STATUS_REG_1H_EVENT_M           0x10
  45 #define BIT_RTC_STATUS_REG_1D_EVENT_M           0x20
  46 #define BIT_RTC_STATUS_REG_ALARM_M              0x40
  47 #define BIT_RTC_STATUS_REG_POWER_UP_M           0x80
  48
  49 /* RTC_INTERRUPTS_REG bitfields */
  50 #define BIT_RTC_INTERRUPTS_REG_EVERY_M          0x03
  51 #define BIT_RTC_INTERRUPTS_REG_IT_TIMER_M       0x04
  52 #define BIT_RTC_INTERRUPTS_REG_IT_ALARM_M       0x08
  53
  54 /* DEVCTRL bitfields */
  55 #define BIT_RTC_PWDN                            0x40
  56
  57 /* REG_SECONDS_REG through REG_YEARS_REG is how many registers? */
  58 #define ALL_TIME_REGS                           7
  59 #define ALL_ALM_REGS                            6
  60
  61
  62 #define RTC_SET_TIME_RETRIES    5
  63 #define RTC_GET_TIME_RETRIES    5
  64
  65
  66 struct rk818_rtc {
  67         struct rk818 *rk818;
  68         struct rtc_device *rtc;
  69         unsigned int alarm_enabled:1;
  70 };
  71
  72 /*
  73  * Read current time and date in RTC
  74  */
  75 static int rk818_rtc_readtime(struct device *dev, struct rtc_time *tm)
  76 {
  77         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
  78         struct rk818 *rk818 = rk818_rtc->rk818;
  79         int ret;
  80         //int count = 0;
  81         unsigned char rtc_data[ALL_TIME_REGS + 1];
  82         u8 rtc_ctl;
  83
  84         /*Dummy read*/
  85         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
  86
  87         /* Has the RTC been programmed? */
  88         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
  89         if (ret < 0) {
  90                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
  91                 return ret;
  92         }
  93
  94         rtc_ctl = ret & (~BIT_RTC_CTRL_REG_RTC_V_OPT_M);
  95
  96         ret = rk818_reg_write(rk818, RK818_RTC_CTRL_REG, rtc_ctl);
  97         if (ret < 0) {
  98                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
  99                 return ret;
 100         }
 101
 102 #if 0
 103         /* Read twice to make sure we don't read a corrupt, partially
 104          * incremented, value.
 105          */
 106         do {
 107                 ret = rk818_bulk_read(rk818, RK818_SECONDS_REG,
 108                                        ALL_TIME_REGS, rtc_data);
 109                 if (ret != 0)
 110                         continue;
 111
 112                 tm->tm_sec = bcd2bin(rtc_data[0]);
 113                 tm->tm_min = bcd2bin(rtc_data[1]);
 114                 tm->tm_hour = bcd2bin(rtc_data[2]) ;
 115                 tm->tm_mday = bcd2bin(rtc_data[3]);
 116                 tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
 117                 tm->tm_year = bcd2bin(rtc_data[5]) + 100;
 118                 tm->tm_wday = bcd2bin(rtc_data[6]);
 119
 120                 printk( "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 121                         1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,
 122                         tm->tm_hour, tm->tm_min, tm->tm_sec);
 123
 124                 return ret;
 125
 126         } while (++count < RTC_GET_TIME_RETRIES);
 127         dev_err(dev, "Timed out reading current time\n");
 128 #else
 129         rtc_data[0] = rk818_reg_read(rk818,0x00);
 130         rtc_data[1] = rk818_reg_read(rk818,0x01);
 131         rtc_data[2] = rk818_reg_read(rk818,0x02);
 132         rtc_data[3] = rk818_reg_read(rk818,0x03);
 133         rtc_data[4] = rk818_reg_read(rk818,0x04);
 134         rtc_data[5] = rk818_reg_read(rk818,0x05);
 135         rtc_data[6] = rk818_reg_read(rk818,0x06);
 136
 137          tm->tm_sec = bcd2bin(rtc_data[0]);
 138          tm->tm_min = bcd2bin(rtc_data[1]);
 139          tm->tm_hour = bcd2bin(rtc_data[2]) ;
 140          tm->tm_mday = bcd2bin(rtc_data[3]);
 141          tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
 142          tm->tm_year = bcd2bin(rtc_data[5]) + 100;
 143          tm->tm_wday = bcd2bin(rtc_data[6]);
 144
 145           dev_dbg(dev, "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 146                         1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,tm->tm_hour , tm->tm_min, tm->tm_sec);
 147
 148 #endif
 149         return 0;
 150
 151 }
 152
 153 /*
 154  * Set current time and date in RTC
 155  */
 156 static int rk818_rtc_set_time(struct device *dev, struct rtc_time *tm)
 157 {
 158         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
 159         struct rk818 *rk818 = rk818_rtc->rk818;
 160         int ret;
 161         u8 rtc_ctl;
 162         unsigned char rtc_data[ALL_TIME_REGS + 1];
 163
 164         rtc_data[0] = bin2bcd(tm->tm_sec);
 165         rtc_data[1] = bin2bcd(tm->tm_min);
 166         rtc_data[2] = bin2bcd(tm->tm_hour );
 167         rtc_data[3] = bin2bcd(tm->tm_mday);
 168         rtc_data[4] = bin2bcd(tm->tm_mon + 1);
 169         rtc_data[5] = bin2bcd(tm->tm_year - 100);
 170         rtc_data[6] = bin2bcd(tm->tm_wday);
 171
 172          dev_dbg(dev, "set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 173                         1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,tm->tm_hour , tm->tm_min, tm->tm_sec);
 174
 175         /*Dummy read*/
 176         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
 177
 178         /* Stop RTC while updating the TC registers */
 179         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
 180         if (ret < 0) {
 181                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
 182                 return ret;
 183         }
 184
 185         rtc_ctl = ret | (BIT_RTC_CTRL_REG_STOP_RTC_M);
 186
 187         ret = rk818_reg_write(rk818, RK818_RTC_CTRL_REG, rtc_ctl);
 188         if (ret < 0) {
 189                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
 190                 return ret;
 191         }
 192 #if 0
 193         /* update all the time registers in one shot */
 194         ret = rk818_bulk_write(rk818, RK818_SECONDS_REG,
 195                                        ALL_TIME_REGS, rtc_data);
 196         if (ret < 0) {
 197                 dev_err(dev, "Failed to read RTC times: %d\n", ret);
 198                 return ret;
 199         }
 200 #else
 201         rk818_reg_write(rk818,0x00,rtc_data[0]);
 202         rk818_reg_write(rk818,0x01,rtc_data[1]);
 203         rk818_reg_write(rk818,0x02,rtc_data[2]);
 204         rk818_reg_write(rk818,0x03,rtc_data[3]);
 205         rk818_reg_write(rk818,0x04,rtc_data[4]);
 206         rk818_reg_write(rk818,0x05,rtc_data[5]);
 207         rk818_reg_write(rk818,0x06,rtc_data[6]);
 208
 209 #endif
 210         /*Dummy read*/
 211         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
 212
 213         /* Start RTC again */
 214         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
 215         if (ret < 0) {
 216                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
 217                 return ret;
 218         }
 219
 220         rtc_ctl = ret &(~ BIT_RTC_CTRL_REG_STOP_RTC_M);
 221
 222         ret = rk818_reg_write(rk818, RK818_RTC_CTRL_REG, rtc_ctl);
 223         if (ret < 0) {
 224                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
 225                 return ret;
 226         }
 227
 228         return 0;
 229 }
 230
 231 /*
 232  * Read alarm time and date in RTC
 233  */
 234 static int rk818_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
 235 {
 236         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
 237         int ret;
 238         unsigned char alrm_data[ALL_ALM_REGS + 1];
 239 #if 0
 240         ret = rk818_bulk_read(rk818_rtc->rk818, RK818_ALARM_SECONDS_REG,
 241                                ALL_ALM_REGS, alrm_data);
 242         if (ret != 0) {
 243                 dev_err(dev, "Failed to read alarm time: %d\n", ret);
 244                 return ret;
 245         }
 246 #else
 247         alrm_data[0] = rk818_reg_read(rk818_rtc->rk818,0x08);
 248         alrm_data[1] = rk818_reg_read(rk818_rtc->rk818,0x09);
 249         alrm_data[2] = rk818_reg_read(rk818_rtc->rk818,0x0a);
 250         alrm_data[3] = rk818_reg_read(rk818_rtc->rk818,0x0b);
 251         alrm_data[4] = rk818_reg_read(rk818_rtc->rk818,0x0c);
 252         alrm_data[5] = rk818_reg_read(rk818_rtc->rk818,0x0d);
 253
 254
 255 #endif
 256         /* some of these fields may be wildcard/"match all" */
 257         alrm->time.tm_sec = bcd2bin(alrm_data[0]);
 258         alrm->time.tm_min = bcd2bin(alrm_data[1]);
 259         alrm->time.tm_hour = bcd2bin(alrm_data[2]);
 260         alrm->time.tm_mday = bcd2bin(alrm_data[3]);
 261         alrm->time.tm_mon = bcd2bin(alrm_data[4]) - 1;
 262         alrm->time.tm_year = bcd2bin(alrm_data[5]) + 100;
 263
 264         ret = rk818_reg_read(rk818_rtc->rk818, RK818_RTC_INT_REG);
 265         if (ret < 0) {
 266                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
 267                 return ret;
 268         }
 269         dev_dbg(dev,"alrm read RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 270                         1900 + alrm->time.tm_year, alrm->time.tm_mon + 1, alrm->time.tm_mday, alrm->time.tm_wday, alrm->time.tm_hour, alrm->time.tm_min, alrm->time.tm_sec);
 271
 272
 273
 274         if (ret & BIT_RTC_INTERRUPTS_REG_IT_ALARM_M)
 275                 alrm->enabled = 1;
 276         else
 277                 alrm->enabled = 0;
 278
 279         return 0;
 280 }
 281
 282 static int rk818_rtc_stop_alarm(struct rk818_rtc *rk818_rtc)
 283 {
 284         rk818_rtc->alarm_enabled = 0;
 285
 286         return rk818_clear_bits(rk818_rtc->rk818, RK818_RTC_INT_REG,
 287                                BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
 288
 289 }
 290
 291 static int rk818_rtc_start_alarm(struct rk818_rtc *rk818_rtc)
 292 {
 293         rk818_rtc->alarm_enabled = 1;
 294
 295         return rk818_set_bits(rk818_rtc->rk818, RK818_RTC_INT_REG,
 296                                BIT_RTC_INTERRUPTS_REG_IT_ALARM_M,BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
 297
 298 }
 299
 300 static int rk818_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 301 {
 302         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
 303         int ret;
 304         unsigned char alrm_data[ALL_TIME_REGS + 1];
 305
 306         ret = rk818_rtc_stop_alarm(rk818_rtc);
 307         if (ret < 0) {
 308                 dev_err(dev, "Failed to stop alarm: %d\n", ret);
 309                 return ret;
 310         }
 311
 312          dev_dbg(dev,"alrm set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 313                         1900 + alrm->time.tm_year, alrm->time.tm_mon + 1, alrm->time.tm_mday, alrm->time.tm_wday, alrm->time.tm_hour, alrm->time.tm_min, alrm->time.tm_sec);
 314
 315         alrm_data[0] = bin2bcd(alrm->time.tm_sec);
 316         alrm_data[1] = bin2bcd(alrm->time.tm_min);
 317         alrm_data[2] = bin2bcd(alrm->time.tm_hour );
 318         alrm_data[3] = bin2bcd(alrm->time.tm_mday);
 319         alrm_data[4] = bin2bcd(alrm->time.tm_mon + 1);
 320         alrm_data[5] = bin2bcd(alrm->time.tm_year - 100);
 321 #if 0
 322         ret = rk818_bulk_write(rk818_rtc->rk818, RK818_ALARM_SECONDS_REG,
 323                                ALL_ALM_REGS, alrm_data);
 324         if (ret != 0) {
 325                 dev_err(dev, "Failed to read alarm time: %d\n", ret);
 326                 return ret;
 327         }
 328 #else
 329          rk818_reg_write(rk818_rtc->rk818,0x08,alrm_data[0]);
 330         rk818_reg_write(rk818_rtc->rk818,0x09,alrm_data[1]);
 331         rk818_reg_write(rk818_rtc->rk818,0x0a,alrm_data[2]);
 332         rk818_reg_write(rk818_rtc->rk818,0x0b,alrm_data[3]);
 333         rk818_reg_write(rk818_rtc->rk818,0x0c,alrm_data[4]);
 334         rk818_reg_write(rk818_rtc->rk818,0x0d,alrm_data[5]);
 335
 336 #endif
 337         if (alrm->enabled) {
 338                 ret = rk818_rtc_start_alarm(rk818_rtc);
 339                 if (ret < 0) {
 340                         dev_err(dev, "Failed to start alarm: %d\n", ret);
 341                         return ret;
 342                 }
 343         }
 344
 345         return 0;
 346 }
 347
 348 static int rk818_rtc_alarm_irq_enable(struct device *dev,
 349                                        unsigned int enabled)
 350 {
 351         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
 352
 353         if (enabled)
 354                 return rk818_rtc_start_alarm(rk818_rtc);
 355         else
 356                 return rk818_rtc_stop_alarm(rk818_rtc);
 357 }
 358
 359 static int rk818_rtc_update_irq_enable(struct device *dev,
 360                                        unsigned int enabled)
 361 {
 362         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
 363
 364         if (enabled)
 365                 return rk818_set_bits(rk818_rtc->rk818, RK818_RTC_INT_REG,
 366                                BIT_RTC_INTERRUPTS_REG_IT_TIMER_M,BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
 367         else
 368                 return rk818_clear_bits(rk818_rtc->rk818, RK818_RTC_INT_REG,
 369                                BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
 370 }
 371
 372 /*
 373  * We will just handle setting the frequency and make use the framework for
 374  * reading the periodic interupts.
 375  *
 376  * @freq: Current periodic IRQ freq:
 377  * bit 0: every second
 378  * bit 1: every minute
 379  * bit 2: every hour
 380  * bit 3: every day
 381  */
 382 #if 0
 383 static int rk818_rtc_irq_set_freq(struct device *dev, int freq)
 384 {
 385         struct rk818_rtc *rk818_rtc = dev_get_drvdata(dev);
 386         int ret;
 387         u8 rtc_ctl;
 388
 389         if (freq < 0 || freq > 3)
 390                 return -EINVAL;
 391
 392         ret = rk818_reg_read(rk818_rtc->rk818, RK818_RTC_INT_REG);
 393         if (ret < 0) {
 394                 dev_err(dev, "Failed to read RTC interrupt: %d\n", ret);
 395                 return ret;
 396         }
 397
 398         rtc_ctl = ret | freq;
 399
 400         ret = rk818_reg_write(rk818_rtc->rk818, RK818_RTC_INT_REG, rtc_ctl);
 401         if (ret < 0) {
 402                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
 403                 return ret;
 404         }
 405
 406         return ret;
 407 }
 408 #endif
 409
 410 static irqreturn_t rk818_alm_irq(int irq, void *data)
 411 {
 412         struct rk818_rtc *rk818_rtc = data;
 413         int ret;
 414         u8 rtc_ctl;
 415
 416         /*Dummy read -- mandatory for status register*/
 417         ret = rk818_reg_read(rk818_rtc->rk818, RK818_RTC_STATUS_REG);
 418         if (ret < 0) {
 419                 printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 420                 return ret;
 421         }
 422
 423         ret = rk818_reg_read(rk818_rtc->rk818, RK818_RTC_STATUS_REG);
 424         if (ret < 0) {
 425                 printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 426                 return ret;
 427         }
 428         rtc_ctl = ret&0xff;
 429
 430         //The alarm interrupt keeps its low level, until the micro-controller write 1 in the ALARM bit of the RTC_STATUS_REG register.
 431         ret = rk818_reg_write(rk818_rtc->rk818, RK818_RTC_STATUS_REG,rtc_ctl);
 432         if (ret < 0) {
 433                 printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 434                 return ret;
 435         }
 436
 437         rtc_update_irq(rk818_rtc->rtc, 1, RTC_IRQF | RTC_AF);
 438
 439         printk("%s:irq=%d,rtc_ctl=0x%x\n",__func__,irq,rtc_ctl);
 440         return IRQ_HANDLED;
 441 }
 442
 443 static irqreturn_t rk818_per_irq(int irq, void *data)
 444 {
 445         struct rk818_rtc *rk818_rtc = data;
 446
 447         rtc_update_irq(rk818_rtc->rtc, 1, RTC_IRQF | RTC_UF);
 448
 449         //printk("%s:irq=%d\n",__func__,irq);
 450         return IRQ_HANDLED;
 451 }
 452
 453 static const struct rtc_class_ops rk818_rtc_ops = {
 454         .read_time = rk818_rtc_readtime,
 455         //.set_mmss = rk818_rtc_set_mmss,
 456         .set_time = rk818_rtc_set_time,
 457         .read_alarm = rk818_rtc_readalarm,
 458         .set_alarm = rk818_rtc_setalarm,
 459         .alarm_irq_enable = rk818_rtc_alarm_irq_enable,
 460         //.update_irq_enable = rk818_rtc_update_irq_enable,
 461         //.irq_set_freq = rk818_rtc_irq_set_freq,
 462 };
 463
 464 #ifdef CONFIG_PM
 465 /* Turn off the alarm if it should not be a wake source. */
 466 static int rk818_rtc_suspend(struct device *dev)
 467 {
 468         struct platform_device *pdev = to_platform_device(dev);
 469         struct rk818_rtc *rk818_rtc = dev_get_drvdata(&pdev->dev);
 470         int ret;
 471
 472         if (rk818_rtc->alarm_enabled && device_may_wakeup(&pdev->dev))
 473                 ret = rk818_rtc_start_alarm(rk818_rtc);
 474         else
 475                 ret = rk818_rtc_stop_alarm(rk818_rtc);
 476
 477         if (ret < 0)
 478                 dev_err(&pdev->dev, "Failed to update RTC alarm: %d\n", ret);
 479
 480         return 0;
 481 }
 482
 483 /* Enable the alarm if it should be enabled (in case it was disabled to
 484  * prevent use as a wake source).
 485  */
 486 static int rk818_rtc_resume(struct device *dev)
 487 {
 488         struct platform_device *pdev = to_platform_device(dev);
 489         struct rk818_rtc *rk818_rtc = dev_get_drvdata(&pdev->dev);
 490         int ret;
 491
 492         if (rk818_rtc->alarm_enabled) {
 493                 ret = rk818_rtc_start_alarm(rk818_rtc);
 494                 if (ret < 0)
 495                         dev_err(&pdev->dev,
 496                                 "Failed to restart RTC alarm: %d\n", ret);
 497         }
 498
 499         return 0;
 500 }
 501
 502 /* Unconditionally disable the alarm */
 503 static int rk818_rtc_freeze(struct device *dev)
 504 {
 505         struct platform_device *pdev = to_platform_device(dev);
 506         struct rk818_rtc *rk818_rtc = dev_get_drvdata(&pdev->dev);
 507         int ret;
 508
 509         ret = rk818_rtc_stop_alarm(rk818_rtc);
 510         if (ret < 0)
 511                 dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", ret);
 512
 513         return 0;
 514 }
 515 #else
 516 #define rk818_rtc_suspend NULL
 517 #define rk818_rtc_resume NULL
 518 #define rk818_rtc_freeze NULL
 519 #endif
 520 extern struct rk818 *g_rk818;
 521 struct platform_device *rk818_pdev;
 522 struct rtc_time rk818_tm_def = {        //      2012.1.1 12:00:00 Saturday
 523                         .tm_wday = 6,
 524                         .tm_year = 112,
 525                         .tm_mon = 0,
 526                         .tm_mday = 1,
 527                         .tm_hour = 12,
 528                         .tm_min = 0,
 529                         .tm_sec = 0,
 530 };
 531
 532 static int rk818_rtc_probe(struct platform_device *pdev)
 533 {
 534         struct rk818 *rk818 = dev_get_drvdata(pdev->dev.parent);
 535         struct rk818_rtc *rk818_rtc;
 536         struct rtc_time tm;
 537         int per_irq;
 538         int alm_irq;
 539         int ret = 0;
 540         u8 rtc_ctl;
 541
 542         printk("%s,line=%d\n", __func__,__LINE__);
 543
 544         rk818_rtc = devm_kzalloc(&pdev->dev,sizeof(*rk818_rtc), GFP_KERNEL);
 545         if (rk818_rtc == NULL)
 546                 return -ENOMEM;
 547
 548         platform_set_drvdata(pdev, rk818_rtc);
 549         rk818_rtc->rk818 = rk818;
 550
 551         /* Take rtc out of reset */
 552         /*
 553         ret = rk818_reg_read(rk818, RK818_DEVCTRL);
 554         if (ret < 0) {
 555                 dev_err(&pdev->dev, "Failed to read RK818_DEVCTRL: %d\n", ret);
 556                 return ret;
 557         }
 558
 559         if(ret & BIT_RTC_PWDN)
 560         {
 561                 rtc_ctl = ret & (~BIT_RTC_PWDN);
 562
 563                 ret = rk818_reg_write(rk818, RK818_DEVCTRL, rtc_ctl);
 564                 if (ret < 0) {
 565                         dev_err(&pdev->dev, "Failed to write RTC control: %d\n", ret);
 566                         return ret;
 567                 }
 568         }
 569         */
 570         /*start rtc default*/
 571         ret = rk818_reg_read(rk818, RK818_RTC_CTRL_REG);
 572         if (ret < 0) {
 573                 dev_err(&pdev->dev, "Failed to read RTC control: %d\n", ret);
 574                 return ret;
 575         }
 576         rtc_ctl = ret & (~BIT_RTC_CTRL_REG_STOP_RTC_M);
 577
 578         ret = rk818_reg_write(rk818, RK818_RTC_CTRL_REG, rtc_ctl);
 579         if (ret < 0) {
 580                 dev_err(&pdev->dev, "Failed to write RTC control: %d\n", ret);
 581                         return ret;
 582                 }
 583
 584         ret = rk818_reg_read(rk818, RK818_RTC_STATUS_REG);
 585         if (ret < 0) {
 586                 dev_err(&pdev->dev, "Failed to read RTC status: %d\n", ret);
 587                 return ret;
 588         }
 589         rk818_reg_write(rk818,RK818_RTC_STATUS_REG,0xfe);
 590         /*set init time*/
 591
 592         ret = rk818_rtc_readtime(&pdev->dev, &tm);
 593         if (ret<0)
 594         {
 595                 dev_err(&pdev->dev, "Failed to read RTC time\n");
 596                 return ret;
 597         }
 598
 599         ret = rtc_valid_tm(&tm);
 600         if (ret) {
 601         dev_err(&pdev->dev,"invalid date/time and init time\n");
 602                 rk818_rtc_set_time(&pdev->dev, &rk818_tm_def); // 2012-01-01 12:00:00
 603 //              DBG( "set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",1900 + tm_def.tm_year, tm_def.tm_mon + 1, tm_def.tm_mday, tm_def.tm_wday,tm_def.tm_hour, tm_def.tm_min, tm_def.tm_sec);
 604         }
 605
 606         device_init_wakeup(&pdev->dev, 1);
 607
 608         rk818_rtc->rtc = rtc_device_register("rk818", &pdev->dev,
 609                                               &rk818_rtc_ops, THIS_MODULE);
 610         if (IS_ERR(rk818_rtc->rtc)) {
 611                 ret = PTR_ERR(rk818_rtc->rtc);
 612                 goto err;
 613         }
 614
 615         per_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_RTC_PERIOD);
 616         alm_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_RTC_ALARM);
 617
 618         /*request rtc and alarm irq of rk818*/
 619         ret = devm_request_threaded_irq(rk818->dev,per_irq, NULL, rk818_per_irq,
 620                                    IRQF_TRIGGER_RISING, "RTC period",
 621                                    rk818_rtc);
 622         if (ret != 0) {
 623                 dev_err(&pdev->dev, "Failed to request periodic IRQ %d: %d\n",
 624                         per_irq, ret);
 625         }
 626
 627         ret = devm_request_threaded_irq(rk818->dev,alm_irq, NULL, rk818_alm_irq,
 628                                    IRQF_TRIGGER_RISING, "RTC alarm",
 629                                    rk818_rtc);
 630         if (ret != 0) {
 631                 dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
 632                         alm_irq, ret);
 633         }
 634
 635         //for rtc irq test
 636         /*
 637         rk818_set_bits(rk818_rtc->rk818, RK818_RTC_STATUS_REG,(0x1<< 6),(0x1 <<6));
 638         rk818_set_bits(rk818_rtc->rk818, RK818_RTC_INT_REG,0x0c,0x0c);
 639         rk818_set_bits(rk818_rtc->rk818,RK818_INT_STS_REG1,(0x3 << 5),(0x3 <<5));
 640         rk818_set_bits(rk818_rtc->rk818, RK818_INT_STS_MSK_REG1,(0x3 <<5),0);
 641 */
 642
 643 //      enable_irq_wake(alm_irq); // so rk818 alarm irq can wake up system
 644         rk818_pdev = pdev;
 645
 646         printk("%s:ok\n",__func__);
 647
 648         return 0;
 649
 650 err:
 651         return ret;
 652 }
 653
 654 static int  rk818_rtc_remove(struct platform_device *pdev)
 655 {
 656         struct rk818_rtc *rk818_rtc = platform_get_drvdata(pdev);
 657         int per_irq = rk818_rtc->rk818->irq_base + RK818_IRQ_RTC_PERIOD;
 658         int alm_irq = rk818_rtc->rk818->irq_base + RK818_IRQ_RTC_ALARM;
 659
 660         free_irq(alm_irq, rk818_rtc);
 661         free_irq(per_irq, rk818_rtc);
 662         rtc_device_unregister(rk818_rtc->rtc);
 663
 664         return 0;
 665 }
 666
 667 static const struct dev_pm_ops rk818_rtc_pm_ops = {
 668         .suspend = rk818_rtc_suspend,
 669         .resume = rk818_rtc_resume,
 670
 671         .freeze = rk818_rtc_freeze,
 672         .thaw = rk818_rtc_resume,
 673         .restore = rk818_rtc_resume,
 674
 675         .poweroff = rk818_rtc_suspend,
 676 };
 677
 678 static struct platform_driver rk818_rtc_driver = {
 679         .probe = rk818_rtc_probe,
 680         .remove = rk818_rtc_remove,
 681         .driver = {
 682                 .name = "rk818-rtc",
 683                 .pm = &rk818_rtc_pm_ops,
 684         },
 685 };
 686
 687 static ssize_t rtc_rk818_test_write(struct file *file,
 688                         const char __user *buf, size_t count, loff_t *offset)
 689 {
 690         char nr_buf[8];
 691         int nr = 0, ret;
 692         struct platform_device *pdev;
 693         struct rtc_time tm;
 694         struct rtc_wkalrm alrm;
 695         struct rk818_rtc *rk818_rtc;
 696
 697         if(count > 3)
 698                 return -EFAULT;
 699         ret = copy_from_user(nr_buf, buf, count);
 700         if(ret < 0)
 701                 return -EFAULT;
 702
 703         sscanf(nr_buf, "%d", &nr);
 704         if(nr > 5 || nr < 0)
 705         {
 706                 printk("%s:data is error\n",__func__);
 707                 return -EFAULT;
 708         }
 709
 710         if(!rk818_pdev)
 711                 return -EFAULT;
 712         else
 713                 pdev = rk818_pdev;
 714
 715
 716         rk818_rtc = dev_get_drvdata(&pdev->dev);
 717
 718         //test rtc time
 719         if(nr == 0)
 720         {
 721                 tm.tm_wday = 6;
 722                 tm.tm_year = 111;
 723                 tm.tm_mon = 0;
 724                 tm.tm_mday = 1;
 725                 tm.tm_hour = 12;
 726                 tm.tm_min = 0;
 727                 tm.tm_sec = 0;
 728
 729                 ret = rk818_rtc_set_time(&pdev->dev, &tm); // 2011-01-01 12:00:00
 730                 if (ret)
 731                 {
 732                         dev_err(&pdev->dev, "Failed to set RTC time\n");
 733                         return -EFAULT;
 734                 }
 735
 736         }
 737
 738         /*set init time*/
 739         ret = rk818_rtc_readtime(&pdev->dev, &tm);
 740         if (ret)
 741                 dev_err(&pdev->dev, "Failed to read RTC time\n");
 742         else
 743                 dev_info(&pdev->dev, "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 744                         1900 + tm.tm_year, tm.tm_mon + 1, tm.tm_mday, tm.tm_wday,
 745                         tm.tm_hour, tm.tm_min, tm.tm_sec);
 746
 747         if(!ret)
 748         printk("%s:ok\n",__func__);
 749         else
 750         printk("%s:error\n",__func__);
 751
 752
 753         //test rtc alarm
 754         if(nr == 2)
 755         {
 756                 //2000-01-01 00:00:30
 757                 if(tm.tm_sec < 30)
 758                 {
 759                         alrm.time.tm_sec = tm.tm_sec+30;
 760                         alrm.time.tm_min = tm.tm_min;
 761                 }
 762                 else
 763                 {
 764                         alrm.time.tm_sec = tm.tm_sec-30;
 765                         alrm.time.tm_min = tm.tm_min+1;
 766                 }
 767                 alrm.time.tm_hour = tm.tm_hour;
 768                 alrm.time.tm_mday = tm.tm_mday;
 769                 alrm.time.tm_mon = tm.tm_mon;
 770                 alrm.time.tm_year = tm.tm_year;
 771                 rk818_rtc_alarm_irq_enable(&pdev->dev, 1);
 772                 rk818_rtc_setalarm(&pdev->dev, &alrm);
 773
 774                 dev_info(&pdev->dev, "Set alarm %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 775                                 1900 + alrm.time.tm_year, alrm.time.tm_mon + 1, alrm.time.tm_mday, alrm.time.tm_wday,
 776                                 alrm.time.tm_hour, alrm.time.tm_min, alrm.time.tm_sec);
 777         }
 778
 779
 780         if(nr == 3)
 781         {
 782                 ret = rk818_reg_read(rk818_rtc->rk818, RK818_RTC_STATUS_REG);
 783                 if (ret < 0) {
 784                         printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 785                         return ret;
 786                 }
 787                 printk("%s:ret=0x%x\n",__func__,ret&0xff);
 788
 789                 ret = rk818_reg_write(rk818_rtc->rk818, RK818_RTC_STATUS_REG, ret&0xff);
 790                 if (ret < 0) {
 791                         printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 792                         return ret;
 793                 }
 794         }
 795
 796         if(nr == 4)
 797         rk818_rtc_update_irq_enable(&pdev->dev, 1);
 798
 799         if(nr == 5)
 800         rk818_rtc_update_irq_enable(&pdev->dev, 0);
 801
 802         return count;
 803 }
 804
 805 static const struct file_operations rtc_rk818_test_fops = {
 806         .write = rtc_rk818_test_write,
 807 };
 808
 809 static struct miscdevice rtc_rk818_test_misc = {
 810         .minor = MISC_DYNAMIC_MINOR,
 811         .name = "rtc_rk818_test",
 812         .fops = &rtc_rk818_test_fops,
 813 };
 814
 815
 816 static int __init rk818_rtc_init(void)
 817 {
 818         misc_register(&rtc_rk818_test_misc);
 819         return platform_driver_register(&rk818_rtc_driver);
 820 }
 821 subsys_initcall_sync(rk818_rtc_init);
 822
 823 static void __exit rk818_rtc_exit(void)
 824 {
 825         misc_deregister(&rtc_rk818_test_misc);
 826         platform_driver_unregister(&rk818_rtc_driver);
 827 }
 828 module_exit(rk818_rtc_exit);
 829
 830 MODULE_DESCRIPTION("RTC driver for the rk818 series PMICs");
 831 MODULE_AUTHOR("ZHANGQING <zhanqging@rock-chips.com>");
 832 MODULE_LICENSE("GPL");
 833 MODULE_ALIAS("platform:rk818-rtc");