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 static int rk818_rtc_irq_set_freq(struct device *dev, int freq)
 383 {
 384         struct rk818_rtc *rk818_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 = rk818_reg_read(rk818_rtc->rk818, RK818_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 = rk818_reg_write(rk818_rtc->rk818, RK818_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
 408 static irqreturn_t rk818_alm_irq(int irq, void *data)
 409 {
 410         struct rk818_rtc *rk818_rtc = data;
 411         int ret;
 412         u8 rtc_ctl;
 413
 414         /*Dummy read -- mandatory for status register*/
 415         ret = rk818_reg_read(rk818_rtc->rk818, RK818_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 = rk818_reg_read(rk818_rtc->rk818, RK818_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 = rk818_reg_write(rk818_rtc->rk818, RK818_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(rk818_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 rk818_per_irq(int irq, void *data)
 442 {
 443         struct rk818_rtc *rk818_rtc = data;
 444
 445         rtc_update_irq(rk818_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 rk818_rtc_ops = {
 452         .read_time = rk818_rtc_readtime,
 453         //.set_mmss = rk818_rtc_set_mmss,
 454         .set_time = rk818_rtc_set_time,
 455         .read_alarm = rk818_rtc_readalarm,
 456         .set_alarm = rk818_rtc_setalarm,
 457         .alarm_irq_enable = rk818_rtc_alarm_irq_enable,
 458         //.update_irq_enable = rk818_rtc_update_irq_enable,
 459         //.irq_set_freq = rk818_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 rk818_rtc_suspend(struct device *dev)
 465 {
 466         struct platform_device *pdev = to_platform_device(dev);
 467         struct rk818_rtc *rk818_rtc = dev_get_drvdata(&pdev->dev);
 468         int ret;
 469
 470         if (rk818_rtc->alarm_enabled && device_may_wakeup(&pdev->dev))
 471                 ret = rk818_rtc_start_alarm(rk818_rtc);
 472         else
 473                 ret = rk818_rtc_stop_alarm(rk818_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 rk818_rtc_resume(struct device *dev)
 485 {
 486         struct platform_device *pdev = to_platform_device(dev);
 487         struct rk818_rtc *rk818_rtc = dev_get_drvdata(&pdev->dev);
 488         int ret;
 489
 490         if (rk818_rtc->alarm_enabled) {
 491                 ret = rk818_rtc_start_alarm(rk818_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 rk818_rtc_freeze(struct device *dev)
 502 {
 503         struct platform_device *pdev = to_platform_device(dev);
 504         struct rk818_rtc *rk818_rtc = dev_get_drvdata(&pdev->dev);
 505         int ret;
 506
 507         ret = rk818_rtc_stop_alarm(rk818_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 rk818_rtc_suspend NULL
 515 #define rk818_rtc_resume NULL
 516 #define rk818_rtc_freeze NULL
 517 #endif
 518 extern struct rk818 *g_rk818;
 519 struct platform_device *rk818_pdev;
 520 struct rtc_time rk818_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 rk818_rtc_probe(struct platform_device *pdev)
 531 {
 532         struct rk818 *rk818 = dev_get_drvdata(pdev->dev.parent);
 533         struct rk818_rtc *rk818_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         rk818_rtc = devm_kzalloc(&pdev->dev,sizeof(*rk818_rtc), GFP_KERNEL);
 543         if (rk818_rtc == NULL)
 544                 return -ENOMEM;
 545
 546         platform_set_drvdata(pdev, rk818_rtc);
 547         rk818_rtc->rk818 = rk818;
 548
 549         /* Take rtc out of reset */
 550         /*
 551         ret = rk818_reg_read(rk818, RK818_DEVCTRL);
 552         if (ret < 0) {
 553                 dev_err(&pdev->dev, "Failed to read RK818_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 = rk818_reg_write(rk818, RK818_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 = rk818_reg_read(rk818, RK818_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 = rk818_reg_write(rk818, RK818_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 = rk818_reg_read(rk818, RK818_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         rk818_reg_write(rk818,RK818_RTC_STATUS_REG,0xfe);
 588         /*set init time*/
 589
 590         ret = rk818_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                 rk818_rtc_set_time(&pdev->dev, &rk818_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         rk818_rtc->rtc = rtc_device_register("rk818", &pdev->dev,
 607                                               &rk818_rtc_ops, THIS_MODULE);
 608         if (IS_ERR(rk818_rtc->rtc)) {
 609                 ret = PTR_ERR(rk818_rtc->rtc);
 610                 goto err;
 611         }
 612
 613         per_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_RTC_PERIOD);
 614         alm_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_RTC_ALARM);
 615
 616         /*request rtc and alarm irq of rk818*/
 617         ret = devm_request_threaded_irq(rk818->dev,per_irq, NULL, rk818_per_irq,
 618                                    IRQF_TRIGGER_RISING, "RTC period",
 619                                    rk818_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(rk818->dev,alm_irq, NULL, rk818_alm_irq,
 626                                    IRQF_TRIGGER_RISING, "RTC alarm",
 627                                    rk818_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         rk818_set_bits(rk818_rtc->rk818, RK818_RTC_STATUS_REG,(0x1<< 6),(0x1 <<6));
 636         rk818_set_bits(rk818_rtc->rk818, RK818_RTC_INT_REG,0x0c,0x0c);
 637         rk818_set_bits(rk818_rtc->rk818,RK818_INT_STS_REG1,(0x3 << 5),(0x3 <<5));
 638         rk818_set_bits(rk818_rtc->rk818, RK818_INT_STS_MSK_REG1,(0x3 <<5),0);
 639 */
 640
 641 //      enable_irq_wake(alm_irq); // so rk818 alarm irq can wake up system
 642         rk818_pdev = pdev;
 643
 644         printk("%s:ok\n",__func__);
 645
 646         return 0;
 647
 648 err:
 649         return ret;
 650 }
 651
 652 static int  rk818_rtc_remove(struct platform_device *pdev)
 653 {
 654         struct rk818_rtc *rk818_rtc = platform_get_drvdata(pdev);
 655         int per_irq = rk818_rtc->rk818->irq_base + RK818_IRQ_RTC_PERIOD;
 656         int alm_irq = rk818_rtc->rk818->irq_base + RK818_IRQ_RTC_ALARM;
 657
 658         free_irq(alm_irq, rk818_rtc);
 659         free_irq(per_irq, rk818_rtc);
 660         rtc_device_unregister(rk818_rtc->rtc);
 661
 662         return 0;
 663 }
 664
 665 static const struct dev_pm_ops rk818_rtc_pm_ops = {
 666         .suspend = rk818_rtc_suspend,
 667         .resume = rk818_rtc_resume,
 668
 669         .freeze = rk818_rtc_freeze,
 670         .thaw = rk818_rtc_resume,
 671         .restore = rk818_rtc_resume,
 672
 673         .poweroff = rk818_rtc_suspend,
 674 };
 675
 676 static struct platform_driver rk818_rtc_driver = {
 677         .probe = rk818_rtc_probe,
 678         .remove = rk818_rtc_remove,
 679         .driver = {
 680                 .name = "rk818-rtc",
 681                 .pm = &rk818_rtc_pm_ops,
 682         },
 683 };
 684
 685 static ssize_t rtc_rk818_test_write(struct file *file,
 686                         const char __user *buf, size_t count, loff_t *offset)
 687 {
 688         char nr_buf[8];
 689         int nr = 0, ret;
 690         struct platform_device *pdev;
 691         struct rtc_time tm;
 692         struct rtc_wkalrm alrm;
 693         struct rk818_rtc *rk818_rtc;
 694
 695         if(count > 3)
 696                 return -EFAULT;
 697         ret = copy_from_user(nr_buf, buf, count);
 698         if(ret < 0)
 699                 return -EFAULT;
 700
 701         sscanf(nr_buf, "%d", &nr);
 702         if(nr > 5 || nr < 0)
 703         {
 704                 printk("%s:data is error\n",__func__);
 705                 return -EFAULT;
 706         }
 707
 708         if(!rk818_pdev)
 709                 return -EFAULT;
 710         else
 711                 pdev = rk818_pdev;
 712
 713
 714         rk818_rtc = dev_get_drvdata(&pdev->dev);
 715
 716         //test rtc time
 717         if(nr == 0)
 718         {
 719                 tm.tm_wday = 6;
 720                 tm.tm_year = 111;
 721                 tm.tm_mon = 0;
 722                 tm.tm_mday = 1;
 723                 tm.tm_hour = 12;
 724                 tm.tm_min = 0;
 725                 tm.tm_sec = 0;
 726
 727                 ret = rk818_rtc_set_time(&pdev->dev, &tm); // 2011-01-01 12:00:00
 728                 if (ret)
 729                 {
 730                         dev_err(&pdev->dev, "Failed to set RTC time\n");
 731                         return -EFAULT;
 732                 }
 733
 734         }
 735
 736         /*set init time*/
 737         ret = rk818_rtc_readtime(&pdev->dev, &tm);
 738         if (ret)
 739                 dev_err(&pdev->dev, "Failed to read RTC time\n");
 740         else
 741                 dev_info(&pdev->dev, "RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 742                         1900 + tm.tm_year, tm.tm_mon + 1, tm.tm_mday, tm.tm_wday,
 743                         tm.tm_hour, tm.tm_min, tm.tm_sec);
 744
 745         if(!ret)
 746         printk("%s:ok\n",__func__);
 747         else
 748         printk("%s:error\n",__func__);
 749
 750
 751         //test rtc alarm
 752         if(nr == 2)
 753         {
 754                 //2000-01-01 00:00:30
 755                 if(tm.tm_sec < 30)
 756                 {
 757                         alrm.time.tm_sec = tm.tm_sec+30;
 758                         alrm.time.tm_min = tm.tm_min;
 759                 }
 760                 else
 761                 {
 762                         alrm.time.tm_sec = tm.tm_sec-30;
 763                         alrm.time.tm_min = tm.tm_min+1;
 764                 }
 765                 alrm.time.tm_hour = tm.tm_hour;
 766                 alrm.time.tm_mday = tm.tm_mday;
 767                 alrm.time.tm_mon = tm.tm_mon;
 768                 alrm.time.tm_year = tm.tm_year;
 769                 rk818_rtc_alarm_irq_enable(&pdev->dev, 1);
 770                 rk818_rtc_setalarm(&pdev->dev, &alrm);
 771
 772                 dev_info(&pdev->dev, "Set alarm %4d-%02d-%02d(%d) %02d:%02d:%02d\n",
 773                                 1900 + alrm.time.tm_year, alrm.time.tm_mon + 1, alrm.time.tm_mday, alrm.time.tm_wday,
 774                                 alrm.time.tm_hour, alrm.time.tm_min, alrm.time.tm_sec);
 775         }
 776
 777
 778         if(nr == 3)
 779         {
 780                 ret = rk818_reg_read(rk818_rtc->rk818, RK818_RTC_STATUS_REG);
 781                 if (ret < 0) {
 782                         printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 783                         return ret;
 784                 }
 785                 printk("%s:ret=0x%x\n",__func__,ret&0xff);
 786
 787                 ret = rk818_reg_write(rk818_rtc->rk818, RK818_RTC_STATUS_REG, ret&0xff);
 788                 if (ret < 0) {
 789                         printk("%s:Failed to read RTC status: %d\n", __func__, ret);
 790                         return ret;
 791                 }
 792         }
 793
 794         if(nr == 4)
 795         rk818_rtc_update_irq_enable(&pdev->dev, 1);
 796
 797         if(nr == 5)
 798         rk818_rtc_update_irq_enable(&pdev->dev, 0);
 799
 800         return count;
 801 }
 802
 803 static const struct file_operations rtc_rk818_test_fops = {
 804         .write = rtc_rk818_test_write,
 805 };
 806
 807 static struct miscdevice rtc_rk818_test_misc = {
 808         .minor = MISC_DYNAMIC_MINOR,
 809         .name = "rtc_rk818_test",
 810         .fops = &rtc_rk818_test_fops,
 811 };
 812
 813
 814 static int __init rk818_rtc_init(void)
 815 {
 816         misc_register(&rtc_rk818_test_misc);
 817         return platform_driver_register(&rk818_rtc_driver);
 818 }
 819 subsys_initcall_sync(rk818_rtc_init);
 820
 821 static void __exit rk818_rtc_exit(void)
 822 {
 823         misc_deregister(&rtc_rk818_test_misc);
 824         platform_driver_unregister(&rk818_rtc_driver);
 825 }
 826 module_exit(rk818_rtc_exit);
 827
 828 MODULE_DESCRIPTION("RTC driver for the rk818 series PMICs");
 829 MODULE_AUTHOR("ZHANGQING <zhanqging@rock-chips.com>");
 830 MODULE_LICENSE("GPL");
 831 MODULE_ALIAS("platform:rk818-rtc");