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