1 /* 2 * RTC subsystem, interface functions 3 * 4 * Copyright (C) 2005 Tower Technologies 5 * Author: Alessandro Zummo <a.zummo@towertech.it> 6 * 7 * based on arch/arm/common/rtctime.c 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/rtc.h> 15 #include <linux/sched.h> 16 #include <linux/log2.h> 17 #include <linux/workqueue.h> 18 19 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer); 20 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer); 21 22 static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 23 { 24 int err; 25 if (!rtc->ops) 26 err = -ENODEV; 27 else if (!rtc->ops->read_time) 28 err = -EINVAL; 29 else { 30 memset(tm, 0, sizeof(struct rtc_time)); 31 err = rtc->ops->read_time(rtc->dev.parent, tm); 32 } 33 return err; 34 } 35 36 int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 37 { 38 int err; 39 40 err = mutex_lock_interruptible(&rtc->ops_lock); 41 if (err) 42 return err; 43 44 err = __rtc_read_time(rtc, tm); 45 mutex_unlock(&rtc->ops_lock); 46 return err; 47 } 48 EXPORT_SYMBOL_GPL(rtc_read_time); 49 50 int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm) 51 { 52 int err; 53 54 err = rtc_valid_tm(tm); 55 if (err != 0) 56 return err; 57 58 err = mutex_lock_interruptible(&rtc->ops_lock); 59 if (err) 60 return err; 61 62 if (!rtc->ops) 63 err = -ENODEV; 64 else if (rtc->ops->set_time) 65 err = rtc->ops->set_time(rtc->dev.parent, tm); 66 else if (rtc->ops->set_mmss) { 67 unsigned long secs; 68 err = rtc_tm_to_time(tm, &secs); 69 if (err == 0) 70 err = rtc->ops->set_mmss(rtc->dev.parent, secs); 71 } else 72 err = -EINVAL; 73 74 mutex_unlock(&rtc->ops_lock); 75 return err; 76 } 77 EXPORT_SYMBOL_GPL(rtc_set_time); 78 79 int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs) 80 { 81 int err; 82 83 err = mutex_lock_interruptible(&rtc->ops_lock); 84 if (err) 85 return err; 86 87 if (!rtc->ops) 88 err = -ENODEV; 89 else if (rtc->ops->set_mmss) 90 err = rtc->ops->set_mmss(rtc->dev.parent, secs); 91 else if (rtc->ops->read_time && rtc->ops->set_time) { 92 struct rtc_time new, old; 93 94 err = rtc->ops->read_time(rtc->dev.parent, &old); 95 if (err == 0) { 96 rtc_time_to_tm(secs, &new); 97 98 /* 99 * avoid writing when we're going to change the day of 100 * the month. We will retry in the next minute. This 101 * basically means that if the RTC must not drift 102 * by more than 1 minute in 11 minutes. 103 */ 104 if (!((old.tm_hour == 23 && old.tm_min == 59) || 105 (new.tm_hour == 23 && new.tm_min == 59))) 106 err = rtc->ops->set_time(rtc->dev.parent, 107 &new); 108 } 109 } 110 else 111 err = -EINVAL; 112 113 mutex_unlock(&rtc->ops_lock); 114 115 return err; 116 } 117 EXPORT_SYMBOL_GPL(rtc_set_mmss); 118 119 static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 120 { 121 int err; 122 123 err = mutex_lock_interruptible(&rtc->ops_lock); 124 if (err) 125 return err; 126 127 if (rtc->ops == NULL) 128 err = -ENODEV; 129 else if (!rtc->ops->read_alarm) 130 err = -EINVAL; 131 else { 132 memset(alarm, 0, sizeof(struct rtc_wkalrm)); 133 err = rtc->ops->read_alarm(rtc->dev.parent, alarm); 134 } 135 136 mutex_unlock(&rtc->ops_lock); 137 return err; 138 } 139 140 int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 141 { 142 int err; 143 struct rtc_time before, now; 144 int first_time = 1; 145 unsigned long t_now, t_alm; 146 enum { none, day, month, year } missing = none; 147 unsigned days; 148 149 /* The lower level RTC driver may return -1 in some fields, 150 * creating invalid alarm->time values, for reasons like: 151 * 152 * - The hardware may not be capable of filling them in; 153 * many alarms match only on time-of-day fields, not 154 * day/month/year calendar data. 155 * 156 * - Some hardware uses illegal values as "wildcard" match 157 * values, which non-Linux firmware (like a BIOS) may try 158 * to set up as e.g. "alarm 15 minutes after each hour". 159 * Linux uses only oneshot alarms. 160 * 161 * When we see that here, we deal with it by using values from 162 * a current RTC timestamp for any missing (-1) values. The 163 * RTC driver prevents "periodic alarm" modes. 164 * 165 * But this can be racey, because some fields of the RTC timestamp 166 * may have wrapped in the interval since we read the RTC alarm, 167 * which would lead to us inserting inconsistent values in place 168 * of the -1 fields. 169 * 170 * Reading the alarm and timestamp in the reverse sequence 171 * would have the same race condition, and not solve the issue. 172 * 173 * So, we must first read the RTC timestamp, 174 * then read the RTC alarm value, 175 * and then read a second RTC timestamp. 176 * 177 * If any fields of the second timestamp have changed 178 * when compared with the first timestamp, then we know 179 * our timestamp may be inconsistent with that used by 180 * the low-level rtc_read_alarm_internal() function. 181 * 182 * So, when the two timestamps disagree, we just loop and do 183 * the process again to get a fully consistent set of values. 184 * 185 * This could all instead be done in the lower level driver, 186 * but since more than one lower level RTC implementation needs it, 187 * then it's probably best best to do it here instead of there.. 188 */ 189 190 /* Get the "before" timestamp */ 191 err = rtc_read_time(rtc, &before); 192 if (err < 0) 193 return err; 194 do { 195 if (!first_time) 196 memcpy(&before, &now, sizeof(struct rtc_time)); 197 first_time = 0; 198 199 /* get the RTC alarm values, which may be incomplete */ 200 err = rtc_read_alarm_internal(rtc, alarm); 201 if (err) 202 return err; 203 204 /* full-function RTCs won't have such missing fields */ 205 if (rtc_valid_tm(&alarm->time) == 0) 206 return 0; 207 208 /* get the "after" timestamp, to detect wrapped fields */ 209 err = rtc_read_time(rtc, &now); 210 if (err < 0) 211 return err; 212 213 /* note that tm_sec is a "don't care" value here: */ 214 } while ( before.tm_min != now.tm_min 215 || before.tm_hour != now.tm_hour 216 || before.tm_mon != now.tm_mon 217 || before.tm_year != now.tm_year); 218 219 /* Fill in the missing alarm fields using the timestamp; we 220 * know there's at least one since alarm->time is invalid. 221 */ 222 if (alarm->time.tm_sec == -1) 223 alarm->time.tm_sec = now.tm_sec; 224 if (alarm->time.tm_min == -1) 225 alarm->time.tm_min = now.tm_min; 226 if (alarm->time.tm_hour == -1) 227 alarm->time.tm_hour = now.tm_hour; 228 229 /* For simplicity, only support date rollover for now */ 230 if (alarm->time.tm_mday == -1) { 231 alarm->time.tm_mday = now.tm_mday; 232 missing = day; 233 } 234 if (alarm->time.tm_mon == -1) { 235 alarm->time.tm_mon = now.tm_mon; 236 if (missing == none) 237 missing = month; 238 } 239 if (alarm->time.tm_year == -1) { 240 alarm->time.tm_year = now.tm_year; 241 if (missing == none) 242 missing = year; 243 } 244 245 /* with luck, no rollover is needed */ 246 rtc_tm_to_time(&now, &t_now); 247 rtc_tm_to_time(&alarm->time, &t_alm); 248 if (t_now < t_alm) 249 goto done; 250 251 switch (missing) { 252 253 /* 24 hour rollover ... if it's now 10am Monday, an alarm that 254 * that will trigger at 5am will do so at 5am Tuesday, which 255 * could also be in the next month or year. This is a common 256 * case, especially for PCs. 257 */ 258 case day: 259 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day"); 260 t_alm += 24 * 60 * 60; 261 rtc_time_to_tm(t_alm, &alarm->time); 262 break; 263 264 /* Month rollover ... if it's the 31th, an alarm on the 3rd will 265 * be next month. An alarm matching on the 30th, 29th, or 28th 266 * may end up in the month after that! Many newer PCs support 267 * this type of alarm. 268 */ 269 case month: 270 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month"); 271 do { 272 if (alarm->time.tm_mon < 11) 273 alarm->time.tm_mon++; 274 else { 275 alarm->time.tm_mon = 0; 276 alarm->time.tm_year++; 277 } 278 days = rtc_month_days(alarm->time.tm_mon, 279 alarm->time.tm_year); 280 } while (days < alarm->time.tm_mday); 281 break; 282 283 /* Year rollover ... easy except for leap years! */ 284 case year: 285 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year"); 286 do { 287 alarm->time.tm_year++; 288 } while (rtc_valid_tm(&alarm->time) != 0); 289 break; 290 291 default: 292 dev_warn(&rtc->dev, "alarm rollover not handled\n"); 293 } 294 295 done: 296 return 0; 297 } 298 299 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 300 { 301 int err; 302 303 err = mutex_lock_interruptible(&rtc->ops_lock); 304 if (err) 305 return err; 306 if (rtc->ops == NULL) 307 err = -ENODEV; 308 else if (!rtc->ops->read_alarm) 309 err = -EINVAL; 310 else { 311 memset(alarm, 0, sizeof(struct rtc_wkalrm)); 312 alarm->enabled = rtc->aie_timer.enabled; 313 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires); 314 } 315 mutex_unlock(&rtc->ops_lock); 316 317 return err; 318 } 319 EXPORT_SYMBOL_GPL(rtc_read_alarm); 320 321 int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 322 { 323 struct rtc_time tm; 324 long now, scheduled; 325 int err; 326 327 err = rtc_valid_tm(&alarm->time); 328 if (err) 329 return err; 330 rtc_tm_to_time(&alarm->time, &scheduled); 331 332 /* Make sure we're not setting alarms in the past */ 333 err = __rtc_read_time(rtc, &tm); 334 rtc_tm_to_time(&tm, &now); 335 if (scheduled <= now) 336 return -ETIME; 337 /* 338 * XXX - We just checked to make sure the alarm time is not 339 * in the past, but there is still a race window where if 340 * the is alarm set for the next second and the second ticks 341 * over right here, before we set the alarm. 342 */ 343 344 if (!rtc->ops) 345 err = -ENODEV; 346 else if (!rtc->ops->set_alarm) 347 err = -EINVAL; 348 else 349 err = rtc->ops->set_alarm(rtc->dev.parent, alarm); 350 351 return err; 352 } 353 354 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 355 { 356 int err; 357 358 err = rtc_valid_tm(&alarm->time); 359 if (err != 0) 360 return err; 361 362 err = mutex_lock_interruptible(&rtc->ops_lock); 363 if (err) 364 return err; 365 if (rtc->aie_timer.enabled) { 366 rtc_timer_remove(rtc, &rtc->aie_timer); 367 } 368 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 369 rtc->aie_timer.period = ktime_set(0, 0); 370 if (alarm->enabled) { 371 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 372 } 373 mutex_unlock(&rtc->ops_lock); 374 return err; 375 } 376 EXPORT_SYMBOL_GPL(rtc_set_alarm); 377 378 /* Called once per device from rtc_device_register */ 379 int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 380 { 381 int err; 382 383 err = rtc_valid_tm(&alarm->time); 384 if (err != 0) 385 return err; 386 387 err = mutex_lock_interruptible(&rtc->ops_lock); 388 if (err) 389 return err; 390 391 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 392 rtc->aie_timer.period = ktime_set(0, 0); 393 if (alarm->enabled) { 394 rtc->aie_timer.enabled = 1; 395 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node); 396 } 397 mutex_unlock(&rtc->ops_lock); 398 return err; 399 } 400 EXPORT_SYMBOL_GPL(rtc_initialize_alarm); 401 402 403 404 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled) 405 { 406 int err = mutex_lock_interruptible(&rtc->ops_lock); 407 if (err) 408 return err; 409 410 if (rtc->aie_timer.enabled != enabled) { 411 if (enabled) 412 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 413 else 414 rtc_timer_remove(rtc, &rtc->aie_timer); 415 } 416 417 if (err) 418 /* nothing */; 419 else if (!rtc->ops) 420 err = -ENODEV; 421 else if (!rtc->ops->alarm_irq_enable) 422 err = -EINVAL; 423 else 424 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled); 425 426 mutex_unlock(&rtc->ops_lock); 427 return err; 428 } 429 EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable); 430 431 int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) 432 { 433 int err = mutex_lock_interruptible(&rtc->ops_lock); 434 if (err) 435 return err; 436 437 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 438 if (enabled == 0 && rtc->uie_irq_active) { 439 mutex_unlock(&rtc->ops_lock); 440 return rtc_dev_update_irq_enable_emul(rtc, 0); 441 } 442 #endif 443 /* make sure we're changing state */ 444 if (rtc->uie_rtctimer.enabled == enabled) 445 goto out; 446 447 if (enabled) { 448 struct rtc_time tm; 449 ktime_t now, onesec; 450 451 __rtc_read_time(rtc, &tm); 452 onesec = ktime_set(1, 0); 453 now = rtc_tm_to_ktime(tm); 454 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec); 455 rtc->uie_rtctimer.period = ktime_set(1, 0); 456 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer); 457 } else 458 rtc_timer_remove(rtc, &rtc->uie_rtctimer); 459 460 out: 461 mutex_unlock(&rtc->ops_lock); 462 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 463 /* 464 * Enable emulation if the driver did not provide 465 * the update_irq_enable function pointer or if returned 466 * -EINVAL to signal that it has been configured without 467 * interrupts or that are not available at the moment. 468 */ 469 if (err == -EINVAL) 470 err = rtc_dev_update_irq_enable_emul(rtc, enabled); 471 #endif 472 return err; 473 474 } 475 EXPORT_SYMBOL_GPL(rtc_update_irq_enable); 476 477 478 /** 479 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook 480 * @rtc: pointer to the rtc device 481 * 482 * This function is called when an AIE, UIE or PIE mode interrupt 483 * has occurred (or been emulated). 484 * 485 * Triggers the registered irq_task function callback. 486 */ 487 void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode) 488 { 489 unsigned long flags; 490 491 /* mark one irq of the appropriate mode */ 492 spin_lock_irqsave(&rtc->irq_lock, flags); 493 rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode); 494 spin_unlock_irqrestore(&rtc->irq_lock, flags); 495 496 /* call the task func */ 497 spin_lock_irqsave(&rtc->irq_task_lock, flags); 498 if (rtc->irq_task) 499 rtc->irq_task->func(rtc->irq_task->private_data); 500 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 501 502 wake_up_interruptible(&rtc->irq_queue); 503 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); 504 } 505 506 507 /** 508 * rtc_aie_update_irq - AIE mode rtctimer hook 509 * @private: pointer to the rtc_device 510 * 511 * This functions is called when the aie_timer expires. 512 */ 513 void rtc_aie_update_irq(void *private) 514 { 515 struct rtc_device *rtc = (struct rtc_device *)private; 516 rtc_handle_legacy_irq(rtc, 1, RTC_AF); 517 } 518 519 520 /** 521 * rtc_uie_update_irq - UIE mode rtctimer hook 522 * @private: pointer to the rtc_device 523 * 524 * This functions is called when the uie_timer expires. 525 */ 526 void rtc_uie_update_irq(void *private) 527 { 528 struct rtc_device *rtc = (struct rtc_device *)private; 529 rtc_handle_legacy_irq(rtc, 1, RTC_UF); 530 } 531 532 533 /** 534 * rtc_pie_update_irq - PIE mode hrtimer hook 535 * @timer: pointer to the pie mode hrtimer 536 * 537 * This function is used to emulate PIE mode interrupts 538 * using an hrtimer. This function is called when the periodic 539 * hrtimer expires. 540 */ 541 enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer) 542 { 543 struct rtc_device *rtc; 544 ktime_t period; 545 int count; 546 rtc = container_of(timer, struct rtc_device, pie_timer); 547 548 period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq); 549 count = hrtimer_forward_now(timer, period); 550 551 rtc_handle_legacy_irq(rtc, count, RTC_PF); 552 553 return HRTIMER_RESTART; 554 } 555 556 /** 557 * rtc_update_irq - Triggered when a RTC interrupt occurs. 558 * @rtc: the rtc device 559 * @num: how many irqs are being reported (usually one) 560 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF 561 * Context: any 562 */ 563 void rtc_update_irq(struct rtc_device *rtc, 564 unsigned long num, unsigned long events) 565 { 566 schedule_work(&rtc->irqwork); 567 } 568 EXPORT_SYMBOL_GPL(rtc_update_irq); 569 570 static int __rtc_match(struct device *dev, void *data) 571 { 572 char *name = (char *)data; 573 574 if (strcmp(dev_name(dev), name) == 0) 575 return 1; 576 return 0; 577 } 578 579 struct rtc_device *rtc_class_open(char *name) 580 { 581 struct device *dev; 582 struct rtc_device *rtc = NULL; 583 584 dev = class_find_device(rtc_class, NULL, name, __rtc_match); 585 if (dev) 586 rtc = to_rtc_device(dev); 587 588 if (rtc) { 589 if (!try_module_get(rtc->owner)) { 590 put_device(dev); 591 rtc = NULL; 592 } 593 } 594 595 return rtc; 596 } 597 EXPORT_SYMBOL_GPL(rtc_class_open); 598 599 void rtc_class_close(struct rtc_device *rtc) 600 { 601 module_put(rtc->owner); 602 put_device(&rtc->dev); 603 } 604 EXPORT_SYMBOL_GPL(rtc_class_close); 605 606 int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task) 607 { 608 int retval = -EBUSY; 609 610 if (task == NULL || task->func == NULL) 611 return -EINVAL; 612 613 /* Cannot register while the char dev is in use */ 614 if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags)) 615 return -EBUSY; 616 617 spin_lock_irq(&rtc->irq_task_lock); 618 if (rtc->irq_task == NULL) { 619 rtc->irq_task = task; 620 retval = 0; 621 } 622 spin_unlock_irq(&rtc->irq_task_lock); 623 624 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags); 625 626 return retval; 627 } 628 EXPORT_SYMBOL_GPL(rtc_irq_register); 629 630 void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task) 631 { 632 spin_lock_irq(&rtc->irq_task_lock); 633 if (rtc->irq_task == task) 634 rtc->irq_task = NULL; 635 spin_unlock_irq(&rtc->irq_task_lock); 636 } 637 EXPORT_SYMBOL_GPL(rtc_irq_unregister); 638 639 /** 640 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs 641 * @rtc: the rtc device 642 * @task: currently registered with rtc_irq_register() 643 * @enabled: true to enable periodic IRQs 644 * Context: any 645 * 646 * Note that rtc_irq_set_freq() should previously have been used to 647 * specify the desired frequency of periodic IRQ task->func() callbacks. 648 */ 649 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled) 650 { 651 int err = 0; 652 unsigned long flags; 653 654 spin_lock_irqsave(&rtc->irq_task_lock, flags); 655 if (rtc->irq_task != NULL && task == NULL) 656 err = -EBUSY; 657 if (rtc->irq_task != task) 658 err = -EACCES; 659 660 if (enabled) { 661 ktime_t period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq); 662 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL); 663 } else { 664 hrtimer_cancel(&rtc->pie_timer); 665 } 666 rtc->pie_enabled = enabled; 667 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 668 669 return err; 670 } 671 EXPORT_SYMBOL_GPL(rtc_irq_set_state); 672 673 /** 674 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ 675 * @rtc: the rtc device 676 * @task: currently registered with rtc_irq_register() 677 * @freq: positive frequency with which task->func() will be called 678 * Context: any 679 * 680 * Note that rtc_irq_set_state() is used to enable or disable the 681 * periodic IRQs. 682 */ 683 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq) 684 { 685 int err = 0; 686 unsigned long flags; 687 688 if (freq <= 0) 689 return -EINVAL; 690 691 spin_lock_irqsave(&rtc->irq_task_lock, flags); 692 if (rtc->irq_task != NULL && task == NULL) 693 err = -EBUSY; 694 if (rtc->irq_task != task) 695 err = -EACCES; 696 if (err == 0) { 697 rtc->irq_freq = freq; 698 if (rtc->pie_enabled) { 699 ktime_t period; 700 hrtimer_cancel(&rtc->pie_timer); 701 period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq); 702 hrtimer_start(&rtc->pie_timer, period, 703 HRTIMER_MODE_REL); 704 } 705 } 706 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 707 return err; 708 } 709 EXPORT_SYMBOL_GPL(rtc_irq_set_freq); 710 711 /** 712 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue 713 * @rtc rtc device 714 * @timer timer being added. 715 * 716 * Enqueues a timer onto the rtc devices timerqueue and sets 717 * the next alarm event appropriately. 718 * 719 * Sets the enabled bit on the added timer. 720 * 721 * Must hold ops_lock for proper serialization of timerqueue 722 */ 723 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer) 724 { 725 timer->enabled = 1; 726 timerqueue_add(&rtc->timerqueue, &timer->node); 727 if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) { 728 struct rtc_wkalrm alarm; 729 int err; 730 alarm.time = rtc_ktime_to_tm(timer->node.expires); 731 alarm.enabled = 1; 732 err = __rtc_set_alarm(rtc, &alarm); 733 if (err == -ETIME) 734 schedule_work(&rtc->irqwork); 735 else if (err) { 736 timerqueue_del(&rtc->timerqueue, &timer->node); 737 timer->enabled = 0; 738 return err; 739 } 740 } 741 return 0; 742 } 743 744 /** 745 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue 746 * @rtc rtc device 747 * @timer timer being removed. 748 * 749 * Removes a timer onto the rtc devices timerqueue and sets 750 * the next alarm event appropriately. 751 * 752 * Clears the enabled bit on the removed timer. 753 * 754 * Must hold ops_lock for proper serialization of timerqueue 755 */ 756 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) 757 { 758 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 759 timerqueue_del(&rtc->timerqueue, &timer->node); 760 timer->enabled = 0; 761 if (next == &timer->node) { 762 struct rtc_wkalrm alarm; 763 int err; 764 next = timerqueue_getnext(&rtc->timerqueue); 765 if (!next) 766 return; 767 alarm.time = rtc_ktime_to_tm(next->expires); 768 alarm.enabled = 1; 769 err = __rtc_set_alarm(rtc, &alarm); 770 if (err == -ETIME) 771 schedule_work(&rtc->irqwork); 772 } 773 } 774 775 /** 776 * rtc_timer_do_work - Expires rtc timers 777 * @rtc rtc device 778 * @timer timer being removed. 779 * 780 * Expires rtc timers. Reprograms next alarm event if needed. 781 * Called via worktask. 782 * 783 * Serializes access to timerqueue via ops_lock mutex 784 */ 785 void rtc_timer_do_work(struct work_struct *work) 786 { 787 struct rtc_timer *timer; 788 struct timerqueue_node *next; 789 ktime_t now; 790 struct rtc_time tm; 791 792 struct rtc_device *rtc = 793 container_of(work, struct rtc_device, irqwork); 794 795 mutex_lock(&rtc->ops_lock); 796 again: 797 __rtc_read_time(rtc, &tm); 798 now = rtc_tm_to_ktime(tm); 799 while ((next = timerqueue_getnext(&rtc->timerqueue))) { 800 if (next->expires.tv64 > now.tv64) 801 break; 802 803 /* expire timer */ 804 timer = container_of(next, struct rtc_timer, node); 805 timerqueue_del(&rtc->timerqueue, &timer->node); 806 timer->enabled = 0; 807 if (timer->task.func) 808 timer->task.func(timer->task.private_data); 809 810 /* Re-add/fwd periodic timers */ 811 if (ktime_to_ns(timer->period)) { 812 timer->node.expires = ktime_add(timer->node.expires, 813 timer->period); 814 timer->enabled = 1; 815 timerqueue_add(&rtc->timerqueue, &timer->node); 816 } 817 } 818 819 /* Set next alarm */ 820 if (next) { 821 struct rtc_wkalrm alarm; 822 int err; 823 alarm.time = rtc_ktime_to_tm(next->expires); 824 alarm.enabled = 1; 825 err = __rtc_set_alarm(rtc, &alarm); 826 if (err == -ETIME) 827 goto again; 828 } 829 830 mutex_unlock(&rtc->ops_lock); 831 } 832 833 834 /* rtc_timer_init - Initializes an rtc_timer 835 * @timer: timer to be intiialized 836 * @f: function pointer to be called when timer fires 837 * @data: private data passed to function pointer 838 * 839 * Kernel interface to initializing an rtc_timer. 840 */ 841 void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data) 842 { 843 timerqueue_init(&timer->node); 844 timer->enabled = 0; 845 timer->task.func = f; 846 timer->task.private_data = data; 847 } 848 849 /* rtc_timer_start - Sets an rtc_timer to fire in the future 850 * @ rtc: rtc device to be used 851 * @ timer: timer being set 852 * @ expires: time at which to expire the timer 853 * @ period: period that the timer will recur 854 * 855 * Kernel interface to set an rtc_timer 856 */ 857 int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer, 858 ktime_t expires, ktime_t period) 859 { 860 int ret = 0; 861 mutex_lock(&rtc->ops_lock); 862 if (timer->enabled) 863 rtc_timer_remove(rtc, timer); 864 865 timer->node.expires = expires; 866 timer->period = period; 867 868 ret = rtc_timer_enqueue(rtc, timer); 869 870 mutex_unlock(&rtc->ops_lock); 871 return ret; 872 } 873 874 /* rtc_timer_cancel - Stops an rtc_timer 875 * @ rtc: rtc device to be used 876 * @ timer: timer being set 877 * 878 * Kernel interface to cancel an rtc_timer 879 */ 880 int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer) 881 { 882 int ret = 0; 883 mutex_lock(&rtc->ops_lock); 884 if (timer->enabled) 885 rtc_timer_remove(rtc, timer); 886 mutex_unlock(&rtc->ops_lock); 887 return ret; 888 } 889 890 891