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 static 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 static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled) 640 { 641 /* 642 * We always cancel the timer here first, because otherwise 643 * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK); 644 * when we manage to start the timer before the callback 645 * returns HRTIMER_RESTART. 646 * 647 * We cannot use hrtimer_cancel() here as a running callback 648 * could be blocked on rtc->irq_task_lock and hrtimer_cancel() 649 * would spin forever. 650 */ 651 if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0) 652 return -1; 653 654 if (enabled) { 655 ktime_t period = ktime_set(0, NSEC_PER_SEC / rtc->irq_freq); 656 657 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL); 658 } 659 return 0; 660 } 661 662 /** 663 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs 664 * @rtc: the rtc device 665 * @task: currently registered with rtc_irq_register() 666 * @enabled: true to enable periodic IRQs 667 * Context: any 668 * 669 * Note that rtc_irq_set_freq() should previously have been used to 670 * specify the desired frequency of periodic IRQ task->func() callbacks. 671 */ 672 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled) 673 { 674 int err = 0; 675 unsigned long flags; 676 677 retry: 678 spin_lock_irqsave(&rtc->irq_task_lock, flags); 679 if (rtc->irq_task != NULL && task == NULL) 680 err = -EBUSY; 681 if (rtc->irq_task != task) 682 err = -EACCES; 683 if (!err) { 684 if (rtc_update_hrtimer(rtc, enabled) < 0) { 685 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 686 cpu_relax(); 687 goto retry; 688 } 689 rtc->pie_enabled = enabled; 690 } 691 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 692 return err; 693 } 694 EXPORT_SYMBOL_GPL(rtc_irq_set_state); 695 696 /** 697 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ 698 * @rtc: the rtc device 699 * @task: currently registered with rtc_irq_register() 700 * @freq: positive frequency with which task->func() will be called 701 * Context: any 702 * 703 * Note that rtc_irq_set_state() is used to enable or disable the 704 * periodic IRQs. 705 */ 706 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq) 707 { 708 int err = 0; 709 unsigned long flags; 710 711 if (freq <= 0 || freq > RTC_MAX_FREQ) 712 return -EINVAL; 713 retry: 714 spin_lock_irqsave(&rtc->irq_task_lock, flags); 715 if (rtc->irq_task != NULL && task == NULL) 716 err = -EBUSY; 717 if (rtc->irq_task != task) 718 err = -EACCES; 719 if (!err) { 720 rtc->irq_freq = freq; 721 if (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) { 722 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 723 cpu_relax(); 724 goto retry; 725 } 726 } 727 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 728 return err; 729 } 730 EXPORT_SYMBOL_GPL(rtc_irq_set_freq); 731 732 /** 733 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue 734 * @rtc rtc device 735 * @timer timer being added. 736 * 737 * Enqueues a timer onto the rtc devices timerqueue and sets 738 * the next alarm event appropriately. 739 * 740 * Sets the enabled bit on the added timer. 741 * 742 * Must hold ops_lock for proper serialization of timerqueue 743 */ 744 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer) 745 { 746 timer->enabled = 1; 747 timerqueue_add(&rtc->timerqueue, &timer->node); 748 if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) { 749 struct rtc_wkalrm alarm; 750 int err; 751 alarm.time = rtc_ktime_to_tm(timer->node.expires); 752 alarm.enabled = 1; 753 err = __rtc_set_alarm(rtc, &alarm); 754 if (err == -ETIME) 755 schedule_work(&rtc->irqwork); 756 else if (err) { 757 timerqueue_del(&rtc->timerqueue, &timer->node); 758 timer->enabled = 0; 759 return err; 760 } 761 } 762 return 0; 763 } 764 765 /** 766 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue 767 * @rtc rtc device 768 * @timer timer being removed. 769 * 770 * Removes a timer onto the rtc devices timerqueue and sets 771 * the next alarm event appropriately. 772 * 773 * Clears the enabled bit on the removed timer. 774 * 775 * Must hold ops_lock for proper serialization of timerqueue 776 */ 777 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) 778 { 779 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 780 timerqueue_del(&rtc->timerqueue, &timer->node); 781 timer->enabled = 0; 782 if (next == &timer->node) { 783 struct rtc_wkalrm alarm; 784 int err; 785 next = timerqueue_getnext(&rtc->timerqueue); 786 if (!next) 787 return; 788 alarm.time = rtc_ktime_to_tm(next->expires); 789 alarm.enabled = 1; 790 err = __rtc_set_alarm(rtc, &alarm); 791 if (err == -ETIME) 792 schedule_work(&rtc->irqwork); 793 } 794 } 795 796 /** 797 * rtc_timer_do_work - Expires rtc timers 798 * @rtc rtc device 799 * @timer timer being removed. 800 * 801 * Expires rtc timers. Reprograms next alarm event if needed. 802 * Called via worktask. 803 * 804 * Serializes access to timerqueue via ops_lock mutex 805 */ 806 void rtc_timer_do_work(struct work_struct *work) 807 { 808 struct rtc_timer *timer; 809 struct timerqueue_node *next; 810 ktime_t now; 811 struct rtc_time tm; 812 813 struct rtc_device *rtc = 814 container_of(work, struct rtc_device, irqwork); 815 816 mutex_lock(&rtc->ops_lock); 817 again: 818 __rtc_read_time(rtc, &tm); 819 now = rtc_tm_to_ktime(tm); 820 while ((next = timerqueue_getnext(&rtc->timerqueue))) { 821 if (next->expires.tv64 > now.tv64) 822 break; 823 824 /* expire timer */ 825 timer = container_of(next, struct rtc_timer, node); 826 timerqueue_del(&rtc->timerqueue, &timer->node); 827 timer->enabled = 0; 828 if (timer->task.func) 829 timer->task.func(timer->task.private_data); 830 831 /* Re-add/fwd periodic timers */ 832 if (ktime_to_ns(timer->period)) { 833 timer->node.expires = ktime_add(timer->node.expires, 834 timer->period); 835 timer->enabled = 1; 836 timerqueue_add(&rtc->timerqueue, &timer->node); 837 } 838 } 839 840 /* Set next alarm */ 841 if (next) { 842 struct rtc_wkalrm alarm; 843 int err; 844 alarm.time = rtc_ktime_to_tm(next->expires); 845 alarm.enabled = 1; 846 err = __rtc_set_alarm(rtc, &alarm); 847 if (err == -ETIME) 848 goto again; 849 } 850 851 mutex_unlock(&rtc->ops_lock); 852 } 853 854 855 /* rtc_timer_init - Initializes an rtc_timer 856 * @timer: timer to be intiialized 857 * @f: function pointer to be called when timer fires 858 * @data: private data passed to function pointer 859 * 860 * Kernel interface to initializing an rtc_timer. 861 */ 862 void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data) 863 { 864 timerqueue_init(&timer->node); 865 timer->enabled = 0; 866 timer->task.func = f; 867 timer->task.private_data = data; 868 } 869 870 /* rtc_timer_start - Sets an rtc_timer to fire in the future 871 * @ rtc: rtc device to be used 872 * @ timer: timer being set 873 * @ expires: time at which to expire the timer 874 * @ period: period that the timer will recur 875 * 876 * Kernel interface to set an rtc_timer 877 */ 878 int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer, 879 ktime_t expires, ktime_t period) 880 { 881 int ret = 0; 882 mutex_lock(&rtc->ops_lock); 883 if (timer->enabled) 884 rtc_timer_remove(rtc, timer); 885 886 timer->node.expires = expires; 887 timer->period = period; 888 889 ret = rtc_timer_enqueue(rtc, timer); 890 891 mutex_unlock(&rtc->ops_lock); 892 return ret; 893 } 894 895 /* rtc_timer_cancel - Stops an rtc_timer 896 * @ rtc: rtc device to be used 897 * @ timer: timer being set 898 * 899 * Kernel interface to cancel an rtc_timer 900 */ 901 int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer) 902 { 903 int ret = 0; 904 mutex_lock(&rtc->ops_lock); 905 if (timer->enabled) 906 rtc_timer_remove(rtc, timer); 907 mutex_unlock(&rtc->ops_lock); 908 return ret; 909 } 910 911 912