arch/x86/kernel/hpet.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/clocksource.h>
   3 #include <linux/clockchips.h>
   4 #include <linux/interrupt.h>
   5 #include <linux/irq.h>
   6 #include <linux/export.h>
   7 #include <linux/delay.h>
   8 #include <linux/errno.h>
   9 #include <linux/i8253.h>
  10 #include <linux/slab.h>
  11 #include <linux/hpet.h>
  12 #include <linux/init.h>
  13 #include <linux/cpu.h>
  14 #include <linux/pm.h>
  15 #include <linux/io.h>
  16
  17 #include <asm/cpufeature.h>
  18 #include <asm/irqdomain.h>
  19 #include <asm/fixmap.h>
  20 #include <asm/hpet.h>
  21 #include <asm/time.h>
  22
  23 #undef  pr_fmt
  24 #define pr_fmt(fmt) "hpet: " fmt
  25
  26 #define HPET_MASK                       CLOCKSOURCE_MASK(32)
  27
  28 #define HPET_DEV_USED_BIT               2
  29 #define HPET_DEV_USED                   (1 << HPET_DEV_USED_BIT)
  30 #define HPET_DEV_VALID                  0x8
  31 #define HPET_DEV_FSB_CAP                0x1000
  32 #define HPET_DEV_PERI_CAP               0x2000
  33
  34 #define HPET_MIN_CYCLES                 128
  35 #define HPET_MIN_PROG_DELTA             (HPET_MIN_CYCLES + (HPET_MIN_CYCLES >> 1))
  36
  37 /*
  38  * HPET address is set in acpi/boot.c, when an ACPI entry exists
  39  */
  40 unsigned long                           hpet_address;
  41 u8                                      hpet_blockid; /* OS timer block num */
  42 bool                                    hpet_msi_disable;
  43
  44 #ifdef CONFIG_PCI_MSI
  45 static unsigned int                     hpet_num_timers;
  46 #endif
  47 static void __iomem                     *hpet_virt_address;
  48
  49 struct hpet_dev {
  50         struct clock_event_device       evt;
  51         unsigned int                    num;
  52         int                             cpu;
  53         unsigned int                    irq;
  54         unsigned int                    flags;
  55         char                            name[10];
  56 };
  57
  58 static inline struct hpet_dev *EVT_TO_HPET_DEV(struct clock_event_device *evtdev)
  59 {
  60         return container_of(evtdev, struct hpet_dev, evt);
  61 }
  62
  63 inline unsigned int hpet_readl(unsigned int a)
  64 {
  65         return readl(hpet_virt_address + a);
  66 }
  67
  68 static inline void hpet_writel(unsigned int d, unsigned int a)
  69 {
  70         writel(d, hpet_virt_address + a);
  71 }
  72
  73 #ifdef CONFIG_X86_64
  74 #include <asm/pgtable.h>
  75 #endif
  76
  77 static inline void hpet_set_mapping(void)
  78 {
  79         hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
  80 }
  81
  82 static inline void hpet_clear_mapping(void)
  83 {
  84         iounmap(hpet_virt_address);
  85         hpet_virt_address = NULL;
  86 }
  87
  88 /*
  89  * HPET command line enable / disable
  90  */
  91 bool boot_hpet_disable;
  92 bool hpet_force_user;
  93 static bool hpet_verbose;
  94
  95 static int __init hpet_setup(char *str)
  96 {
  97         while (str) {
  98                 char *next = strchr(str, ',');
  99
 100                 if (next)
 101                         *next++ = 0;
 102                 if (!strncmp("disable", str, 7))
 103                         boot_hpet_disable = true;
 104                 if (!strncmp("force", str, 5))
 105                         hpet_force_user = true;
 106                 if (!strncmp("verbose", str, 7))
 107                         hpet_verbose = true;
 108                 str = next;
 109         }
 110         return 1;
 111 }
 112 __setup("hpet=", hpet_setup);
 113
 114 static int __init disable_hpet(char *str)
 115 {
 116         boot_hpet_disable = true;
 117         return 1;
 118 }
 119 __setup("nohpet", disable_hpet);
 120
 121 static inline int is_hpet_capable(void)
 122 {
 123         return !boot_hpet_disable && hpet_address;
 124 }
 125
 126 /*
 127  * HPET timer interrupt enable / disable
 128  */
 129 static bool hpet_legacy_int_enabled;
 130
 131 /**
 132  * is_hpet_enabled - check whether the hpet timer interrupt is enabled
 133  */
 134 int is_hpet_enabled(void)
 135 {
 136         return is_hpet_capable() && hpet_legacy_int_enabled;
 137 }
 138 EXPORT_SYMBOL_GPL(is_hpet_enabled);
 139
 140 static void _hpet_print_config(const char *function, int line)
 141 {
 142         u32 i, timers, l, h;
 143         pr_info("%s(%d):\n", function, line);
 144         l = hpet_readl(HPET_ID);
 145         h = hpet_readl(HPET_PERIOD);
 146         timers = ((l & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
 147         pr_info("ID: 0x%x, PERIOD: 0x%x\n", l, h);
 148         l = hpet_readl(HPET_CFG);
 149         h = hpet_readl(HPET_STATUS);
 150         pr_info("CFG: 0x%x, STATUS: 0x%x\n", l, h);
 151         l = hpet_readl(HPET_COUNTER);
 152         h = hpet_readl(HPET_COUNTER+4);
 153         pr_info("COUNTER_l: 0x%x, COUNTER_h: 0x%x\n", l, h);
 154
 155         for (i = 0; i < timers; i++) {
 156                 l = hpet_readl(HPET_Tn_CFG(i));
 157                 h = hpet_readl(HPET_Tn_CFG(i)+4);
 158                 pr_info("T%d: CFG_l: 0x%x, CFG_h: 0x%x\n", i, l, h);
 159                 l = hpet_readl(HPET_Tn_CMP(i));
 160                 h = hpet_readl(HPET_Tn_CMP(i)+4);
 161                 pr_info("T%d: CMP_l: 0x%x, CMP_h: 0x%x\n", i, l, h);
 162                 l = hpet_readl(HPET_Tn_ROUTE(i));
 163                 h = hpet_readl(HPET_Tn_ROUTE(i)+4);
 164                 pr_info("T%d ROUTE_l: 0x%x, ROUTE_h: 0x%x\n", i, l, h);
 165         }
 166 }
 167
 168 #define hpet_print_config()                                     \
 169 do {                                                            \
 170         if (hpet_verbose)                                       \
 171                 _hpet_print_config(__func__, __LINE__); \
 172 } while (0)
 173
 174 /*
 175  * When the hpet driver (/dev/hpet) is enabled, we need to reserve
 176  * timer 0 and timer 1 in case of RTC emulation.
 177  */
 178 #ifdef CONFIG_HPET
 179
 180 static void hpet_reserve_msi_timers(struct hpet_data *hd);
 181
 182 static void hpet_reserve_platform_timers(unsigned int id)
 183 {
 184         struct hpet __iomem *hpet = hpet_virt_address;
 185         struct hpet_timer __iomem *timer = &hpet->hpet_timers[2];
 186         unsigned int nrtimers, i;
 187         struct hpet_data hd;
 188
 189         nrtimers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
 190
 191         memset(&hd, 0, sizeof(hd));
 192         hd.hd_phys_address      = hpet_address;
 193         hd.hd_address           = hpet;
 194         hd.hd_nirqs             = nrtimers;
 195         hpet_reserve_timer(&hd, 0);
 196
 197 #ifdef CONFIG_HPET_EMULATE_RTC
 198         hpet_reserve_timer(&hd, 1);
 199 #endif
 200
 201         /*
 202          * NOTE that hd_irq[] reflects IOAPIC input pins (LEGACY_8254
 203          * is wrong for i8259!) not the output IRQ.  Many BIOS writers
 204          * don't bother configuring *any* comparator interrupts.
 205          */
 206         hd.hd_irq[0] = HPET_LEGACY_8254;
 207         hd.hd_irq[1] = HPET_LEGACY_RTC;
 208
 209         for (i = 2; i < nrtimers; timer++, i++) {
 210                 hd.hd_irq[i] = (readl(&timer->hpet_config) &
 211                         Tn_INT_ROUTE_CNF_MASK) >> Tn_INT_ROUTE_CNF_SHIFT;
 212         }
 213
 214         hpet_reserve_msi_timers(&hd);
 215
 216         hpet_alloc(&hd);
 217
 218 }
 219 #else
 220 static void hpet_reserve_platform_timers(unsigned int id) { }
 221 #endif
 222
 223 /*
 224  * Common hpet info
 225  */
 226 static unsigned long hpet_freq;
 227
 228 static struct clock_event_device hpet_clockevent;
 229
 230 static void hpet_stop_counter(void)
 231 {
 232         u32 cfg = hpet_readl(HPET_CFG);
 233         cfg &= ~HPET_CFG_ENABLE;
 234         hpet_writel(cfg, HPET_CFG);
 235 }
 236
 237 static void hpet_reset_counter(void)
 238 {
 239         hpet_writel(0, HPET_COUNTER);
 240         hpet_writel(0, HPET_COUNTER + 4);
 241 }
 242
 243 static void hpet_start_counter(void)
 244 {
 245         unsigned int cfg = hpet_readl(HPET_CFG);
 246         cfg |= HPET_CFG_ENABLE;
 247         hpet_writel(cfg, HPET_CFG);
 248 }
 249
 250 static void hpet_restart_counter(void)
 251 {
 252         hpet_stop_counter();
 253         hpet_reset_counter();
 254         hpet_start_counter();
 255 }
 256
 257 static void hpet_resume_device(void)
 258 {
 259         force_hpet_resume();
 260 }
 261
 262 static void hpet_resume_counter(struct clocksource *cs)
 263 {
 264         hpet_resume_device();
 265         hpet_restart_counter();
 266 }
 267
 268 static void hpet_enable_legacy_int(void)
 269 {
 270         unsigned int cfg = hpet_readl(HPET_CFG);
 271
 272         cfg |= HPET_CFG_LEGACY;
 273         hpet_writel(cfg, HPET_CFG);
 274         hpet_legacy_int_enabled = true;
 275 }
 276
 277 static void hpet_legacy_clockevent_register(void)
 278 {
 279         /* Start HPET legacy interrupts */
 280         hpet_enable_legacy_int();
 281
 282         /*
 283          * Start hpet with the boot cpu mask and make it
 284          * global after the IO_APIC has been initialized.
 285          */
 286         hpet_clockevent.cpumask = cpumask_of(boot_cpu_data.cpu_index);
 287         clockevents_config_and_register(&hpet_clockevent, hpet_freq,
 288                                         HPET_MIN_PROG_DELTA, 0x7FFFFFFF);
 289         global_clock_event = &hpet_clockevent;
 290         pr_debug("Clockevent registered\n");
 291 }
 292
 293 static int hpet_set_periodic(struct clock_event_device *evt, int timer)
 294 {
 295         unsigned int cfg, cmp, now;
 296         uint64_t delta;
 297
 298         hpet_stop_counter();
 299         delta = ((uint64_t)(NSEC_PER_SEC / HZ)) * evt->mult;
 300         delta >>= evt->shift;
 301         now = hpet_readl(HPET_COUNTER);
 302         cmp = now + (unsigned int)delta;
 303         cfg = hpet_readl(HPET_Tn_CFG(timer));
 304         cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
 305                HPET_TN_32BIT;
 306         hpet_writel(cfg, HPET_Tn_CFG(timer));
 307         hpet_writel(cmp, HPET_Tn_CMP(timer));
 308         udelay(1);
 309         /*
 310          * HPET on AMD 81xx needs a second write (with HPET_TN_SETVAL
 311          * cleared) to T0_CMP to set the period. The HPET_TN_SETVAL
 312          * bit is automatically cleared after the first write.
 313          * (See AMD-8111 HyperTransport I/O Hub Data Sheet,
 314          * Publication # 24674)
 315          */
 316         hpet_writel((unsigned int)delta, HPET_Tn_CMP(timer));
 317         hpet_start_counter();
 318         hpet_print_config();
 319
 320         return 0;
 321 }
 322
 323 static int hpet_set_oneshot(struct clock_event_device *evt, int timer)
 324 {
 325         unsigned int cfg;
 326
 327         cfg = hpet_readl(HPET_Tn_CFG(timer));
 328         cfg &= ~HPET_TN_PERIODIC;
 329         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
 330         hpet_writel(cfg, HPET_Tn_CFG(timer));
 331
 332         return 0;
 333 }
 334
 335 static int hpet_shutdown(struct clock_event_device *evt, int timer)
 336 {
 337         unsigned int cfg;
 338
 339         cfg = hpet_readl(HPET_Tn_CFG(timer));
 340         cfg &= ~HPET_TN_ENABLE;
 341         hpet_writel(cfg, HPET_Tn_CFG(timer));
 342
 343         return 0;
 344 }
 345
 346 static int hpet_resume(struct clock_event_device *evt)
 347 {
 348         hpet_enable_legacy_int();
 349         hpet_print_config();
 350         return 0;
 351 }
 352
 353 static int hpet_next_event(unsigned long delta,
 354                            struct clock_event_device *evt, int timer)
 355 {
 356         u32 cnt;
 357         s32 res;
 358
 359         cnt = hpet_readl(HPET_COUNTER);
 360         cnt += (u32) delta;
 361         hpet_writel(cnt, HPET_Tn_CMP(timer));
 362
 363         /*
 364          * HPETs are a complete disaster. The compare register is
 365          * based on a equal comparison and neither provides a less
 366          * than or equal functionality (which would require to take
 367          * the wraparound into account) nor a simple count down event
 368          * mode. Further the write to the comparator register is
 369          * delayed internally up to two HPET clock cycles in certain
 370          * chipsets (ATI, ICH9,10). Some newer AMD chipsets have even
 371          * longer delays. We worked around that by reading back the
 372          * compare register, but that required another workaround for
 373          * ICH9,10 chips where the first readout after write can
 374          * return the old stale value. We already had a minimum
 375          * programming delta of 5us enforced, but a NMI or SMI hitting
 376          * between the counter readout and the comparator write can
 377          * move us behind that point easily. Now instead of reading
 378          * the compare register back several times, we make the ETIME
 379          * decision based on the following: Return ETIME if the
 380          * counter value after the write is less than HPET_MIN_CYCLES
 381          * away from the event or if the counter is already ahead of
 382          * the event. The minimum programming delta for the generic
 383          * clockevents code is set to 1.5 * HPET_MIN_CYCLES.
 384          */
 385         res = (s32)(cnt - hpet_readl(HPET_COUNTER));
 386
 387         return res < HPET_MIN_CYCLES ? -ETIME : 0;
 388 }
 389
 390 static int hpet_legacy_shutdown(struct clock_event_device *evt)
 391 {
 392         return hpet_shutdown(evt, 0);
 393 }
 394
 395 static int hpet_legacy_set_oneshot(struct clock_event_device *evt)
 396 {
 397         return hpet_set_oneshot(evt, 0);
 398 }
 399
 400 static int hpet_legacy_set_periodic(struct clock_event_device *evt)
 401 {
 402         return hpet_set_periodic(evt, 0);
 403 }
 404
 405 static int hpet_legacy_resume(struct clock_event_device *evt)
 406 {
 407         return hpet_resume(evt);
 408 }
 409
 410 static int hpet_legacy_next_event(unsigned long delta,
 411                         struct clock_event_device *evt)
 412 {
 413         return hpet_next_event(delta, evt, 0);
 414 }
 415
 416 /*
 417  * The hpet clock event device
 418  */
 419 static struct clock_event_device hpet_clockevent = {
 420         .name                   = "hpet",
 421         .features               = CLOCK_EVT_FEAT_PERIODIC |
 422                                   CLOCK_EVT_FEAT_ONESHOT,
 423         .set_state_periodic     = hpet_legacy_set_periodic,
 424         .set_state_oneshot      = hpet_legacy_set_oneshot,
 425         .set_state_shutdown     = hpet_legacy_shutdown,
 426         .tick_resume            = hpet_legacy_resume,
 427         .set_next_event         = hpet_legacy_next_event,
 428         .irq                    = 0,
 429         .rating                 = 50,
 430 };
 431
 432 /*
 433  * HPET MSI Support
 434  */
 435 #ifdef CONFIG_PCI_MSI
 436
 437 static DEFINE_PER_CPU(struct hpet_dev *, cpu_hpet_dev);
 438 static struct hpet_dev  *hpet_devs;
 439 static struct irq_domain *hpet_domain;
 440
 441 void hpet_msi_unmask(struct irq_data *data)
 442 {
 443         struct hpet_dev *hdev = irq_data_get_irq_handler_data(data);
 444         unsigned int cfg;
 445
 446         /* unmask it */
 447         cfg = hpet_readl(HPET_Tn_CFG(hdev->num));
 448         cfg |= HPET_TN_ENABLE | HPET_TN_FSB;
 449         hpet_writel(cfg, HPET_Tn_CFG(hdev->num));
 450 }
 451
 452 void hpet_msi_mask(struct irq_data *data)
 453 {
 454         struct hpet_dev *hdev = irq_data_get_irq_handler_data(data);
 455         unsigned int cfg;
 456
 457         /* mask it */
 458         cfg = hpet_readl(HPET_Tn_CFG(hdev->num));
 459         cfg &= ~(HPET_TN_ENABLE | HPET_TN_FSB);
 460         hpet_writel(cfg, HPET_Tn_CFG(hdev->num));
 461 }
 462
 463 void hpet_msi_write(struct hpet_dev *hdev, struct msi_msg *msg)
 464 {
 465         hpet_writel(msg->data, HPET_Tn_ROUTE(hdev->num));
 466         hpet_writel(msg->address_lo, HPET_Tn_ROUTE(hdev->num) + 4);
 467 }
 468
 469 void hpet_msi_read(struct hpet_dev *hdev, struct msi_msg *msg)
 470 {
 471         msg->data = hpet_readl(HPET_Tn_ROUTE(hdev->num));
 472         msg->address_lo = hpet_readl(HPET_Tn_ROUTE(hdev->num) + 4);
 473         msg->address_hi = 0;
 474 }
 475
 476 static int hpet_msi_shutdown(struct clock_event_device *evt)
 477 {
 478         struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 479
 480         return hpet_shutdown(evt, hdev->num);
 481 }
 482
 483 static int hpet_msi_set_oneshot(struct clock_event_device *evt)
 484 {
 485         struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 486
 487         return hpet_set_oneshot(evt, hdev->num);
 488 }
 489
 490 static int hpet_msi_set_periodic(struct clock_event_device *evt)
 491 {
 492         struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 493
 494         return hpet_set_periodic(evt, hdev->num);
 495 }
 496
 497 static int hpet_msi_resume(struct clock_event_device *evt)
 498 {
 499         struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 500         struct irq_data *data = irq_get_irq_data(hdev->irq);
 501         struct msi_msg msg;
 502
 503         /* Restore the MSI msg and unmask the interrupt */
 504         irq_chip_compose_msi_msg(data, &msg);
 505         hpet_msi_write(hdev, &msg);
 506         hpet_msi_unmask(data);
 507         return 0;
 508 }
 509
 510 static int hpet_msi_next_event(unsigned long delta,
 511                                 struct clock_event_device *evt)
 512 {
 513         struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 514         return hpet_next_event(delta, evt, hdev->num);
 515 }
 516
 517 static irqreturn_t hpet_interrupt_handler(int irq, void *data)
 518 {
 519         struct hpet_dev *dev = (struct hpet_dev *)data;
 520         struct clock_event_device *hevt = &dev->evt;
 521
 522         if (!hevt->event_handler) {
 523                 pr_info("Spurious interrupt HPET timer %d\n", dev->num);
 524                 return IRQ_HANDLED;
 525         }
 526
 527         hevt->event_handler(hevt);
 528         return IRQ_HANDLED;
 529 }
 530
 531 static int hpet_setup_irq(struct hpet_dev *dev)
 532 {
 533
 534         if (request_irq(dev->irq, hpet_interrupt_handler,
 535                         IRQF_TIMER | IRQF_NOBALANCING,
 536                         dev->name, dev))
 537                 return -1;
 538
 539         disable_irq(dev->irq);
 540         irq_set_affinity(dev->irq, cpumask_of(dev->cpu));
 541         enable_irq(dev->irq);
 542
 543         pr_debug("%s irq %d for MSI\n", dev->name, dev->irq);
 544
 545         return 0;
 546 }
 547
 548 static void init_one_hpet_msi_clockevent(struct hpet_dev *hdev, int cpu)
 549 {
 550         struct clock_event_device *evt = &hdev->evt;
 551
 552         if (!(hdev->flags & HPET_DEV_VALID))
 553                 return;
 554
 555         hdev->cpu = cpu;
 556         per_cpu(cpu_hpet_dev, cpu) = hdev;
 557         evt->name = hdev->name;
 558         hpet_setup_irq(hdev);
 559         evt->irq = hdev->irq;
 560
 561         evt->rating = 110;
 562         evt->features = CLOCK_EVT_FEAT_ONESHOT;
 563         if (hdev->flags & HPET_DEV_PERI_CAP) {
 564                 evt->features |= CLOCK_EVT_FEAT_PERIODIC;
 565                 evt->set_state_periodic = hpet_msi_set_periodic;
 566         }
 567
 568         evt->set_state_shutdown = hpet_msi_shutdown;
 569         evt->set_state_oneshot = hpet_msi_set_oneshot;
 570         evt->tick_resume = hpet_msi_resume;
 571         evt->set_next_event = hpet_msi_next_event;
 572         evt->cpumask = cpumask_of(hdev->cpu);
 573
 574         clockevents_config_and_register(evt, hpet_freq, HPET_MIN_PROG_DELTA,
 575                                         0x7FFFFFFF);
 576 }
 577
 578 #ifdef CONFIG_HPET
 579 /* Reserve at least one timer for userspace (/dev/hpet) */
 580 #define RESERVE_TIMERS 1
 581 #else
 582 #define RESERVE_TIMERS 0
 583 #endif
 584
 585 static void hpet_msi_capability_lookup(unsigned int start_timer)
 586 {
 587         unsigned int id;
 588         unsigned int num_timers;
 589         unsigned int num_timers_used = 0;
 590         int i, irq;
 591
 592         if (hpet_msi_disable)
 593                 return;
 594
 595         if (boot_cpu_has(X86_FEATURE_ARAT))
 596                 return;
 597         id = hpet_readl(HPET_ID);
 598
 599         num_timers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT);
 600         num_timers++; /* Value read out starts from 0 */
 601         hpet_print_config();
 602
 603         hpet_domain = hpet_create_irq_domain(hpet_blockid);
 604         if (!hpet_domain)
 605                 return;
 606
 607         hpet_devs = kcalloc(num_timers, sizeof(struct hpet_dev), GFP_KERNEL);
 608         if (!hpet_devs)
 609                 return;
 610
 611         hpet_num_timers = num_timers;
 612
 613         for (i = start_timer; i < num_timers - RESERVE_TIMERS; i++) {
 614                 struct hpet_dev *hdev = &hpet_devs[num_timers_used];
 615                 unsigned int cfg = hpet_readl(HPET_Tn_CFG(i));
 616
 617                 /* Only consider HPET timer with MSI support */
 618                 if (!(cfg & HPET_TN_FSB_CAP))
 619                         continue;
 620
 621                 hdev->flags = 0;
 622                 if (cfg & HPET_TN_PERIODIC_CAP)
 623                         hdev->flags |= HPET_DEV_PERI_CAP;
 624                 sprintf(hdev->name, "hpet%d", i);
 625                 hdev->num = i;
 626
 627                 irq = hpet_assign_irq(hpet_domain, hdev, hdev->num);
 628                 if (irq <= 0)
 629                         continue;
 630
 631                 hdev->irq = irq;
 632                 hdev->flags |= HPET_DEV_FSB_CAP;
 633                 hdev->flags |= HPET_DEV_VALID;
 634                 num_timers_used++;
 635                 if (num_timers_used == num_possible_cpus())
 636                         break;
 637         }
 638
 639         pr_info("%d channels of %d reserved for per-cpu timers\n",
 640                 num_timers, num_timers_used);
 641 }
 642
 643 #ifdef CONFIG_HPET
 644 static void hpet_reserve_msi_timers(struct hpet_data *hd)
 645 {
 646         int i;
 647
 648         if (!hpet_devs)
 649                 return;
 650
 651         for (i = 0; i < hpet_num_timers; i++) {
 652                 struct hpet_dev *hdev = &hpet_devs[i];
 653
 654                 if (!(hdev->flags & HPET_DEV_VALID))
 655                         continue;
 656
 657                 hd->hd_irq[hdev->num] = hdev->irq;
 658                 hpet_reserve_timer(hd, hdev->num);
 659         }
 660 }
 661 #endif
 662
 663 static struct hpet_dev *hpet_get_unused_timer(void)
 664 {
 665         int i;
 666
 667         if (!hpet_devs)
 668                 return NULL;
 669
 670         for (i = 0; i < hpet_num_timers; i++) {
 671                 struct hpet_dev *hdev = &hpet_devs[i];
 672
 673                 if (!(hdev->flags & HPET_DEV_VALID))
 674                         continue;
 675                 if (test_and_set_bit(HPET_DEV_USED_BIT,
 676                         (unsigned long *)&hdev->flags))
 677                         continue;
 678                 return hdev;
 679         }
 680         return NULL;
 681 }
 682
 683 static int hpet_cpuhp_online(unsigned int cpu)
 684 {
 685         struct hpet_dev *hdev = hpet_get_unused_timer();
 686
 687         if (hdev)
 688                 init_one_hpet_msi_clockevent(hdev, cpu);
 689         return 0;
 690 }
 691
 692 static int hpet_cpuhp_dead(unsigned int cpu)
 693 {
 694         struct hpet_dev *hdev = per_cpu(cpu_hpet_dev, cpu);
 695
 696         if (!hdev)
 697                 return 0;
 698         free_irq(hdev->irq, hdev);
 699         hdev->flags &= ~HPET_DEV_USED;
 700         per_cpu(cpu_hpet_dev, cpu) = NULL;
 701         return 0;
 702 }
 703 #else
 704
 705 static void hpet_msi_capability_lookup(unsigned int start_timer)
 706 {
 707         return;
 708 }
 709
 710 #ifdef CONFIG_HPET
 711 static void hpet_reserve_msi_timers(struct hpet_data *hd)
 712 {
 713         return;
 714 }
 715 #endif
 716
 717 #define hpet_cpuhp_online       NULL
 718 #define hpet_cpuhp_dead         NULL
 719
 720 #endif
 721
 722 /*
 723  * Clock source related code
 724  */
 725 #if defined(CONFIG_SMP) && defined(CONFIG_64BIT)
 726 /*
 727  * Reading the HPET counter is a very slow operation. If a large number of
 728  * CPUs are trying to access the HPET counter simultaneously, it can cause
 729  * massive delay and slow down system performance dramatically. This may
 730  * happen when HPET is the default clock source instead of TSC. For a
 731  * really large system with hundreds of CPUs, the slowdown may be so
 732  * severe that it may actually crash the system because of a NMI watchdog
 733  * soft lockup, for example.
 734  *
 735  * If multiple CPUs are trying to access the HPET counter at the same time,
 736  * we don't actually need to read the counter multiple times. Instead, the
 737  * other CPUs can use the counter value read by the first CPU in the group.
 738  *
 739  * This special feature is only enabled on x86-64 systems. It is unlikely
 740  * that 32-bit x86 systems will have enough CPUs to require this feature
 741  * with its associated locking overhead. And we also need 64-bit atomic
 742  * read.
 743  *
 744  * The lock and the hpet value are stored together and can be read in a
 745  * single atomic 64-bit read. It is explicitly assumed that arch_spinlock_t
 746  * is 32 bits in size.
 747  */
 748 union hpet_lock {
 749         struct {
 750                 arch_spinlock_t lock;
 751                 u32 value;
 752         };
 753         u64 lockval;
 754 };
 755
 756 static union hpet_lock hpet __cacheline_aligned = {
 757         { .lock = __ARCH_SPIN_LOCK_UNLOCKED, },
 758 };
 759
 760 static u64 read_hpet(struct clocksource *cs)
 761 {
 762         unsigned long flags;
 763         union hpet_lock old, new;
 764
 765         BUILD_BUG_ON(sizeof(union hpet_lock) != 8);
 766
 767         /*
 768          * Read HPET directly if in NMI.
 769          */
 770         if (in_nmi())
 771                 return (u64)hpet_readl(HPET_COUNTER);
 772
 773         /*
 774          * Read the current state of the lock and HPET value atomically.
 775          */
 776         old.lockval = READ_ONCE(hpet.lockval);
 777
 778         if (arch_spin_is_locked(&old.lock))
 779                 goto contended;
 780
 781         local_irq_save(flags);
 782         if (arch_spin_trylock(&hpet.lock)) {
 783                 new.value = hpet_readl(HPET_COUNTER);
 784                 /*
 785                  * Use WRITE_ONCE() to prevent store tearing.
 786                  */
 787                 WRITE_ONCE(hpet.value, new.value);
 788                 arch_spin_unlock(&hpet.lock);
 789                 local_irq_restore(flags);
 790                 return (u64)new.value;
 791         }
 792         local_irq_restore(flags);
 793
 794 contended:
 795         /*
 796          * Contended case
 797          * --------------
 798          * Wait until the HPET value change or the lock is free to indicate
 799          * its value is up-to-date.
 800          *
 801          * It is possible that old.value has already contained the latest
 802          * HPET value while the lock holder was in the process of releasing
 803          * the lock. Checking for lock state change will enable us to return
 804          * the value immediately instead of waiting for the next HPET reader
 805          * to come along.
 806          */
 807         do {
 808                 cpu_relax();
 809                 new.lockval = READ_ONCE(hpet.lockval);
 810         } while ((new.value == old.value) && arch_spin_is_locked(&new.lock));
 811
 812         return (u64)new.value;
 813 }
 814 #else
 815 /*
 816  * For UP or 32-bit.
 817  */
 818 static u64 read_hpet(struct clocksource *cs)
 819 {
 820         return (u64)hpet_readl(HPET_COUNTER);
 821 }
 822 #endif
 823
 824 static struct clocksource clocksource_hpet = {
 825         .name           = "hpet",
 826         .rating         = 250,
 827         .read           = read_hpet,
 828         .mask           = HPET_MASK,
 829         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 830         .resume         = hpet_resume_counter,
 831 };
 832
 833 static int hpet_clocksource_register(void)
 834 {
 835         u64 start, now;
 836         u64 t1;
 837
 838         /* Start the counter */
 839         hpet_restart_counter();
 840
 841         /* Verify whether hpet counter works */
 842         t1 = hpet_readl(HPET_COUNTER);
 843         start = rdtsc();
 844
 845         /*
 846          * We don't know the TSC frequency yet, but waiting for
 847          * 200000 TSC cycles is safe:
 848          * 4 GHz == 50us
 849          * 1 GHz == 200us
 850          */
 851         do {
 852                 rep_nop();
 853                 now = rdtsc();
 854         } while ((now - start) < 200000UL);
 855
 856         if (t1 == hpet_readl(HPET_COUNTER)) {
 857                 pr_warn("Counter not counting. HPET disabled\n");
 858                 return -ENODEV;
 859         }
 860
 861         clocksource_register_hz(&clocksource_hpet, (u32)hpet_freq);
 862         return 0;
 863 }
 864
 865 static u32 *hpet_boot_cfg;
 866
 867 /**
 868  * hpet_enable - Try to setup the HPET timer. Returns 1 on success.
 869  */
 870 int __init hpet_enable(void)
 871 {
 872         u32 hpet_period, cfg, id;
 873         u64 freq;
 874         unsigned int i, last;
 875
 876         if (!is_hpet_capable())
 877                 return 0;
 878
 879         hpet_set_mapping();
 880         if (!hpet_virt_address)
 881                 return 0;
 882
 883         /*
 884          * Read the period and check for a sane value:
 885          */
 886         hpet_period = hpet_readl(HPET_PERIOD);
 887
 888         /*
 889          * AMD SB700 based systems with spread spectrum enabled use a
 890          * SMM based HPET emulation to provide proper frequency
 891          * setting. The SMM code is initialized with the first HPET
 892          * register access and takes some time to complete. During
 893          * this time the config register reads 0xffffffff. We check
 894          * for max. 1000 loops whether the config register reads a non
 895          * 0xffffffff value to make sure that HPET is up and running
 896          * before we go further. A counting loop is safe, as the HPET
 897          * access takes thousands of CPU cycles. On non SB700 based
 898          * machines this check is only done once and has no side
 899          * effects.
 900          */
 901         for (i = 0; hpet_readl(HPET_CFG) == 0xFFFFFFFF; i++) {
 902                 if (i == 1000) {
 903                         pr_warn("Config register invalid. Disabling HPET\n");
 904                         goto out_nohpet;
 905                 }
 906         }
 907
 908         if (hpet_period < HPET_MIN_PERIOD || hpet_period > HPET_MAX_PERIOD)
 909                 goto out_nohpet;
 910
 911         /*
 912          * The period is a femto seconds value. Convert it to a
 913          * frequency.
 914          */
 915         freq = FSEC_PER_SEC;
 916         do_div(freq, hpet_period);
 917         hpet_freq = freq;
 918
 919         /*
 920          * Read the HPET ID register to retrieve the IRQ routing
 921          * information and the number of channels
 922          */
 923         id = hpet_readl(HPET_ID);
 924         hpet_print_config();
 925
 926         last = (id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
 927
 928 #ifdef CONFIG_HPET_EMULATE_RTC
 929         /*
 930          * The legacy routing mode needs at least two channels, tick timer
 931          * and the rtc emulation channel.
 932          */
 933         if (!last)
 934                 goto out_nohpet;
 935 #endif
 936
 937         cfg = hpet_readl(HPET_CFG);
 938         hpet_boot_cfg = kmalloc_array(last + 2, sizeof(*hpet_boot_cfg),
 939                                       GFP_KERNEL);
 940         if (hpet_boot_cfg)
 941                 *hpet_boot_cfg = cfg;
 942         else
 943                 pr_warn("HPET initial state will not be saved\n");
 944         cfg &= ~(HPET_CFG_ENABLE | HPET_CFG_LEGACY);
 945         hpet_writel(cfg, HPET_CFG);
 946         if (cfg)
 947                 pr_warn("Global config: Unknown bits %#x\n", cfg);
 948
 949         for (i = 0; i <= last; ++i) {
 950                 cfg = hpet_readl(HPET_Tn_CFG(i));
 951                 if (hpet_boot_cfg)
 952                         hpet_boot_cfg[i + 1] = cfg;
 953                 cfg &= ~(HPET_TN_ENABLE | HPET_TN_LEVEL | HPET_TN_FSB);
 954                 hpet_writel(cfg, HPET_Tn_CFG(i));
 955                 cfg &= ~(HPET_TN_PERIODIC | HPET_TN_PERIODIC_CAP
 956                          | HPET_TN_64BIT_CAP | HPET_TN_32BIT | HPET_TN_ROUTE
 957                          | HPET_TN_FSB | HPET_TN_FSB_CAP);
 958                 if (cfg)
 959                         pr_warn("Channel #%u config: Unknown bits %#x\n", i, cfg);
 960         }
 961         hpet_print_config();
 962
 963         if (hpet_clocksource_register())
 964                 goto out_nohpet;
 965
 966         if (id & HPET_ID_LEGSUP) {
 967                 hpet_legacy_clockevent_register();
 968                 return 1;
 969         }
 970         return 0;
 971
 972 out_nohpet:
 973         hpet_clear_mapping();
 974         hpet_address = 0;
 975         return 0;
 976 }
 977
 978 /*
 979  * Needs to be late, as the reserve_timer code calls kalloc !
 980  *
 981  * Not a problem on i386 as hpet_enable is called from late_time_init,
 982  * but on x86_64 it is necessary !
 983  */
 984 static __init int hpet_late_init(void)
 985 {
 986         int ret;
 987
 988         if (boot_hpet_disable)
 989                 return -ENODEV;
 990
 991         if (!hpet_address) {
 992                 if (!force_hpet_address)
 993                         return -ENODEV;
 994
 995                 hpet_address = force_hpet_address;
 996                 hpet_enable();
 997         }
 998
 999         if (!hpet_virt_address)
1000                 return -ENODEV;
1001
1002         if (hpet_readl(HPET_ID) & HPET_ID_LEGSUP)
1003                 hpet_msi_capability_lookup(2);
1004         else
1005                 hpet_msi_capability_lookup(0);
1006
1007         hpet_reserve_platform_timers(hpet_readl(HPET_ID));
1008         hpet_print_config();
1009
1010         if (hpet_msi_disable)
1011                 return 0;
1012
1013         if (boot_cpu_has(X86_FEATURE_ARAT))
1014                 return 0;
1015
1016         ret = cpuhp_setup_state(CPUHP_AP_X86_HPET_ONLINE, "x86/hpet:online",
1017                                 hpet_cpuhp_online, NULL);
1018         if (ret)
1019                 return ret;
1020         ret = cpuhp_setup_state(CPUHP_X86_HPET_DEAD, "x86/hpet:dead", NULL,
1021                                 hpet_cpuhp_dead);
1022         if (ret)
1023                 goto err_cpuhp;
1024         return 0;
1025
1026 err_cpuhp:
1027         cpuhp_remove_state(CPUHP_AP_X86_HPET_ONLINE);
1028         return ret;
1029 }
1030 fs_initcall(hpet_late_init);
1031
1032 void hpet_disable(void)
1033 {
1034         if (is_hpet_capable() && hpet_virt_address) {
1035                 unsigned int cfg = hpet_readl(HPET_CFG), id, last;
1036
1037                 if (hpet_boot_cfg)
1038                         cfg = *hpet_boot_cfg;
1039                 else if (hpet_legacy_int_enabled) {
1040                         cfg &= ~HPET_CFG_LEGACY;
1041                         hpet_legacy_int_enabled = false;
1042                 }
1043                 cfg &= ~HPET_CFG_ENABLE;
1044                 hpet_writel(cfg, HPET_CFG);
1045
1046                 if (!hpet_boot_cfg)
1047                         return;
1048
1049                 id = hpet_readl(HPET_ID);
1050                 last = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT);
1051
1052                 for (id = 0; id <= last; ++id)
1053                         hpet_writel(hpet_boot_cfg[id + 1], HPET_Tn_CFG(id));
1054
1055                 if (*hpet_boot_cfg & HPET_CFG_ENABLE)
1056                         hpet_writel(*hpet_boot_cfg, HPET_CFG);
1057         }
1058 }
1059
1060 #ifdef CONFIG_HPET_EMULATE_RTC
1061
1062 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1063  * is enabled, we support RTC interrupt functionality in software.
1064  * RTC has 3 kinds of interrupts:
1065  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1066  *    is updated
1067  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1068  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1069  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1070  * (1) and (2) above are implemented using polling at a frequency of
1071  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1072  * overhead. (DEFAULT_RTC_INT_FREQ)
1073  * For (3), we use interrupts at 64Hz or user specified periodic
1074  * frequency, whichever is higher.
1075  */
1076 #include <linux/mc146818rtc.h>
1077 #include <linux/rtc.h>
1078
1079 #define DEFAULT_RTC_INT_FREQ    64
1080 #define DEFAULT_RTC_SHIFT       6
1081 #define RTC_NUM_INTS            1
1082
1083 static unsigned long hpet_rtc_flags;
1084 static int hpet_prev_update_sec;
1085 static struct rtc_time hpet_alarm_time;
1086 static unsigned long hpet_pie_count;
1087 static u32 hpet_t1_cmp;
1088 static u32 hpet_default_delta;
1089 static u32 hpet_pie_delta;
1090 static unsigned long hpet_pie_limit;
1091
1092 static rtc_irq_handler irq_handler;
1093
1094 /*
1095  * Check that the hpet counter c1 is ahead of the c2
1096  */
1097 static inline int hpet_cnt_ahead(u32 c1, u32 c2)
1098 {
1099         return (s32)(c2 - c1) < 0;
1100 }
1101
1102 /*
1103  * Registers a IRQ handler.
1104  */
1105 int hpet_register_irq_handler(rtc_irq_handler handler)
1106 {
1107         if (!is_hpet_enabled())
1108                 return -ENODEV;
1109         if (irq_handler)
1110                 return -EBUSY;
1111
1112         irq_handler = handler;
1113
1114         return 0;
1115 }
1116 EXPORT_SYMBOL_GPL(hpet_register_irq_handler);
1117
1118 /*
1119  * Deregisters the IRQ handler registered with hpet_register_irq_handler()
1120  * and does cleanup.
1121  */
1122 void hpet_unregister_irq_handler(rtc_irq_handler handler)
1123 {
1124         if (!is_hpet_enabled())
1125                 return;
1126
1127         irq_handler = NULL;
1128         hpet_rtc_flags = 0;
1129 }
1130 EXPORT_SYMBOL_GPL(hpet_unregister_irq_handler);
1131
1132 /*
1133  * Timer 1 for RTC emulation. We use one shot mode, as periodic mode
1134  * is not supported by all HPET implementations for timer 1.
1135  *
1136  * hpet_rtc_timer_init() is called when the rtc is initialized.
1137  */
1138 int hpet_rtc_timer_init(void)
1139 {
1140         unsigned int cfg, cnt, delta;
1141         unsigned long flags;
1142
1143         if (!is_hpet_enabled())
1144                 return 0;
1145
1146         if (!hpet_default_delta) {
1147                 uint64_t clc;
1148
1149                 clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
1150                 clc >>= hpet_clockevent.shift + DEFAULT_RTC_SHIFT;
1151                 hpet_default_delta = clc;
1152         }
1153
1154         if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
1155                 delta = hpet_default_delta;
1156         else
1157                 delta = hpet_pie_delta;
1158
1159         local_irq_save(flags);
1160
1161         cnt = delta + hpet_readl(HPET_COUNTER);
1162         hpet_writel(cnt, HPET_T1_CMP);
1163         hpet_t1_cmp = cnt;
1164
1165         cfg = hpet_readl(HPET_T1_CFG);
1166         cfg &= ~HPET_TN_PERIODIC;
1167         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
1168         hpet_writel(cfg, HPET_T1_CFG);
1169
1170         local_irq_restore(flags);
1171
1172         return 1;
1173 }
1174 EXPORT_SYMBOL_GPL(hpet_rtc_timer_init);
1175
1176 static void hpet_disable_rtc_channel(void)
1177 {
1178         u32 cfg = hpet_readl(HPET_T1_CFG);
1179         cfg &= ~HPET_TN_ENABLE;
1180         hpet_writel(cfg, HPET_T1_CFG);
1181 }
1182
1183 /*
1184  * The functions below are called from rtc driver.
1185  * Return 0 if HPET is not being used.
1186  * Otherwise do the necessary changes and return 1.
1187  */
1188 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
1189 {
1190         if (!is_hpet_enabled())
1191                 return 0;
1192
1193         hpet_rtc_flags &= ~bit_mask;
1194         if (unlikely(!hpet_rtc_flags))
1195                 hpet_disable_rtc_channel();
1196
1197         return 1;
1198 }
1199 EXPORT_SYMBOL_GPL(hpet_mask_rtc_irq_bit);
1200
1201 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
1202 {
1203         unsigned long oldbits = hpet_rtc_flags;
1204
1205         if (!is_hpet_enabled())
1206                 return 0;
1207
1208         hpet_rtc_flags |= bit_mask;
1209
1210         if ((bit_mask & RTC_UIE) && !(oldbits & RTC_UIE))
1211                 hpet_prev_update_sec = -1;
1212
1213         if (!oldbits)
1214                 hpet_rtc_timer_init();
1215
1216         return 1;
1217 }
1218 EXPORT_SYMBOL_GPL(hpet_set_rtc_irq_bit);
1219
1220 int hpet_set_alarm_time(unsigned char hrs, unsigned char min,
1221                         unsigned char sec)
1222 {
1223         if (!is_hpet_enabled())
1224                 return 0;
1225
1226         hpet_alarm_time.tm_hour = hrs;
1227         hpet_alarm_time.tm_min = min;
1228         hpet_alarm_time.tm_sec = sec;
1229
1230         return 1;
1231 }
1232 EXPORT_SYMBOL_GPL(hpet_set_alarm_time);
1233
1234 int hpet_set_periodic_freq(unsigned long freq)
1235 {
1236         uint64_t clc;
1237
1238         if (!is_hpet_enabled())
1239                 return 0;
1240
1241         if (freq <= DEFAULT_RTC_INT_FREQ)
1242                 hpet_pie_limit = DEFAULT_RTC_INT_FREQ / freq;
1243         else {
1244                 clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
1245                 do_div(clc, freq);
1246                 clc >>= hpet_clockevent.shift;
1247                 hpet_pie_delta = clc;
1248                 hpet_pie_limit = 0;
1249         }
1250         return 1;
1251 }
1252 EXPORT_SYMBOL_GPL(hpet_set_periodic_freq);
1253
1254 int hpet_rtc_dropped_irq(void)
1255 {
1256         return is_hpet_enabled();
1257 }
1258 EXPORT_SYMBOL_GPL(hpet_rtc_dropped_irq);
1259
1260 static void hpet_rtc_timer_reinit(void)
1261 {
1262         unsigned int delta;
1263         int lost_ints = -1;
1264
1265         if (unlikely(!hpet_rtc_flags))
1266                 hpet_disable_rtc_channel();
1267
1268         if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
1269                 delta = hpet_default_delta;
1270         else
1271                 delta = hpet_pie_delta;
1272
1273         /*
1274          * Increment the comparator value until we are ahead of the
1275          * current count.
1276          */
1277         do {
1278                 hpet_t1_cmp += delta;
1279                 hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
1280                 lost_ints++;
1281         } while (!hpet_cnt_ahead(hpet_t1_cmp, hpet_readl(HPET_COUNTER)));
1282
1283         if (lost_ints) {
1284                 if (hpet_rtc_flags & RTC_PIE)
1285                         hpet_pie_count += lost_ints;
1286                 if (printk_ratelimit())
1287                         pr_warn("Lost %d RTC interrupts\n", lost_ints);
1288         }
1289 }
1290
1291 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
1292 {
1293         struct rtc_time curr_time;
1294         unsigned long rtc_int_flag = 0;
1295
1296         hpet_rtc_timer_reinit();
1297         memset(&curr_time, 0, sizeof(struct rtc_time));
1298
1299         if (hpet_rtc_flags & (RTC_UIE | RTC_AIE))
1300                 mc146818_get_time(&curr_time);
1301
1302         if (hpet_rtc_flags & RTC_UIE &&
1303             curr_time.tm_sec != hpet_prev_update_sec) {
1304                 if (hpet_prev_update_sec >= 0)
1305                         rtc_int_flag = RTC_UF;
1306                 hpet_prev_update_sec = curr_time.tm_sec;
1307         }
1308
1309         if (hpet_rtc_flags & RTC_PIE &&
1310             ++hpet_pie_count >= hpet_pie_limit) {
1311                 rtc_int_flag |= RTC_PF;
1312                 hpet_pie_count = 0;
1313         }
1314
1315         if (hpet_rtc_flags & RTC_AIE &&
1316             (curr_time.tm_sec == hpet_alarm_time.tm_sec) &&
1317             (curr_time.tm_min == hpet_alarm_time.tm_min) &&
1318             (curr_time.tm_hour == hpet_alarm_time.tm_hour))
1319                         rtc_int_flag |= RTC_AF;
1320
1321         if (rtc_int_flag) {
1322                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
1323                 if (irq_handler)
1324                         irq_handler(rtc_int_flag, dev_id);
1325         }
1326         return IRQ_HANDLED;
1327 }
1328 EXPORT_SYMBOL_GPL(hpet_rtc_interrupt);
1329 #endif