1 /* 2 * RTC class driver for "CMOS RTC": PCs, ACPI, etc 3 * 4 * Copyright (C) 1996 Paul Gortmaker (drivers/char/rtc.c) 5 * Copyright (C) 2006 David Brownell (convert to new framework) 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 */ 12 13 /* 14 * The original "cmos clock" chip was an MC146818 chip, now obsolete. 15 * That defined the register interface now provided by all PCs, some 16 * non-PC systems, and incorporated into ACPI. Modern PC chipsets 17 * integrate an MC146818 clone in their southbridge, and boards use 18 * that instead of discrete clones like the DS12887 or M48T86. There 19 * are also clones that connect using the LPC bus. 20 * 21 * That register API is also used directly by various other drivers 22 * (notably for integrated NVRAM), infrastructure (x86 has code to 23 * bypass the RTC framework, directly reading the RTC during boot 24 * and updating minutes/seconds for systems using NTP synch) and 25 * utilities (like userspace 'hwclock', if no /dev node exists). 26 * 27 * So **ALL** calls to CMOS_READ and CMOS_WRITE must be done with 28 * interrupts disabled, holding the global rtc_lock, to exclude those 29 * other drivers and utilities on correctly configured systems. 30 */ 31 #include <linux/kernel.h> 32 #include <linux/module.h> 33 #include <linux/init.h> 34 #include <linux/interrupt.h> 35 #include <linux/spinlock.h> 36 #include <linux/platform_device.h> 37 #include <linux/mod_devicetable.h> 38 39 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */ 40 #include <asm-generic/rtc.h> 41 42 43 struct cmos_rtc { 44 struct rtc_device *rtc; 45 struct device *dev; 46 int irq; 47 struct resource *iomem; 48 49 u8 suspend_ctrl; 50 51 /* newer hardware extends the original register set */ 52 u8 day_alrm; 53 u8 mon_alrm; 54 u8 century; 55 }; 56 57 /* both platform and pnp busses use negative numbers for invalid irqs */ 58 #define is_valid_irq(n) ((n) >= 0) 59 60 static const char driver_name[] = "rtc_cmos"; 61 62 /* The RTC_INTR register may have e.g. RTC_PF set even if RTC_PIE is clear; 63 * always mask it against the irq enable bits in RTC_CONTROL. Bit values 64 * are the same: PF==PIE, AF=AIE, UF=UIE; so RTC_IRQMASK works with both. 65 */ 66 #define RTC_IRQMASK (RTC_PF | RTC_AF | RTC_UF) 67 68 static inline int is_intr(u8 rtc_intr) 69 { 70 if (!(rtc_intr & RTC_IRQF)) 71 return 0; 72 return rtc_intr & RTC_IRQMASK; 73 } 74 75 /*----------------------------------------------------------------*/ 76 77 static int cmos_read_time(struct device *dev, struct rtc_time *t) 78 { 79 /* REVISIT: if the clock has a "century" register, use 80 * that instead of the heuristic in get_rtc_time(). 81 * That'll make Y3K compatility (year > 2070) easy! 82 */ 83 get_rtc_time(t); 84 return 0; 85 } 86 87 static int cmos_set_time(struct device *dev, struct rtc_time *t) 88 { 89 /* REVISIT: set the "century" register if available 90 * 91 * NOTE: this ignores the issue whereby updating the seconds 92 * takes effect exactly 500ms after we write the register. 93 * (Also queueing and other delays before we get this far.) 94 */ 95 return set_rtc_time(t); 96 } 97 98 static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t) 99 { 100 struct cmos_rtc *cmos = dev_get_drvdata(dev); 101 unsigned char rtc_control; 102 103 if (!is_valid_irq(cmos->irq)) 104 return -EIO; 105 106 /* Basic alarms only support hour, minute, and seconds fields. 107 * Some also support day and month, for alarms up to a year in 108 * the future. 109 */ 110 t->time.tm_mday = -1; 111 t->time.tm_mon = -1; 112 113 spin_lock_irq(&rtc_lock); 114 t->time.tm_sec = CMOS_READ(RTC_SECONDS_ALARM); 115 t->time.tm_min = CMOS_READ(RTC_MINUTES_ALARM); 116 t->time.tm_hour = CMOS_READ(RTC_HOURS_ALARM); 117 118 if (cmos->day_alrm) { 119 t->time.tm_mday = CMOS_READ(cmos->day_alrm); 120 if (!t->time.tm_mday) 121 t->time.tm_mday = -1; 122 123 if (cmos->mon_alrm) { 124 t->time.tm_mon = CMOS_READ(cmos->mon_alrm); 125 if (!t->time.tm_mon) 126 t->time.tm_mon = -1; 127 } 128 } 129 130 rtc_control = CMOS_READ(RTC_CONTROL); 131 spin_unlock_irq(&rtc_lock); 132 133 /* REVISIT this assumes PC style usage: always BCD */ 134 135 if (((unsigned)t->time.tm_sec) < 0x60) 136 t->time.tm_sec = BCD2BIN(t->time.tm_sec); 137 else 138 t->time.tm_sec = -1; 139 if (((unsigned)t->time.tm_min) < 0x60) 140 t->time.tm_min = BCD2BIN(t->time.tm_min); 141 else 142 t->time.tm_min = -1; 143 if (((unsigned)t->time.tm_hour) < 0x24) 144 t->time.tm_hour = BCD2BIN(t->time.tm_hour); 145 else 146 t->time.tm_hour = -1; 147 148 if (cmos->day_alrm) { 149 if (((unsigned)t->time.tm_mday) <= 0x31) 150 t->time.tm_mday = BCD2BIN(t->time.tm_mday); 151 else 152 t->time.tm_mday = -1; 153 if (cmos->mon_alrm) { 154 if (((unsigned)t->time.tm_mon) <= 0x12) 155 t->time.tm_mon = BCD2BIN(t->time.tm_mon) - 1; 156 else 157 t->time.tm_mon = -1; 158 } 159 } 160 t->time.tm_year = -1; 161 162 t->enabled = !!(rtc_control & RTC_AIE); 163 t->pending = 0; 164 165 return 0; 166 } 167 168 static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t) 169 { 170 struct cmos_rtc *cmos = dev_get_drvdata(dev); 171 unsigned char mon, mday, hrs, min, sec; 172 unsigned char rtc_control, rtc_intr; 173 174 if (!is_valid_irq(cmos->irq)) 175 return -EIO; 176 177 /* REVISIT this assumes PC style usage: always BCD */ 178 179 /* Writing 0xff means "don't care" or "match all". */ 180 181 mon = t->time.tm_mon; 182 mon = (mon < 12) ? BIN2BCD(mon) : 0xff; 183 mon++; 184 185 mday = t->time.tm_mday; 186 mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff; 187 188 hrs = t->time.tm_hour; 189 hrs = (hrs < 24) ? BIN2BCD(hrs) : 0xff; 190 191 min = t->time.tm_min; 192 min = (min < 60) ? BIN2BCD(min) : 0xff; 193 194 sec = t->time.tm_sec; 195 sec = (sec < 60) ? BIN2BCD(sec) : 0xff; 196 197 spin_lock_irq(&rtc_lock); 198 199 /* next rtc irq must not be from previous alarm setting */ 200 rtc_control = CMOS_READ(RTC_CONTROL); 201 rtc_control &= ~RTC_AIE; 202 CMOS_WRITE(rtc_control, RTC_CONTROL); 203 rtc_intr = CMOS_READ(RTC_INTR_FLAGS); 204 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF; 205 if (is_intr(rtc_intr)) 206 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr); 207 208 /* update alarm */ 209 CMOS_WRITE(hrs, RTC_HOURS_ALARM); 210 CMOS_WRITE(min, RTC_MINUTES_ALARM); 211 CMOS_WRITE(sec, RTC_SECONDS_ALARM); 212 213 /* the system may support an "enhanced" alarm */ 214 if (cmos->day_alrm) { 215 CMOS_WRITE(mday, cmos->day_alrm); 216 if (cmos->mon_alrm) 217 CMOS_WRITE(mon, cmos->mon_alrm); 218 } 219 220 if (t->enabled) { 221 rtc_control |= RTC_AIE; 222 CMOS_WRITE(rtc_control, RTC_CONTROL); 223 rtc_intr = CMOS_READ(RTC_INTR_FLAGS); 224 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF; 225 if (is_intr(rtc_intr)) 226 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr); 227 } 228 229 spin_unlock_irq(&rtc_lock); 230 231 return 0; 232 } 233 234 static int cmos_set_freq(struct device *dev, int freq) 235 { 236 struct cmos_rtc *cmos = dev_get_drvdata(dev); 237 int f; 238 unsigned long flags; 239 240 if (!is_valid_irq(cmos->irq)) 241 return -ENXIO; 242 243 /* 0 = no irqs; 1 = 2^15 Hz ... 15 = 2^0 Hz */ 244 f = ffs(freq); 245 if (f != 0) { 246 if (f-- > 16 || freq != (1 << f)) 247 return -EINVAL; 248 f = 16 - f; 249 } 250 251 spin_lock_irqsave(&rtc_lock, flags); 252 CMOS_WRITE(RTC_REF_CLCK_32KHZ | f, RTC_FREQ_SELECT); 253 spin_unlock_irqrestore(&rtc_lock, flags); 254 255 return 0; 256 } 257 258 #if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE) 259 260 static int 261 cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 262 { 263 struct cmos_rtc *cmos = dev_get_drvdata(dev); 264 unsigned char rtc_control, rtc_intr; 265 unsigned long flags; 266 267 switch (cmd) { 268 case RTC_AIE_OFF: 269 case RTC_AIE_ON: 270 case RTC_UIE_OFF: 271 case RTC_UIE_ON: 272 case RTC_PIE_OFF: 273 case RTC_PIE_ON: 274 if (!is_valid_irq(cmos->irq)) 275 return -EINVAL; 276 break; 277 default: 278 return -ENOIOCTLCMD; 279 } 280 281 spin_lock_irqsave(&rtc_lock, flags); 282 rtc_control = CMOS_READ(RTC_CONTROL); 283 switch (cmd) { 284 case RTC_AIE_OFF: /* alarm off */ 285 rtc_control &= ~RTC_AIE; 286 break; 287 case RTC_AIE_ON: /* alarm on */ 288 rtc_control |= RTC_AIE; 289 break; 290 case RTC_UIE_OFF: /* update off */ 291 rtc_control &= ~RTC_UIE; 292 break; 293 case RTC_UIE_ON: /* update on */ 294 rtc_control |= RTC_UIE; 295 break; 296 case RTC_PIE_OFF: /* periodic off */ 297 rtc_control &= ~RTC_PIE; 298 break; 299 case RTC_PIE_ON: /* periodic on */ 300 rtc_control |= RTC_PIE; 301 break; 302 } 303 CMOS_WRITE(rtc_control, RTC_CONTROL); 304 rtc_intr = CMOS_READ(RTC_INTR_FLAGS); 305 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF; 306 if (is_intr(rtc_intr)) 307 rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr); 308 spin_unlock_irqrestore(&rtc_lock, flags); 309 return 0; 310 } 311 312 #else 313 #define cmos_rtc_ioctl NULL 314 #endif 315 316 #if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE) 317 318 static int cmos_procfs(struct device *dev, struct seq_file *seq) 319 { 320 struct cmos_rtc *cmos = dev_get_drvdata(dev); 321 unsigned char rtc_control, valid; 322 323 spin_lock_irq(&rtc_lock); 324 rtc_control = CMOS_READ(RTC_CONTROL); 325 valid = CMOS_READ(RTC_VALID); 326 spin_unlock_irq(&rtc_lock); 327 328 /* NOTE: at least ICH6 reports battery status using a different 329 * (non-RTC) bit; and SQWE is ignored on many current systems. 330 */ 331 return seq_printf(seq, 332 "periodic_IRQ\t: %s\n" 333 "update_IRQ\t: %s\n" 334 // "square_wave\t: %s\n" 335 // "BCD\t\t: %s\n" 336 "DST_enable\t: %s\n" 337 "periodic_freq\t: %d\n" 338 "batt_status\t: %s\n", 339 (rtc_control & RTC_PIE) ? "yes" : "no", 340 (rtc_control & RTC_UIE) ? "yes" : "no", 341 // (rtc_control & RTC_SQWE) ? "yes" : "no", 342 // (rtc_control & RTC_DM_BINARY) ? "no" : "yes", 343 (rtc_control & RTC_DST_EN) ? "yes" : "no", 344 cmos->rtc->irq_freq, 345 (valid & RTC_VRT) ? "okay" : "dead"); 346 } 347 348 #else 349 #define cmos_procfs NULL 350 #endif 351 352 static const struct rtc_class_ops cmos_rtc_ops = { 353 .ioctl = cmos_rtc_ioctl, 354 .read_time = cmos_read_time, 355 .set_time = cmos_set_time, 356 .read_alarm = cmos_read_alarm, 357 .set_alarm = cmos_set_alarm, 358 .proc = cmos_procfs, 359 .irq_set_freq = cmos_set_freq, 360 }; 361 362 /*----------------------------------------------------------------*/ 363 364 static struct cmos_rtc cmos_rtc; 365 366 static irqreturn_t cmos_interrupt(int irq, void *p) 367 { 368 u8 irqstat; 369 370 spin_lock(&rtc_lock); 371 irqstat = CMOS_READ(RTC_INTR_FLAGS); 372 irqstat &= (CMOS_READ(RTC_CONTROL) & RTC_IRQMASK) | RTC_IRQF; 373 spin_unlock(&rtc_lock); 374 375 if (is_intr(irqstat)) { 376 rtc_update_irq(p, 1, irqstat); 377 return IRQ_HANDLED; 378 } else 379 return IRQ_NONE; 380 } 381 382 #ifdef CONFIG_PNPACPI 383 #define is_pnpacpi() 1 384 #define INITSECTION 385 386 #else 387 #define is_pnpacpi() 0 388 #define INITSECTION __init 389 #endif 390 391 static int INITSECTION 392 cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq) 393 { 394 struct cmos_rtc_board_info *info = dev->platform_data; 395 int retval = 0; 396 unsigned char rtc_control; 397 398 /* there can be only one ... */ 399 if (cmos_rtc.dev) 400 return -EBUSY; 401 402 if (!ports) 403 return -ENODEV; 404 405 cmos_rtc.irq = rtc_irq; 406 cmos_rtc.iomem = ports; 407 408 /* For ACPI systems the info comes from the FADT. On others, 409 * board specific setup provides it as appropriate. 410 */ 411 if (info) { 412 cmos_rtc.day_alrm = info->rtc_day_alarm; 413 cmos_rtc.mon_alrm = info->rtc_mon_alarm; 414 cmos_rtc.century = info->rtc_century; 415 } 416 417 cmos_rtc.rtc = rtc_device_register(driver_name, dev, 418 &cmos_rtc_ops, THIS_MODULE); 419 if (IS_ERR(cmos_rtc.rtc)) 420 return PTR_ERR(cmos_rtc.rtc); 421 422 cmos_rtc.dev = dev; 423 dev_set_drvdata(dev, &cmos_rtc); 424 425 /* platform and pnp busses handle resources incompatibly. 426 * 427 * REVISIT for non-x86 systems we may need to handle io memory 428 * resources: ioremap them, and request_mem_region(). 429 */ 430 if (is_pnpacpi()) { 431 retval = request_resource(&ioport_resource, ports); 432 if (retval < 0) { 433 dev_dbg(dev, "i/o registers already in use\n"); 434 goto cleanup0; 435 } 436 } 437 rename_region(ports, cmos_rtc.rtc->class_dev.class_id); 438 439 spin_lock_irq(&rtc_lock); 440 441 /* force periodic irq to CMOS reset default of 1024Hz; 442 * 443 * REVISIT it's been reported that at least one x86_64 ALI mobo 444 * doesn't use 32KHz here ... for portability we might need to 445 * do something about other clock frequencies. 446 */ 447 CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT); 448 cmos_rtc.rtc->irq_freq = 1024; 449 450 /* disable irqs. 451 * 452 * NOTE after changing RTC_xIE bits we always read INTR_FLAGS; 453 * allegedly some older rtcs need that to handle irqs properly 454 */ 455 rtc_control = CMOS_READ(RTC_CONTROL); 456 rtc_control &= ~(RTC_PIE | RTC_AIE | RTC_UIE); 457 CMOS_WRITE(rtc_control, RTC_CONTROL); 458 CMOS_READ(RTC_INTR_FLAGS); 459 460 spin_unlock_irq(&rtc_lock); 461 462 /* FIXME teach the alarm code how to handle binary mode; 463 * <asm-generic/rtc.h> doesn't know 12-hour mode either. 464 */ 465 if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY))) { 466 dev_dbg(dev, "only 24-hr BCD mode supported\n"); 467 retval = -ENXIO; 468 goto cleanup1; 469 } 470 471 if (is_valid_irq(rtc_irq)) 472 retval = request_irq(rtc_irq, cmos_interrupt, IRQF_DISABLED, 473 cmos_rtc.rtc->class_dev.class_id, 474 &cmos_rtc.rtc->class_dev); 475 if (retval < 0) { 476 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq); 477 goto cleanup1; 478 } 479 480 /* REVISIT optionally make 50 or 114 bytes NVRAM available, 481 * like rtc-ds1553, rtc-ds1742 ... this will often include 482 * registers for century, and day/month alarm. 483 */ 484 485 pr_info("%s: alarms up to one %s%s\n", 486 cmos_rtc.rtc->class_dev.class_id, 487 is_valid_irq(rtc_irq) 488 ? (cmos_rtc.mon_alrm 489 ? "year" 490 : (cmos_rtc.day_alrm 491 ? "month" : "day")) 492 : "no", 493 cmos_rtc.century ? ", y3k" : "" 494 ); 495 496 return 0; 497 498 cleanup1: 499 rename_region(ports, NULL); 500 cleanup0: 501 rtc_device_unregister(cmos_rtc.rtc); 502 return retval; 503 } 504 505 static void cmos_do_shutdown(void) 506 { 507 unsigned char rtc_control; 508 509 spin_lock_irq(&rtc_lock); 510 rtc_control = CMOS_READ(RTC_CONTROL); 511 rtc_control &= ~(RTC_PIE|RTC_AIE|RTC_UIE); 512 CMOS_WRITE(rtc_control, RTC_CONTROL); 513 CMOS_READ(RTC_INTR_FLAGS); 514 spin_unlock_irq(&rtc_lock); 515 } 516 517 static void __exit cmos_do_remove(struct device *dev) 518 { 519 struct cmos_rtc *cmos = dev_get_drvdata(dev); 520 521 cmos_do_shutdown(); 522 523 if (is_pnpacpi()) 524 release_resource(cmos->iomem); 525 rename_region(cmos->iomem, NULL); 526 527 if (is_valid_irq(cmos->irq)) 528 free_irq(cmos->irq, &cmos_rtc.rtc->class_dev); 529 530 rtc_device_unregister(cmos_rtc.rtc); 531 532 cmos_rtc.dev = NULL; 533 dev_set_drvdata(dev, NULL); 534 } 535 536 #ifdef CONFIG_PM 537 538 static int cmos_suspend(struct device *dev, pm_message_t mesg) 539 { 540 struct cmos_rtc *cmos = dev_get_drvdata(dev); 541 int do_wake = device_may_wakeup(dev); 542 unsigned char tmp; 543 544 /* only the alarm might be a wakeup event source */ 545 spin_lock_irq(&rtc_lock); 546 cmos->suspend_ctrl = tmp = CMOS_READ(RTC_CONTROL); 547 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) { 548 unsigned char irqstat; 549 550 if (do_wake) 551 tmp &= ~(RTC_PIE|RTC_UIE); 552 else 553 tmp &= ~(RTC_PIE|RTC_AIE|RTC_UIE); 554 CMOS_WRITE(tmp, RTC_CONTROL); 555 irqstat = CMOS_READ(RTC_INTR_FLAGS); 556 irqstat &= (tmp & RTC_IRQMASK) | RTC_IRQF; 557 if (is_intr(irqstat)) 558 rtc_update_irq(&cmos->rtc->class_dev, 1, irqstat); 559 } 560 spin_unlock_irq(&rtc_lock); 561 562 /* ACPI HOOK: enable ACPI_EVENT_RTC when (tmp & RTC_AIE) 563 * ... it'd be best if we could do that under rtc_lock. 564 */ 565 566 pr_debug("%s: suspend%s, ctrl %02x\n", 567 cmos_rtc.rtc->class_dev.class_id, 568 (tmp & RTC_AIE) ? ", alarm may wake" : "", 569 tmp); 570 571 return 0; 572 } 573 574 static int cmos_resume(struct device *dev) 575 { 576 struct cmos_rtc *cmos = dev_get_drvdata(dev); 577 unsigned char tmp = cmos->suspend_ctrl; 578 579 /* REVISIT: a mechanism to resync the system clock (jiffies) 580 * on resume should be portable between platforms ... 581 */ 582 583 /* re-enable any irqs previously active */ 584 if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) { 585 586 /* ACPI HOOK: disable ACPI_EVENT_RTC when (tmp & RTC_AIE) */ 587 588 spin_lock_irq(&rtc_lock); 589 CMOS_WRITE(tmp, RTC_CONTROL); 590 tmp = CMOS_READ(RTC_INTR_FLAGS); 591 tmp &= (cmos->suspend_ctrl & RTC_IRQMASK) | RTC_IRQF; 592 if (is_intr(tmp)) 593 rtc_update_irq(&cmos->rtc->class_dev, 1, tmp); 594 spin_unlock_irq(&rtc_lock); 595 } 596 597 pr_debug("%s: resume, ctrl %02x\n", 598 cmos_rtc.rtc->class_dev.class_id, 599 cmos->suspend_ctrl); 600 601 602 return 0; 603 } 604 605 #else 606 #define cmos_suspend NULL 607 #define cmos_resume NULL 608 #endif 609 610 /*----------------------------------------------------------------*/ 611 612 /* The "CMOS" RTC normally lives on the platform_bus. On ACPI systems, 613 * the device node will always be created as a PNPACPI device. 614 */ 615 616 #ifdef CONFIG_PNPACPI 617 618 #include <linux/pnp.h> 619 620 static int __devinit 621 cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id) 622 { 623 /* REVISIT paranoia argues for a shutdown notifier, since PNP 624 * drivers can't provide shutdown() methods to disable IRQs. 625 * Or better yet, fix PNP to allow those methods... 626 */ 627 return cmos_do_probe(&pnp->dev, 628 &pnp->res.port_resource[0], 629 pnp->res.irq_resource[0].start); 630 } 631 632 static void __exit cmos_pnp_remove(struct pnp_dev *pnp) 633 { 634 cmos_do_remove(&pnp->dev); 635 } 636 637 #ifdef CONFIG_PM 638 639 static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg) 640 { 641 return cmos_suspend(&pnp->dev, mesg); 642 } 643 644 static int cmos_pnp_resume(struct pnp_dev *pnp) 645 { 646 return cmos_resume(&pnp->dev); 647 } 648 649 #else 650 #define cmos_pnp_suspend NULL 651 #define cmos_pnp_resume NULL 652 #endif 653 654 655 static const struct pnp_device_id rtc_ids[] = { 656 { .id = "PNP0b00", }, 657 { .id = "PNP0b01", }, 658 { .id = "PNP0b02", }, 659 { }, 660 }; 661 MODULE_DEVICE_TABLE(pnp, rtc_ids); 662 663 static struct pnp_driver cmos_pnp_driver = { 664 .name = (char *) driver_name, 665 .id_table = rtc_ids, 666 .probe = cmos_pnp_probe, 667 .remove = __exit_p(cmos_pnp_remove), 668 669 /* flag ensures resume() gets called, and stops syslog spam */ 670 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, 671 .suspend = cmos_pnp_suspend, 672 .resume = cmos_pnp_resume, 673 }; 674 675 static int __init cmos_init(void) 676 { 677 return pnp_register_driver(&cmos_pnp_driver); 678 } 679 module_init(cmos_init); 680 681 static void __exit cmos_exit(void) 682 { 683 pnp_unregister_driver(&cmos_pnp_driver); 684 } 685 module_exit(cmos_exit); 686 687 #else /* no PNPACPI */ 688 689 /*----------------------------------------------------------------*/ 690 691 /* Platform setup should have set up an RTC device, when PNPACPI is 692 * unavailable ... this could happen even on (older) PCs. 693 */ 694 695 static int __init cmos_platform_probe(struct platform_device *pdev) 696 { 697 return cmos_do_probe(&pdev->dev, 698 platform_get_resource(pdev, IORESOURCE_IO, 0), 699 platform_get_irq(pdev, 0)); 700 } 701 702 static int __exit cmos_platform_remove(struct platform_device *pdev) 703 { 704 cmos_do_remove(&pdev->dev); 705 return 0; 706 } 707 708 static void cmos_platform_shutdown(struct platform_device *pdev) 709 { 710 cmos_do_shutdown(); 711 } 712 713 static struct platform_driver cmos_platform_driver = { 714 .remove = __exit_p(cmos_platform_remove), 715 .shutdown = cmos_platform_shutdown, 716 .driver = { 717 .name = (char *) driver_name, 718 .suspend = cmos_suspend, 719 .resume = cmos_resume, 720 } 721 }; 722 723 static int __init cmos_init(void) 724 { 725 return platform_driver_probe(&cmos_platform_driver, 726 cmos_platform_probe); 727 } 728 module_init(cmos_init); 729 730 static void __exit cmos_exit(void) 731 { 732 platform_driver_unregister(&cmos_platform_driver); 733 } 734 module_exit(cmos_exit); 735 736 737 #endif /* !PNPACPI */ 738 739 MODULE_AUTHOR("David Brownell"); 740 MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs"); 741 MODULE_LICENSE("GPL"); 742