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