drivers/rtc/rtc-rk-rk808.c

   1 /*
   2  *      Real Time Clock driver for  rk808
   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/rk808.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 rk808_rtc {
  67         struct rk808 *rk808;
  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 rk808_rtc_readtime(struct device *dev, struct rtc_time *tm)
  76 {
  77         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
  78         struct rk808 *rk808 = rk808_rtc->rk808;
  79         int ret;
  80         unsigned char rtc_data[ALL_TIME_REGS + 1];
  81         u8 rtc_ctl;
  82
  83         /*Dummy read*/
  84         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
  85
  86         /* Has the RTC been programmed? */
  87         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
  88         if (ret < 0) {
  89                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
  90                 return ret;
  91         }
  92
  93         rtc_ctl = ret & (~BIT_RTC_CTRL_REG_RTC_V_OPT_M);
  94
  95         ret = rk808_reg_write(rk808, RK808_RTC_CTRL_REG, rtc_ctl);
  96         if (ret < 0) {
  97                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
  98                 return ret;
  99         }
 100
 101 #if 0
 102         /* Read twice to make sure we don't read a corrupt, partially
 103          * incremented, value.
 104          */
 105         do {
 106                 ret = rk808_bulk_read(rk808, RK808_SECONDS_REG,
 107                                        ALL_TIME_REGS, rtc_data);
 108                 if (ret != 0)
 109                         continue;
 110
 111                 tm->tm_sec = bcd2bin(rtc_data[0]);
 112                 tm->tm_min = bcd2bin(rtc_data[1]);
 113                 tm->tm_hour = bcd2bin(rtc_data[2]) ;
 114                 tm->tm_mday = bcd2bin(rtc_data[3]);
 115                 tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
 116                 tm->tm_year = bcd2bin(rtc_data[5]) + 100;
 117                 tm->tm_wday = bcd2bin(rtc_data[6]);
 118
 119                 printk( "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 120                         1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,
 121                         tm->tm_hour, tm->tm_min, tm->tm_sec);
 122
 123                 return ret;
 124
 125         } while (++count < RTC_GET_TIME_RETRIES);
 126         dev_err(dev, "Timed out reading current time\n");
 127 #else
 128         rtc_data[0] = rk808_reg_read(rk808,0x00);
 129         rtc_data[1] = rk808_reg_read(rk808,0x01);
 130         rtc_data[2] = rk808_reg_read(rk808,0x02);
 131         rtc_data[3] = rk808_reg_read(rk808,0x03);
 132         rtc_data[4] = rk808_reg_read(rk808,0x04);
 133         rtc_data[5] = rk808_reg_read(rk808,0x05);
 134         rtc_data[6] = rk808_reg_read(rk808,0x06);
 135
 136          tm->tm_sec = bcd2bin(rtc_data[0]);
 137          tm->tm_min = bcd2bin(rtc_data[1]);
 138          tm->tm_hour = bcd2bin(rtc_data[2]) ;
 139          tm->tm_mday = bcd2bin(rtc_data[3]);
 140          tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
 141          tm->tm_year = bcd2bin(rtc_data[5]) + 100;
 142          tm->tm_wday = bcd2bin(rtc_data[6]);
 143
 144           dev_dbg(dev, "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 145                         1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,tm->tm_hour , tm->tm_min, tm->tm_sec);
 146
 147 #endif
 148         return 0;
 149
 150 }
 151
 152 /*
 153  * Set current time and date in RTC
 154  */
 155 static int rk808_rtc_set_time(struct device *dev, struct rtc_time *tm)
 156 {
 157         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
 158         struct rk808 *rk808 = rk808_rtc->rk808;
 159         int ret;
 160         u8 rtc_ctl;
 161         unsigned char rtc_data[ALL_TIME_REGS + 1];
 162
 163         rtc_data[0] = bin2bcd(tm->tm_sec);
 164         rtc_data[1] = bin2bcd(tm->tm_min);
 165         rtc_data[2] = bin2bcd(tm->tm_hour );
 166         rtc_data[3] = bin2bcd(tm->tm_mday);
 167         rtc_data[4] = bin2bcd(tm->tm_mon + 1);
 168         rtc_data[5] = bin2bcd(tm->tm_year - 100);
 169         rtc_data[6] = bin2bcd(tm->tm_wday);
 170
 171          dev_dbg(dev, "set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 172                         1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,tm->tm_hour , tm->tm_min, tm->tm_sec);
 173
 174         /*Dummy read*/
 175         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
 176
 177         /* Stop RTC while updating the TC registers */
 178         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
 179         if (ret < 0) {
 180                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
 181                 return ret;
 182         }
 183
 184         rtc_ctl = ret | (BIT_RTC_CTRL_REG_STOP_RTC_M);
 185
 186         ret = rk808_reg_write(rk808, RK808_RTC_CTRL_REG, rtc_ctl);
 187         if (ret < 0) {
 188                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
 189                 return ret;
 190         }
 191 #if 0
 192         /* update all the time registers in one shot */
 193         ret = rk808_bulk_write(rk808, RK808_SECONDS_REG,
 194                                        ALL_TIME_REGS, rtc_data);
 195         if (ret < 0) {
 196                 dev_err(dev, "Failed to read RTC times: %d\n", ret);
 197                 return ret;
 198         }
 199 #else
 200         rk808_reg_write(rk808,0x00,rtc_data[0]);
 201         rk808_reg_write(rk808,0x01,rtc_data[1]);
 202         rk808_reg_write(rk808,0x02,rtc_data[2]);
 203         rk808_reg_write(rk808,0x03,rtc_data[3]);
 204         rk808_reg_write(rk808,0x04,rtc_data[4]);
 205         rk808_reg_write(rk808,0x05,rtc_data[5]);
 206         rk808_reg_write(rk808,0x06,rtc_data[6]);
 207
 208 #endif
 209         /*Dummy read*/
 210         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
 211
 212         /* Start RTC again */
 213         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
 214         if (ret < 0) {
 215                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
 216                 return ret;
 217         }
 218
 219         rtc_ctl = ret &(~ BIT_RTC_CTRL_REG_STOP_RTC_M);
 220
 221         ret = rk808_reg_write(rk808, RK808_RTC_CTRL_REG, rtc_ctl);
 222         if (ret < 0) {
 223                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
 224                 return ret;
 225         }
 226
 227         return 0;
 228 }
 229
 230 /*
 231  * Read alarm time and date in RTC
 232  */
 233 static int rk808_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
 234 {
 235         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
 236         int ret;
 237         unsigned char alrm_data[ALL_ALM_REGS + 1];
 238 #if 0
 239         ret = rk808_bulk_read(rk808_rtc->rk808, RK808_ALARM_SECONDS_REG,
 240                                ALL_ALM_REGS, alrm_data);
 241         if (ret != 0) {
 242                 dev_err(dev, "Failed to read alarm time: %d\n", ret);
 243                 return ret;
 244         }
 245 #else
 246         alrm_data[0] = rk808_reg_read(rk808_rtc->rk808,0x08);
 247         alrm_data[1] = rk808_reg_read(rk808_rtc->rk808,0x09);
 248         alrm_data[2] = rk808_reg_read(rk808_rtc->rk808,0x0a);
 249         alrm_data[3] = rk808_reg_read(rk808_rtc->rk808,0x0b);
 250         alrm_data[4] = rk808_reg_read(rk808_rtc->rk808,0x0c);
 251         alrm_data[5] = rk808_reg_read(rk808_rtc->rk808,0x0d);
 252
 253
 254 #endif
 255         /* some of these fields may be wildcard/"match all" */
 256         alrm->time.tm_sec = bcd2bin(alrm_data[0]);
 257         alrm->time.tm_min = bcd2bin(alrm_data[1]);
 258         alrm->time.tm_hour = bcd2bin(alrm_data[2]);
 259         alrm->time.tm_mday = bcd2bin(alrm_data[3]);
 260         alrm->time.tm_mon = bcd2bin(alrm_data[4]) - 1;
 261         alrm->time.tm_year = bcd2bin(alrm_data[5]) + 100;
 262
 263         ret = rk808_reg_read(rk808_rtc->rk808, RK808_RTC_INT_REG);
 264         if (ret < 0) {
 265                 dev_err(dev, "Failed to read RTC control: %d\n", ret);
 266                 return ret;
 267         }
 268         dev_dbg(dev,"alrm read RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 269                         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);
 270
 271
 272
 273         if (ret & BIT_RTC_INTERRUPTS_REG_IT_ALARM_M)
 274                 alrm->enabled = 1;
 275         else
 276                 alrm->enabled = 0;
 277
 278         return 0;
 279 }
 280
 281 static int rk808_rtc_stop_alarm(struct rk808_rtc *rk808_rtc)
 282 {
 283         rk808_rtc->alarm_enabled = 0;
 284
 285         return rk808_clear_bits(rk808_rtc->rk808, RK808_RTC_INT_REG,
 286                                BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
 287
 288 }
 289
 290 static int rk808_rtc_start_alarm(struct rk808_rtc *rk808_rtc)
 291 {
 292         rk808_rtc->alarm_enabled = 1;
 293
 294         return rk808_set_bits(rk808_rtc->rk808, RK808_RTC_INT_REG,
 295                                BIT_RTC_INTERRUPTS_REG_IT_ALARM_M,BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
 296
 297 }
 298
 299 static int rk808_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 300 {
 301         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
 302         int ret;
 303         unsigned char alrm_data[ALL_TIME_REGS + 1];
 304
 305         ret = rk808_rtc_stop_alarm(rk808_rtc);
 306         if (ret < 0) {
 307                 dev_err(dev, "Failed to stop alarm: %d\n", ret);
 308                 return ret;
 309         }
 310
 311          dev_dbg(dev,"alrm set RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 312                         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);
 313
 314         alrm_data[0] = bin2bcd(alrm->time.tm_sec);
 315         alrm_data[1] = bin2bcd(alrm->time.tm_min);
 316         alrm_data[2] = bin2bcd(alrm->time.tm_hour );
 317         alrm_data[3] = bin2bcd(alrm->time.tm_mday);
 318         alrm_data[4] = bin2bcd(alrm->time.tm_mon + 1);
 319         alrm_data[5] = bin2bcd(alrm->time.tm_year - 100);
 320 #if 0
 321         ret = rk808_bulk_write(rk808_rtc->rk808, RK808_ALARM_SECONDS_REG,
 322                                ALL_ALM_REGS, alrm_data);
 323         if (ret != 0) {
 324                 dev_err(dev, "Failed to read alarm time: %d\n", ret);
 325                 return ret;
 326         }
 327 #else
 328          rk808_reg_write(rk808_rtc->rk808,0x08,alrm_data[0]);
 329         rk808_reg_write(rk808_rtc->rk808,0x09,alrm_data[1]);
 330         rk808_reg_write(rk808_rtc->rk808,0x0a,alrm_data[2]);
 331         rk808_reg_write(rk808_rtc->rk808,0x0b,alrm_data[3]);
 332         rk808_reg_write(rk808_rtc->rk808,0x0c,alrm_data[4]);
 333         rk808_reg_write(rk808_rtc->rk808,0x0d,alrm_data[5]);
 334
 335 #endif
 336         if (alrm->enabled) {
 337                 ret = rk808_rtc_start_alarm(rk808_rtc);
 338                 if (ret < 0) {
 339                         dev_err(dev, "Failed to start alarm: %d\n", ret);
 340                         return ret;
 341                 }
 342         }
 343
 344         return 0;
 345 }
 346
 347 static int rk808_rtc_alarm_irq_enable(struct device *dev,
 348                                        unsigned int enabled)
 349 {
 350         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
 351
 352         if (enabled)
 353                 return rk808_rtc_start_alarm(rk808_rtc);
 354         else
 355                 return rk808_rtc_stop_alarm(rk808_rtc);
 356 }
 357
 358 static int rk808_rtc_update_irq_enable(struct device *dev,
 359                                        unsigned int enabled)
 360 {
 361         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
 362
 363         if (enabled)
 364                 return rk808_set_bits(rk808_rtc->rk808, RK808_RTC_INT_REG,
 365                                BIT_RTC_INTERRUPTS_REG_IT_TIMER_M,BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
 366         else
 367                 return rk808_clear_bits(rk808_rtc->rk808, RK808_RTC_INT_REG,
 368                                BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
 369 }
 370
 371 /*
 372  * We will just handle setting the frequency and make use the framework for
 373  * reading the periodic interupts.
 374  *
 375  * @freq: Current periodic IRQ freq:
 376  * bit 0: every second
 377  * bit 1: every minute
 378  * bit 2: every hour
 379  * bit 3: every day
 380  */
 381 #if 0
 382 static int rk808_rtc_irq_set_freq(struct device *dev, int freq)
 383 {
 384         struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev);
 385         int ret;
 386         u8 rtc_ctl;
 387
 388         if (freq < 0 || freq > 3)
 389                 return -EINVAL;
 390
 391         ret = rk808_reg_read(rk808_rtc->rk808, RK808_RTC_INT_REG);
 392         if (ret < 0) {
 393                 dev_err(dev, "Failed to read RTC interrupt: %d\n", ret);
 394                 return ret;
 395         }
 396
 397         rtc_ctl = ret | freq;
 398
 399         ret = rk808_reg_write(rk808_rtc->rk808, RK808_RTC_INT_REG, rtc_ctl);
 400         if (ret < 0) {
 401                 dev_err(dev, "Failed to write RTC control: %d\n", ret);
 402                 return ret;
 403         }
 404
 405         return ret;
 406 }
 407 #endif
 408 static irqreturn_t rk808_alm_irq(int irq, void *data)
 409 {
 410         struct rk808_rtc *rk808_rtc = data;
 411         int ret;
 412         u8 rtc_ctl;
 413
 414         /*Dummy read -- mandatory for status register*/
 415         ret = rk808_reg_read(rk808_rtc->rk808, RK808_RTC_STATUS_REG);
 416         if (ret < 0) {
 417                 printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 418                 return ret;
 419         }
 420
 421         ret = rk808_reg_read(rk808_rtc->rk808, RK808_RTC_STATUS_REG);
 422         if (ret < 0) {
 423                 printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 424                 return ret;
 425         }
 426         rtc_ctl = ret&0xff;
 427
 428         //The alarm interrupt keeps its low level, until the micro-controller write 1 in the ALARM bit of the RTC_STATUS_REG register.
 429         ret = rk808_reg_write(rk808_rtc->rk808, RK808_RTC_STATUS_REG,rtc_ctl);
 430         if (ret < 0) {
 431                 printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 432                 return ret;
 433         }
 434
 435         rtc_update_irq(rk808_rtc->rtc, 1, RTC_IRQF | RTC_AF);
 436
 437         printk("%s:irq=%d,rtc_ctl=0x%x\n",__func__,irq,rtc_ctl);
 438         return IRQ_HANDLED;
 439 }
 440
 441 static irqreturn_t rk808_per_irq(int irq, void *data)
 442 {
 443         struct rk808_rtc *rk808_rtc = data;
 444
 445         rtc_update_irq(rk808_rtc->rtc, 1, RTC_IRQF | RTC_UF);
 446
 447         //printk("%s:irq=%d\n",__func__,irq);
 448         return IRQ_HANDLED;
 449 }
 450
 451 static const struct rtc_class_ops rk808_rtc_ops = {
 452         .read_time = rk808_rtc_readtime,
 453         //.set_mmss = rk808_rtc_set_mmss,
 454         .set_time = rk808_rtc_set_time,
 455         .read_alarm = rk808_rtc_readalarm,
 456         .set_alarm = rk808_rtc_setalarm,
 457         .alarm_irq_enable = rk808_rtc_alarm_irq_enable,
 458         //.update_irq_enable = rk808_rtc_update_irq_enable,
 459         //.irq_set_freq = rk808_rtc_irq_set_freq,
 460 };
 461
 462 #ifdef CONFIG_PM
 463 /* Turn off the alarm if it should not be a wake source. */
 464 static int rk808_rtc_suspend(struct device *dev)
 465 {
 466         struct platform_device *pdev = to_platform_device(dev);
 467         struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev);
 468         int ret;
 469
 470         if (rk808_rtc->alarm_enabled && device_may_wakeup(&pdev->dev))
 471                 ret = rk808_rtc_start_alarm(rk808_rtc);
 472         else
 473                 ret = rk808_rtc_stop_alarm(rk808_rtc);
 474
 475         if (ret < 0)
 476                 dev_err(&pdev->dev, "Failed to update RTC alarm: %d\n", ret);
 477
 478         return 0;
 479 }
 480
 481 /* Enable the alarm if it should be enabled (in case it was disabled to
 482  * prevent use as a wake source).
 483  */
 484 static int rk808_rtc_resume(struct device *dev)
 485 {
 486         struct platform_device *pdev = to_platform_device(dev);
 487         struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev);
 488         int ret;
 489
 490         if (rk808_rtc->alarm_enabled) {
 491                 ret = rk808_rtc_start_alarm(rk808_rtc);
 492                 if (ret <0)
 493                         dev_err(&pdev->dev,
 494                                 "Failed to restart RTC alarm: %d\n", ret);
 495         }
 496
 497         return 0;
 498 }
 499
 500 /* Unconditionally disable the alarm */
 501 static int rk808_rtc_freeze(struct device *dev)
 502 {
 503         struct platform_device *pdev = to_platform_device(dev);
 504         struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev);
 505         int ret;
 506
 507         ret = rk808_rtc_stop_alarm(rk808_rtc);
 508         if (ret < 0)
 509                 dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", ret);
 510
 511         return 0;
 512 }
 513 #else
 514 #define rk808_rtc_suspend NULL
 515 #define rk808_rtc_resume NULL
 516 #define rk808_rtc_freeze NULL
 517 #endif
 518 extern struct rk808 *g_rk808;
 519 struct platform_device *rk808_pdev;
 520 struct rtc_time tm_def = {      //      2012.1.1 12:00:00 Saturday
 521                         .tm_wday = 6,
 522                         .tm_year = 112,
 523                         .tm_mon = 0,
 524                         .tm_mday = 1,
 525                         .tm_hour = 12,
 526                         .tm_min = 0,
 527                         .tm_sec = 0,
 528 };
 529
 530 static int rk808_rtc_probe(struct platform_device *pdev)
 531 {
 532         struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
 533         struct rk808_rtc *rk808_rtc;
 534         struct rtc_time tm;
 535         int per_irq;
 536         int alm_irq;
 537         int ret = 0;
 538         u8 rtc_ctl;
 539
 540         printk("%s,line=%d\n", __func__,__LINE__);
 541
 542         rk808_rtc = kzalloc(sizeof(*rk808_rtc), GFP_KERNEL);
 543         if (rk808_rtc == NULL)
 544                 return -ENOMEM;
 545
 546         platform_set_drvdata(pdev, rk808_rtc);
 547         rk808_rtc->rk808 = rk808;
 548
 549         /* Take rtc out of reset */
 550         /*
 551         ret = rk808_reg_read(rk808, RK808_DEVCTRL);
 552         if (ret < 0) {
 553                 dev_err(&pdev->dev, "Failed to read RK808_DEVCTRL: %d\n", ret);
 554                 return ret;
 555         }
 556
 557         if(ret & BIT_RTC_PWDN)
 558         {
 559                 rtc_ctl = ret & (~BIT_RTC_PWDN);
 560
 561                 ret = rk808_reg_write(rk808, RK808_DEVCTRL, rtc_ctl);
 562                 if (ret < 0) {
 563                         dev_err(&pdev->dev, "Failed to write RTC control: %d\n", ret);
 564                         return ret;
 565                 }
 566         }
 567         */
 568         /*start rtc default*/
 569         ret = rk808_reg_read(rk808, RK808_RTC_CTRL_REG);
 570         if (ret < 0) {
 571                 dev_err(&pdev->dev, "Failed to read RTC control: %d\n", ret);
 572                 return ret;
 573         }
 574         rtc_ctl = ret & (~BIT_RTC_CTRL_REG_STOP_RTC_M);
 575
 576         ret = rk808_reg_write(rk808, RK808_RTC_CTRL_REG, rtc_ctl);
 577         if (ret < 0) {
 578                 dev_err(&pdev->dev, "Failed to write RTC control: %d\n", ret);
 579                         return ret;
 580                 }
 581
 582         ret = rk808_reg_read(rk808, RK808_RTC_STATUS_REG);
 583         if (ret < 0) {
 584                 dev_err(&pdev->dev, "Failed to read RTC status: %d\n", ret);
 585                 return ret;
 586         }
 587         rk808_reg_write(rk808,RK808_RTC_STATUS_REG,0xfe);
 588         /*set init time*/
 589
 590         ret = rk808_rtc_readtime(&pdev->dev, &tm);
 591         if (ret<0)
 592         {
 593                 dev_err(&pdev->dev, "Failed to read RTC time\n");
 594                 return ret;
 595         }
 596
 597         ret = rtc_valid_tm(&tm);
 598         if (ret) {
 599         dev_err(&pdev->dev,"invalid date/time and init time\n");
 600                 rk808_rtc_set_time(&pdev->dev, &tm_def); // 2012-01-01 12:00:00
 601 //              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);
 602         }
 603
 604         device_init_wakeup(&pdev->dev, 1);
 605
 606         rk808_rtc->rtc = rtc_device_register("rk808", &pdev->dev,
 607                                               &rk808_rtc_ops, THIS_MODULE);
 608         if (IS_ERR(rk808_rtc->rtc)) {
 609                 ret = PTR_ERR(rk808_rtc->rtc);
 610                 goto err;
 611         }
 612
 613         per_irq = irq_create_mapping(rk808->irq_domain, RK808_IRQ_RTC_PERIOD);
 614         alm_irq = irq_create_mapping(rk808->irq_domain, RK808_IRQ_RTC_ALARM);
 615
 616         /*request rtc and alarm irq of rk808*/
 617         ret = devm_request_threaded_irq(rk808->dev,per_irq, NULL, rk808_per_irq,
 618                                    IRQF_TRIGGER_RISING, "RTC period",
 619                                    rk808_rtc);
 620         if (ret != 0) {
 621                 dev_err(&pdev->dev, "Failed to request periodic IRQ %d: %d\n",
 622                         per_irq, ret);
 623         }
 624
 625         ret = devm_request_threaded_irq(rk808->dev,alm_irq, NULL, rk808_alm_irq,
 626                                    IRQF_TRIGGER_RISING, "RTC alarm",
 627                                    rk808_rtc);
 628         if (ret != 0) {
 629                 dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
 630                         alm_irq, ret);
 631         }
 632
 633         //for rtc irq test
 634         /*
 635         rk808_set_bits(rk808_rtc->rk808, RK808_RTC_STATUS_REG,(0x1<< 6),(0x1 <<6));
 636         rk808_set_bits(rk808_rtc->rk808, RK808_RTC_INT_REG,0x0c,0x0c);
 637         rk808_set_bits(rk808_rtc->rk808,RK808_INT_STS_REG1,(0x3 << 5),(0x3 <<5));
 638         rk808_set_bits(rk808_rtc->rk808, RK808_INT_STS_MSK_REG1,(0x3 <<5),0);
 639 */
 640
 641 //      enable_irq_wake(alm_irq); // so rk808 alarm irq can wake up system
 642         rk808_pdev = pdev;
 643
 644         printk("%s:ok\n",__func__);
 645
 646         return 0;
 647
 648 err:
 649         kfree(rk808_rtc);
 650         return ret;
 651 }
 652
 653 static int rk808_rtc_remove(struct platform_device *pdev)
 654 {
 655         struct rk808_rtc *rk808_rtc = platform_get_drvdata(pdev);
 656         int per_irq = rk808_rtc->rk808->irq_base + RK808_IRQ_RTC_PERIOD;
 657         int alm_irq = rk808_rtc->rk808->irq_base + RK808_IRQ_RTC_ALARM;
 658
 659         free_irq(alm_irq, rk808_rtc);
 660         free_irq(per_irq, rk808_rtc);
 661         rtc_device_unregister(rk808_rtc->rtc);
 662         kfree(rk808_rtc);
 663
 664         return 0;
 665 }
 666
 667 static const struct dev_pm_ops rk808_rtc_pm_ops = {
 668         .suspend = rk808_rtc_suspend,
 669         .resume = rk808_rtc_resume,
 670
 671         .freeze = rk808_rtc_freeze,
 672         .thaw = rk808_rtc_resume,
 673         .restore = rk808_rtc_resume,
 674
 675         .poweroff = rk808_rtc_suspend,
 676 };
 677
 678 static struct platform_driver rk808_rtc_driver = {
 679         .probe = rk808_rtc_probe,
 680         .remove = rk808_rtc_remove,
 681         .driver = {
 682                 .name = "rk808-rtc",
 683                 .pm = &rk808_rtc_pm_ops,
 684         },
 685 };
 686
 687 static ssize_t rtc_rk808_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 rk808_rtc *rk808_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(!rk808_pdev)
 711                 return -EFAULT;
 712         else
 713                 pdev = rk808_pdev;
 714
 715
 716         rk808_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 = rk808_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 = rk808_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                 rk808_rtc_alarm_irq_enable(&pdev->dev, 1);
 772                 rk808_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 = rk808_reg_read(rk808_rtc->rk808, RK808_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 = rk808_reg_write(rk808_rtc->rk808, RK808_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         rk808_rtc_update_irq_enable(&pdev->dev, 1);
 798
 799         if(nr == 5)
 800         rk808_rtc_update_irq_enable(&pdev->dev, 0);
 801
 802         return count;
 803 }
 804
 805 static const struct file_operations rtc_rk808_test_fops = {
 806         .write = rtc_rk808_test_write,
 807 };
 808
 809 static struct miscdevice rtc_rk808_test_misc = {
 810         .minor = MISC_DYNAMIC_MINOR,
 811         .name = "rtc_rk808_test",
 812         .fops = &rtc_rk808_test_fops,
 813 };
 814
 815
 816 static int __init rk808_rtc_init(void)
 817 {
 818         misc_register(&rtc_rk808_test_misc);
 819         return platform_driver_register(&rk808_rtc_driver);
 820 }
 821 subsys_initcall_sync(rk808_rtc_init);
 822
 823 static void __exit rk808_rtc_exit(void)
 824 {
 825         misc_deregister(&rtc_rk808_test_misc);
 826         platform_driver_unregister(&rk808_rtc_driver);
 827 }
 828 module_exit(rk808_rtc_exit);
 829
 830 MODULE_DESCRIPTION("RTC driver for the rk808 series PMICs");
 831 MODULE_AUTHOR("ZHANGQING <zhanqging@rock-chips.com>");
 832 MODULE_LICENSE("GPL");
 833 MODULE_ALIAS("platform:rk808-rtc");