1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 /* 28 * The "todds1287" module has implementation for both tod 29 * and power button (pbio) interfaces. This driver controls 30 * RTC & APC units of National Semiconductor's 87317 SuperI/O 31 * chip. The tod interface accesses the RTC unit and pbio 32 * interface accesses the APC unit of SuperI/O. Since both 33 * units are implemented in the same Logical Device, registers 34 * for both units are accessible through a common set of index 35 * address & data registers. That is why both interfaces are 36 * implemented in a same driver. 37 * 38 * The APC unit is used to implement the power button. When the 39 * button momentarily is pressed, an interrupt is generated and 40 * at the same time a Fail-safe timer starts to run. If the 41 * timer is not stopped in 21 seconds, the power to system is 42 * turned off. So the first task in the interrupt handler is to 43 * reset the Fail-safe timer. Note that OBP is not clearing 44 * the Fail-safe timer due to limitation in handling interrupts, 45 * so when OBP is running, the power button should be pressed 46 * and held for 4 seconds for the power to go off, otherwise 47 * a momentarily press will delay the power-off for 21 seconds. 48 * 49 * PSARC/1999/393 describes the pbio(7I) interface. 50 */ 51 52 #include <sys/types.h> 53 #include <sys/conf.h> 54 #include <sys/kmem.h> 55 #include <sys/open.h> 56 #include <sys/ddi.h> 57 #include <sys/sunddi.h> 58 59 #include <sys/todds1287.h> 60 #include <sys/modctl.h> 61 #include <sys/stat.h> 62 #include <sys/clock.h> 63 #include <sys/reboot.h> 64 #include <sys/machsystm.h> 65 #include <sys/poll.h> 66 #include <sys/pbio.h> 67 68 #define ABORT_INCREMENT_DELAY 10 69 70 static timestruc_t todds_get(void); 71 static void todds_set(timestruc_t); 72 static uint_t todds_set_watchdog_timer(uint_t); 73 static uint_t todds_clear_watchdog_timer(void); 74 static void todds_set_power_alarm(timestruc_t); 75 static void todds_clear_power_alarm(void); 76 static uint64_t todds_get_cpufrequency(void); 77 78 extern uint64_t find_cpufrequency(volatile uint8_t *); 79 80 /* 81 * External variables 82 */ 83 extern int watchdog_activated; 84 extern uint_t watchdog_timeout_seconds; 85 extern volatile uint8_t *v_pmc_addr_reg; 86 87 /* 88 * Global variables 89 */ 90 int ds1287_debug_flags; 91 int ds1287_caddr_warn; 92 93 /* 94 * cb ops 95 */ 96 static int ds1287_open(dev_t *, int, int, cred_t *); 97 static int ds1287_close(dev_t, int, int, cred_t *); 98 static int ds1287_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 99 static int ds1287_chpoll(dev_t, short, int, short *, struct pollhead **); 100 101 static void read_rtc(struct rtc_t *); 102 static void write_rtc_time(struct rtc_t *); 103 static void write_rtc_alarm(struct rtc_t *); 104 static void select_bank(int bank); 105 static uint_t ds1287_intr(caddr_t); 106 static uint_t ds1287_softintr(caddr_t); 107 static void ds1287_timeout(caddr_t); 108 static uint_t ds1287_issue_shutdown(caddr_t); 109 static void ds1287_log_message(void); 110 111 static struct cb_ops ds1287_cbops = { 112 ds1287_open, /* open */ 113 ds1287_close, /* close */ 114 nodev, /* strategy */ 115 nodev, /* print */ 116 nodev, /* dump */ 117 nodev, /* read */ 118 nodev, /* write */ 119 ds1287_ioctl, /* ioctl */ 120 nodev, /* devmap */ 121 nodev, /* mmap */ 122 nodev, /* segmap */ 123 ds1287_chpoll, /* poll */ 124 ddi_prop_op, /* cb_prop_op */ 125 NULL, /* streamtab */ 126 D_NEW | D_MP, /* Driver compatibility flag */ 127 CB_REV, /* rev */ 128 nodev, /* int (*cb_aread)() */ 129 nodev /* int (*cb_awrite)() */ 130 }; 131 132 /* 133 * dev ops 134 */ 135 static int ds1287_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 136 static int ds1287_attach(dev_info_t *, ddi_attach_cmd_t); 137 static int ds1287_detach(dev_info_t *, ddi_detach_cmd_t); 138 139 static struct dev_ops ds1287_ops = { 140 DEVO_REV, /* devo_rev */ 141 0, /* refcnt */ 142 ds1287_getinfo, /* getinfo */ 143 nulldev, /* identify */ 144 nulldev, /* probe */ 145 ds1287_attach, /* attach */ 146 ds1287_detach, /* detach */ 147 nodev, /* reset */ 148 &ds1287_cbops, /* cb_ops */ 149 (struct bus_ops *)NULL, /* bus_ops */ 150 NULL, /* power */ 151 ddi_quiesce_not_supported, /* devo_quiesce */ 152 }; 153 154 155 static void *ds1287_state; 156 static int instance = -1; 157 158 /* Driver Tunables */ 159 static int ds1287_interrupt_priority = 15; 160 static int ds1287_softint_priority = 2; 161 static hrtime_t power_button_debounce = MSEC2NSEC(10); 162 static hrtime_t power_button_abort_interval = 1.5 * NANOSEC; 163 static int power_button_abort_presses = 3; 164 static int power_button_abort_enable = 1; 165 static int power_button_enable = 1; 166 167 static int power_button_pressed = 0; 168 static int power_button_cancel = 0; 169 static int power_button_timeouts = 0; 170 static int timeout_cancel = 0; 171 static int additional_presses = 0; 172 173 static ddi_iblock_cookie_t ds1287_lo_iblock; 174 static ddi_iblock_cookie_t ds1287_hi_iblock; 175 static ddi_softintr_t ds1287_softintr_id; 176 static kmutex_t ds1287_reg_mutex; /* Protects ds1287 Registers */ 177 178 static struct modldrv modldrv = { 179 &mod_driverops, /* Type of module. This one is a driver */ 180 "ds1287 clock driver", /* Name of the module. */ 181 &ds1287_ops, /* driver ops */ 182 }; 183 184 static struct modlinkage modlinkage = { 185 MODREV_1, &modldrv, NULL 186 }; 187 188 189 int 190 _init(void) 191 { 192 int status; 193 194 status = ddi_soft_state_init(&ds1287_state, sizeof (struct ds1287), 0); 195 if (status != 0) { 196 return (status); 197 } 198 199 if ((status = mod_install(&modlinkage)) != 0) { 200 ddi_soft_state_fini(&ds1287_state); 201 return (status); 202 } 203 204 205 ds1287_hi_iblock = (ddi_iblock_cookie_t)(uintptr_t) 206 ipltospl(ds1287_interrupt_priority); 207 mutex_init(&ds1287_reg_mutex, NULL, MUTEX_DRIVER, ds1287_hi_iblock); 208 209 mutex_enter(&ds1287_reg_mutex); 210 /* Select Bank 1 */ 211 select_bank(1); 212 DS1287_ADDR_REG = RTC_B; 213 DS1287_DATA_REG = (RTC_DM | RTC_HM); 214 mutex_exit(&ds1287_reg_mutex); 215 216 tod_ops.tod_get = todds_get; 217 tod_ops.tod_set = todds_set; 218 219 /* 220 * If v_pmc_addr_reg isn't set, it's because it wasn't set in 221 * sun4u/os/fillsysinfo.c:have_pmc(). This means the real (pmc) 222 * watchdog routines (sun4u/io/pmc.c) will not be used. If the 223 * user were to set watchdog_enable in /etc/system, we'll need to 224 * use our own NOP routines. 225 */ 226 if (v_pmc_addr_reg == NULL) { 227 tod_ops.tod_set_watchdog_timer = todds_set_watchdog_timer; 228 tod_ops.tod_clear_watchdog_timer = todds_clear_watchdog_timer; 229 } 230 tod_ops.tod_set_power_alarm = todds_set_power_alarm; 231 tod_ops.tod_clear_power_alarm = todds_clear_power_alarm; 232 tod_ops.tod_get_cpufrequency = todds_get_cpufrequency; 233 234 return (status); 235 } 236 237 int 238 _fini(void) 239 { 240 if (strcmp(tod_module_name, "todds1287") == 0) 241 return (EBUSY); 242 243 return (mod_remove(&modlinkage)); 244 } 245 246 /* 247 * The loadable-module _info(9E) entry point 248 */ 249 int 250 _info(struct modinfo *modinfop) 251 { 252 return (mod_info(&modlinkage, modinfop)); 253 } 254 255 /*ARGSUSED*/ 256 static int 257 ds1287_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 258 void **result) 259 { 260 struct ds1287 *softsp; 261 262 if (instance == -1) 263 return (DDI_FAILURE); 264 265 switch (infocmd) { 266 case DDI_INFO_DEVT2DEVINFO: 267 if ((softsp = ddi_get_soft_state(ds1287_state, instance)) 268 == NULL) 269 return (DDI_FAILURE); 270 *result = (void *)softsp->dip; 271 return (DDI_SUCCESS); 272 273 case DDI_INFO_DEVT2INSTANCE: 274 *result = (void *)(uintptr_t)instance; 275 return (DDI_SUCCESS); 276 277 default: 278 return (DDI_FAILURE); 279 } 280 } 281 282 static int 283 ds1287_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 284 { 285 struct ds1287 *softsp; 286 287 DPRINTF("ds1287_attach\n"); 288 switch (cmd) { 289 case DDI_ATTACH: 290 break; 291 case DDI_RESUME: 292 return (DDI_SUCCESS); 293 default: 294 return (DDI_FAILURE); 295 } 296 297 if (instance != -1) { 298 cmn_err(CE_WARN, "ds1287_attach: Another instance is already " 299 "attached."); 300 return (DDI_FAILURE); 301 } 302 303 instance = ddi_get_instance(dip); 304 305 if (v_rtc_addr_reg == NULL) { 306 cmn_err(CE_WARN, "ds1287_attach: v_rtc_addr_reg is NULL"); 307 return (DDI_FAILURE); 308 } 309 310 /* 311 * Allocate softc information. 312 */ 313 if (ddi_soft_state_zalloc(ds1287_state, instance) != DDI_SUCCESS) { 314 cmn_err(CE_WARN, "ds1287_attach: Failed to allocate " 315 "soft states."); 316 return (DDI_FAILURE); 317 } 318 319 softsp = ddi_get_soft_state(ds1287_state, instance); 320 DPRINTF("ds1287_attach: instance=%d softsp=0x%p\n", instance, 321 (void *)softsp); 322 323 softsp->dip = dip; 324 325 if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP, 326 "interrupt-priorities", (caddr_t)&ds1287_interrupt_priority, 327 sizeof (int)) != DDI_PROP_SUCCESS) { 328 cmn_err(CE_WARN, "ds1287_attach: Failed to create \"" 329 "interrupt-priorities\" property."); 330 goto error; 331 } 332 333 /* add the softint */ 334 ds1287_lo_iblock = (ddi_iblock_cookie_t)(uintptr_t) 335 ipltospl(ds1287_softint_priority); 336 337 if (ddi_add_softintr(dip, DDI_SOFTINT_FIXED, &ds1287_softintr_id, 338 &ds1287_lo_iblock, NULL, ds1287_softintr, (caddr_t)softsp) != 339 DDI_SUCCESS) { 340 cmn_err(CE_WARN, "ds1287_attach: Failed to add low interrupt."); 341 goto error1; 342 } 343 344 /* add the hi interrupt */ 345 if (ddi_add_intr(dip, 0, NULL, (ddi_idevice_cookie_t *) 346 &ds1287_hi_iblock, ds1287_intr, NULL) != DDI_SUCCESS) { 347 cmn_err(CE_WARN, "ds1287_attach: Failed to add high " 348 "interrupt."); 349 goto error2; 350 } 351 352 /* 353 * Combination of instance number and clone number 0 is used for 354 * creating the minor node. 355 */ 356 if (ddi_create_minor_node(dip, "power_button", S_IFCHR, 357 (instance << 8) + 0, "ddi_power_button", NULL) == DDI_FAILURE) { 358 cmn_err(CE_WARN, "ds1287_attach: Failed to create minor node"); 359 goto error3; 360 } 361 362 ddi_report_dev(dip); 363 364 return (DDI_SUCCESS); 365 366 error3: 367 ddi_remove_intr(dip, 0, NULL); 368 error2: 369 ddi_remove_softintr(ds1287_softintr_id); 370 error1: 371 (void) ddi_prop_remove(DDI_DEV_T_NONE, dip, "interrupt-priorities"); 372 error: 373 ddi_soft_state_free(ds1287_state, instance); 374 return (DDI_FAILURE); 375 } 376 377 /*ARGSUSED*/ 378 static int 379 ds1287_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 380 { 381 DPRINTF("ds1287_detach\n"); 382 switch (cmd) { 383 case DDI_DETACH: 384 /* 385 * Since it needs to always handle the power button, fail 386 * to detach. 387 */ 388 return (DDI_FAILURE); 389 case DDI_SUSPEND: 390 return (DDI_SUCCESS); 391 default: 392 return (DDI_FAILURE); 393 } 394 } 395 396 /*ARGSUSED1*/ 397 static int 398 ds1287_open(dev_t *devp, int flags, int otyp, cred_t *credp) 399 { 400 struct ds1287 *softsp; 401 int clone; 402 403 if (otyp != OTYP_CHR) 404 return (EINVAL); 405 406 if ((softsp = ddi_get_soft_state(ds1287_state, instance)) == 407 NULL) 408 return (ENXIO); 409 410 mutex_enter(&softsp->ds1287_mutex); 411 for (clone = 1; clone < DS1287_MAX_CLONE; clone++) 412 if (!softsp->clones[clone]) 413 break; 414 415 if (clone == DS1287_MAX_CLONE) { 416 cmn_err(CE_WARN, "ds1287_open: No more allocation left " 417 "to clone a minor."); 418 mutex_exit(&softsp->ds1287_mutex); 419 return (ENXIO); 420 } 421 422 *devp = makedevice(getmajor(*devp), (instance << 8) + clone); 423 softsp->clones[clone] = 1; 424 mutex_exit(&softsp->ds1287_mutex); 425 426 return (0); 427 } 428 429 /*ARGSUSED*/ 430 static int 431 ds1287_close(dev_t dev, int flags, int otyp, cred_t *credp) 432 { 433 struct ds1287 *softsp; 434 int clone; 435 436 if (otyp != OTYP_CHR) 437 return (EINVAL); 438 439 if ((softsp = ddi_get_soft_state(ds1287_state, instance)) == 440 NULL) 441 return (ENXIO); 442 443 clone = DS1287_MINOR_TO_CLONE(getminor(dev)); 444 mutex_enter(&softsp->ds1287_mutex); 445 if (softsp->monitor_on == clone) 446 softsp->monitor_on = 0; 447 softsp->clones[clone] = 0; 448 mutex_exit(&softsp->ds1287_mutex); 449 450 return (0); 451 } 452 453 /*ARGSUSED4*/ 454 static int 455 ds1287_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, 456 cred_t *credp, int *rvalp) 457 { 458 struct ds1287 *softsp; 459 int clone; 460 461 if ((softsp = ddi_get_soft_state(ds1287_state, instance)) == 462 NULL) 463 return (ENXIO); 464 465 clone = DS1287_MINOR_TO_CLONE(getminor(dev)); 466 switch (cmd) { 467 case PB_BEGIN_MONITOR: 468 DPRINTF("ds1287_ioctl: PB_BEGIN_MONITOR is called.\n"); 469 mutex_enter(&softsp->ds1287_mutex); 470 if (softsp->monitor_on) { 471 mutex_exit(&softsp->ds1287_mutex); 472 return (EBUSY); 473 } 474 softsp->monitor_on = clone; 475 mutex_exit(&softsp->ds1287_mutex); 476 return (0); 477 478 case PB_END_MONITOR: 479 DPRINTF("ds1287_ioctl: PB_END_MONITOR is called.\n"); 480 mutex_enter(&softsp->ds1287_mutex); 481 482 /* 483 * If PB_END_MONITOR is called without first 484 * calling PB_BEGIN_MONITOR, an error will be 485 * returned. 486 */ 487 if (!softsp->monitor_on) { 488 mutex_exit(&softsp->ds1287_mutex); 489 return (ENXIO); 490 } 491 492 /* 493 * This clone is not monitoring the button. 494 */ 495 if (softsp->monitor_on != clone) { 496 mutex_exit(&softsp->ds1287_mutex); 497 return (EINVAL); 498 } 499 softsp->monitor_on = 0; 500 mutex_exit(&softsp->ds1287_mutex); 501 return (0); 502 503 case PB_GET_EVENTS: 504 DPRINTF("ds1287_ioctl: PB_GET_EVENTS is called.\n"); 505 mutex_enter(&softsp->ds1287_mutex); 506 if (ddi_copyout((void *)&softsp->events, (void *)arg, 507 sizeof (int), mode) != 0) { 508 mutex_exit(&softsp->ds1287_mutex); 509 return (EFAULT); 510 } 511 512 /* 513 * This ioctl returned the events detected since last 514 * call. Note that any application can get the events 515 * and clear the event register. 516 */ 517 softsp->events = 0; 518 mutex_exit(&softsp->ds1287_mutex); 519 return (0); 520 521 /* 522 * This ioctl is used by the test suite. 523 */ 524 case PB_CREATE_BUTTON_EVENT: 525 DPRINTF("ds1287_ioctl: PB_CREATE_BUTTON_EVENT is called.\n"); 526 (void) ds1287_intr(NULL); 527 return (0); 528 529 default: 530 return (ENOTTY); 531 } 532 } 533 534 /*ARGSUSED*/ 535 static int 536 ds1287_chpoll(dev_t dev, short events, int anyyet, 537 short *reventsp, struct pollhead **phpp) 538 { 539 struct ds1287 *softsp; 540 541 if ((softsp = ddi_get_soft_state(ds1287_state, instance)) == NULL) 542 return (ENXIO); 543 544 mutex_enter(&softsp->ds1287_mutex); 545 *reventsp = 0; 546 if (softsp->events) 547 *reventsp = POLLRDNORM|POLLIN; 548 else { 549 if (!anyyet) 550 *phpp = &softsp->pollhd; 551 } 552 mutex_exit(&softsp->ds1287_mutex); 553 554 return (0); 555 } 556 557 static void 558 ds1287_log_message(void) 559 { 560 struct ds1287 *softsp; 561 562 if ((softsp = ddi_get_soft_state(ds1287_state, instance)) == NULL) { 563 cmn_err(CE_WARN, "ds1287: Failed to get internal state!"); 564 return; 565 } 566 567 mutex_enter(&softsp->ds1287_mutex); 568 softsp->shutdown_pending = 0; 569 cmn_err(CE_WARN, "ds1287: Failed to shut down the system!"); 570 mutex_exit(&softsp->ds1287_mutex); 571 } 572 573 /* 574 * To facilitate a power button abort, ds1287_intr() now posts 575 * a softint (calling ds1287_softintr()) for all power button presses and 576 * counts the number of button presses. An abort is issued if the desired 577 * number of button presses within the given time interval. 578 * 579 * Two variables are used to synchronize between the high level intr; 580 * the softint handler and timeout handler 581 * 582 * power_button_cancel - Indicates that an abort happened and the number 583 * of outstanding timeouts that have to be cancelled 584 * 585 * power_button_pressed - Indicates the number of button presses outstanding 586 * which have not been serviced 587 */ 588 /*ARGSUSED*/ 589 static uint_t 590 ds1287_intr(caddr_t ignore) 591 { 592 hrtime_t tstamp; 593 static hrtime_t o_tstamp = 0; 594 static hrtime_t power_button_tstamp = 0; 595 static int power_button_cnt; 596 uint8_t apcr1; 597 598 /* 599 * Stop the Fail-safe timer that starts running 600 * after power button is pressed. If it is not 601 * stopped in 21 seconds, system powers off. 602 */ 603 mutex_enter(&ds1287_reg_mutex); 604 select_bank(2); 605 DS1287_ADDR_REG = APC_APCR1; 606 apcr1 = DS1287_DATA_REG; 607 apcr1 |= APC_FSTRC; 608 DS1287_DATA_REG = apcr1; 609 select_bank(1); 610 mutex_exit(&ds1287_reg_mutex); 611 612 tstamp = gethrtime(); 613 614 /* need to deal with power button debounce */ 615 if (o_tstamp && (tstamp - o_tstamp) < power_button_debounce) { 616 o_tstamp = tstamp; 617 return (DDI_INTR_CLAIMED); 618 } 619 o_tstamp = tstamp; 620 621 power_button_cnt++; 622 623 mutex_enter(&ds1287_reg_mutex); 624 power_button_pressed++; 625 mutex_exit(&ds1287_reg_mutex); 626 627 /* 628 * If power button abort is enabled and power button was pressed 629 * power_button_abort_presses times within power_button_abort_interval 630 * then call abort_sequence_enter(); 631 */ 632 if (power_button_abort_enable) { 633 if (power_button_abort_presses == 1 || 634 tstamp < (power_button_tstamp + 635 power_button_abort_interval)) { 636 if (power_button_cnt == power_button_abort_presses) { 637 mutex_enter(&ds1287_reg_mutex); 638 power_button_cancel += power_button_timeouts; 639 power_button_pressed = 0; 640 mutex_exit(&ds1287_reg_mutex); 641 power_button_cnt = 0; 642 abort_sequence_enter("Power Button Abort"); 643 return (DDI_INTR_CLAIMED); 644 } 645 } else { 646 power_button_cnt = 1; 647 power_button_tstamp = tstamp; 648 } 649 } 650 651 if (!power_button_enable) 652 return (DDI_INTR_CLAIMED); 653 654 /* post softint to issue timeout for power button action */ 655 ddi_trigger_softintr(ds1287_softintr_id); 656 657 return (DDI_INTR_CLAIMED); 658 } 659 660 /* 661 * Handle the softints.... 662 * 663 * If only one softint is posted for several button presses, record 664 * the number of additional presses just incase this was actually not quite 665 * an Abort sequence so that we can log this event later. 666 * 667 * Issue a timeout with a duration being a fraction larger than 668 * the specified Abort interval inorder to perform a power down if required. 669 */ 670 static uint_t 671 ds1287_softintr(caddr_t arg) 672 { 673 struct ds1287 *softsp = (struct ds1287 *)arg; 674 675 DPRINTF("ds1287_softintr\n"); 676 677 if (!power_button_abort_enable) 678 return (ds1287_issue_shutdown(arg)); 679 680 mutex_enter(&ds1287_reg_mutex); 681 if (!power_button_pressed) { 682 mutex_exit(&ds1287_reg_mutex); 683 return (DDI_INTR_CLAIMED); 684 } 685 686 /* 687 * Schedule a timeout to do the necessary 688 * work for shutdown, only one timeout for 689 * n presses if power button was pressed 690 * more than once before softint fired 691 */ 692 if (power_button_pressed > 1) 693 additional_presses += power_button_pressed - 1; 694 695 timeout_cancel = 0; 696 power_button_pressed = 0; 697 power_button_timeouts++; 698 mutex_exit(&ds1287_reg_mutex); 699 (void) timeout((void(*)(void *))ds1287_timeout, 700 softsp, NSEC_TO_TICK(power_button_abort_interval) + 701 ABORT_INCREMENT_DELAY); 702 703 return (DDI_INTR_CLAIMED); 704 } 705 706 /* 707 * Upon receiving a timeout the following is determined: 708 * 709 * If an Abort sequence was issued, then we cancel all outstanding timeouts 710 * and additional presses prior to the Abort sequence. 711 * 712 * If we had multiple timeouts issued and the abort sequence was not met, 713 * then we had more than one button press to power down the machine. We 714 * were probably trying to issue an abort. So log a message indicating this 715 * and cancel all outstanding timeouts. 716 * 717 * If we had just one timeout and the abort sequence was not met then 718 * we really did want to power down the machine, so call ds1287_issue_shutdown() 719 * to do the work and schedule a power down 720 */ 721 static void 722 ds1287_timeout(caddr_t arg) 723 { 724 static int first = 0; 725 726 DPRINTF("ds1287_timeout\n"); 727 728 /* 729 * Abort was generated cancel all outstanding power 730 * button timeouts 731 */ 732 mutex_enter(&ds1287_reg_mutex); 733 if (power_button_cancel) { 734 power_button_cancel--; 735 power_button_timeouts--; 736 if (!first) { 737 first++; 738 additional_presses = 0; 739 } 740 mutex_exit(&ds1287_reg_mutex); 741 return; 742 } 743 first = 0; 744 745 /* 746 * We get here if the timeout(s) have fired and they were 747 * not issued prior to an abort. 748 * 749 * If we had more than one press in the interval we were 750 * probably trying to issue an abort, but didnt press the 751 * required number within the interval. Hence cancel all 752 * timeouts and do not continue towards shutdown. 753 */ 754 if (!timeout_cancel) { 755 timeout_cancel = power_button_timeouts + 756 additional_presses; 757 758 power_button_timeouts--; 759 if (!power_button_timeouts) 760 additional_presses = 0; 761 762 if (timeout_cancel > 1) { 763 mutex_exit(&ds1287_reg_mutex); 764 cmn_err(CE_NOTE, "Power Button pressed " 765 "%d times, cancelling all requests", 766 timeout_cancel); 767 return; 768 } 769 mutex_exit(&ds1287_reg_mutex); 770 771 /* Go and do the work to request shutdown */ 772 (void) ds1287_issue_shutdown(arg); 773 return; 774 } 775 776 power_button_timeouts--; 777 if (!power_button_timeouts) 778 additional_presses = 0; 779 mutex_exit(&ds1287_reg_mutex); 780 } 781 782 static uint_t 783 ds1287_issue_shutdown(caddr_t arg) 784 { 785 struct ds1287 *softsp = (struct ds1287 *)arg; 786 787 DPRINTF("ds1287_issue_shutdown\n"); 788 789 mutex_enter(&softsp->ds1287_mutex); 790 softsp->events |= PB_BUTTON_PRESS; 791 if (softsp->monitor_on != 0) { 792 mutex_exit(&softsp->ds1287_mutex); 793 pollwakeup(&softsp->pollhd, POLLRDNORM); 794 pollwakeup(&softsp->pollhd, POLLIN); 795 return (DDI_INTR_CLAIMED); 796 } 797 798 if (!softsp->shutdown_pending) { 799 cmn_err(CE_WARN, "Power button is pressed, powering down " 800 "the system!"); 801 softsp->shutdown_pending = 1; 802 do_shutdown(); 803 804 /* 805 * Wait a while for "do_shutdown()" to shut down the system 806 * before logging an error message. 807 */ 808 (void) timeout((void(*)(void *))ds1287_log_message, NULL, 809 100 * hz); 810 } 811 mutex_exit(&softsp->ds1287_mutex); 812 813 return (DDI_INTR_CLAIMED); 814 } 815 816 /* 817 * Read the current time from the clock chip and convert to UNIX form. 818 * Assumes that the year in the clock chip is valid. 819 * Must be called with tod_lock held. 820 */ 821 static timestruc_t 822 todds_get(void) 823 { 824 timestruc_t ts; 825 todinfo_t tod; 826 struct rtc_t rtc; 827 828 ASSERT(MUTEX_HELD(&tod_lock)); 829 830 read_rtc(&rtc); 831 DPRINTF("todds_get: century=%d year=%d dom=%d hrs=%d\n", 832 rtc.rtc_century, rtc.rtc_year, rtc.rtc_dom, rtc.rtc_hrs); 833 834 /* 835 * tod_year is base 1900 so this code needs to adjust the true 836 * year retrieved from the rtc's century and year fields. 837 */ 838 tod.tod_year = rtc.rtc_year + (rtc.rtc_century * 100) - 1900; 839 tod.tod_month = rtc.rtc_mon; 840 tod.tod_day = rtc.rtc_dom; 841 tod.tod_dow = rtc.rtc_dow; 842 tod.tod_hour = rtc.rtc_hrs; 843 tod.tod_min = rtc.rtc_min; 844 tod.tod_sec = rtc.rtc_sec; 845 846 ts.tv_sec = tod_to_utc(tod); 847 ts.tv_nsec = 0; 848 849 /* set the hw watchdog timer if it's been activated */ 850 if (watchdog_activated) { 851 int ret = 0; 852 ret = tod_ops.tod_set_watchdog_timer(watchdog_timeout_seconds); 853 if (ret == 0) 854 cmn_err(CE_WARN, "ds1287: failed to set hardware " 855 "watchdog timer."); 856 } 857 858 return (ts); 859 } 860 861 void 862 read_rtc(struct rtc_t *rtc) 863 { 864 uint8_t regb; 865 866 /* 867 * Some SuperIO tod devices don't seem to properly initialize 868 * the CADDR register to place the Century register at bank 1 869 * address 0x48. 870 */ 871 mutex_enter(&ds1287_reg_mutex); 872 873 select_bank(2); 874 DS1287_ADDR_REG = RTC_CADDR; 875 regb = DS1287_DATA_REG; 876 if (regb != 0xc8) { 877 if (!ds1287_caddr_warn) { 878 ds1287_caddr_warn = 1; 879 cmn_err(CE_WARN, "ds1287: century address register " 880 "incorrect (exp 0xc8, obs %x)", regb); 881 } 882 DS1287_DATA_REG = 0xc8; 883 } 884 885 select_bank(1); 886 /* 887 * Freeze clock update 888 */ 889 DS1287_ADDR_REG = RTC_B; 890 regb = DS1287_DATA_REG; 891 DS1287_DATA_REG = (regb | RTC_SET); 892 893 DS1287_ADDR_REG = RTC_SEC; 894 rtc->rtc_sec = DS1287_DATA_REG; 895 DS1287_ADDR_REG = RTC_ASEC; 896 rtc->rtc_asec = DS1287_DATA_REG; 897 DS1287_ADDR_REG = RTC_MIN; 898 rtc->rtc_min = DS1287_DATA_REG; 899 DS1287_ADDR_REG = RTC_AMIN; 900 rtc->rtc_amin = DS1287_DATA_REG; 901 DS1287_ADDR_REG = RTC_HRS; 902 rtc->rtc_hrs = DS1287_DATA_REG; 903 DS1287_ADDR_REG = RTC_AHRS; 904 rtc->rtc_ahrs = DS1287_DATA_REG; 905 DS1287_ADDR_REG = RTC_DOW; 906 rtc->rtc_dow = DS1287_DATA_REG; 907 DS1287_ADDR_REG = RTC_DOM; 908 rtc->rtc_dom = DS1287_DATA_REG; 909 DS1287_ADDR_REG = RTC_MON; 910 rtc->rtc_mon = DS1287_DATA_REG; 911 DS1287_ADDR_REG = RTC_YEAR; 912 rtc->rtc_year = DS1287_DATA_REG; 913 DS1287_ADDR_REG = RTC_CENTURY; 914 rtc->rtc_century = DS1287_DATA_REG; 915 916 /* Read date alarm */ 917 DS1287_ADDR_REG = RTC_ADOM; 918 rtc->rtc_adom = DS1287_DATA_REG; 919 DS1287_ADDR_REG = RTC_AMON; 920 rtc->rtc_amon = DS1287_DATA_REG; 921 922 /* Read wakeup data */ 923 select_bank(2); 924 DS1287_ADDR_REG = APC_WDWR; 925 rtc->apc_wdwr = DS1287_DATA_REG; 926 DS1287_ADDR_REG = APC_WDMR; 927 rtc->apc_wdmr = DS1287_DATA_REG; 928 DS1287_ADDR_REG = APC_WMR; 929 rtc->apc_wmr = DS1287_DATA_REG; 930 DS1287_ADDR_REG = APC_WYR; 931 rtc->apc_wyr = DS1287_DATA_REG; 932 DS1287_ADDR_REG = APC_WCR; 933 rtc->apc_wcr = DS1287_DATA_REG; 934 935 /* 936 * Unfreeze clock update 937 */ 938 DS1287_ADDR_REG = RTC_B; 939 DS1287_DATA_REG = regb; 940 941 mutex_exit(&ds1287_reg_mutex); 942 } 943 944 /* 945 * Write the specified time into the clock chip. 946 * Must be called with tod_lock held. 947 */ 948 static void 949 todds_set(timestruc_t ts) 950 { 951 struct rtc_t rtc; 952 todinfo_t tod = utc_to_tod(ts.tv_sec); 953 int year; 954 955 ASSERT(MUTEX_HELD(&tod_lock)); 956 957 /* tod_year is base 1900 so this code needs to adjust */ 958 year = 1900 + tod.tod_year; 959 rtc.rtc_year = year % 100; 960 rtc.rtc_century = year / 100; 961 rtc.rtc_mon = (uint8_t)tod.tod_month; 962 rtc.rtc_dom = (uint8_t)tod.tod_day; 963 rtc.rtc_dow = (uint8_t)tod.tod_dow; 964 rtc.rtc_hrs = (uint8_t)tod.tod_hour; 965 rtc.rtc_min = (uint8_t)tod.tod_min; 966 rtc.rtc_sec = (uint8_t)tod.tod_sec; 967 DPRINTF("todds_set: century=%d year=%d dom=%d hrs=%d\n", 968 rtc.rtc_century, rtc.rtc_year, rtc.rtc_dom, rtc.rtc_hrs); 969 970 write_rtc_time(&rtc); 971 } 972 973 void 974 write_rtc_time(struct rtc_t *rtc) 975 { 976 uint8_t regb; 977 978 /* 979 * Some SuperIO tod devices don't seem to properly initialize 980 * the CADDR register to place the Century register at bank 1 981 * address 0x48. 982 */ 983 mutex_enter(&ds1287_reg_mutex); 984 985 select_bank(2); 986 DS1287_ADDR_REG = RTC_CADDR; 987 regb = DS1287_DATA_REG; 988 if (regb != 0xc8) { 989 if (!ds1287_caddr_warn) { 990 ds1287_caddr_warn = 1; 991 cmn_err(CE_WARN, "ds1287: century address register " 992 "incorrect (exp 0xc8, obs %x)", regb); 993 } 994 DS1287_DATA_REG = 0xc8; 995 } 996 997 select_bank(1); 998 999 /* 1000 * Freeze 1001 */ 1002 DS1287_ADDR_REG = RTC_B; 1003 regb = DS1287_DATA_REG; 1004 1005 DS1287_DATA_REG = (regb | RTC_SET); 1006 1007 DS1287_ADDR_REG = RTC_SEC; 1008 DS1287_DATA_REG = rtc->rtc_sec; 1009 DS1287_ADDR_REG = RTC_MIN; 1010 DS1287_DATA_REG = rtc->rtc_min; 1011 DS1287_ADDR_REG = RTC_HRS; 1012 DS1287_DATA_REG = rtc->rtc_hrs; 1013 DS1287_ADDR_REG = RTC_DOW; 1014 DS1287_DATA_REG = rtc->rtc_dow; 1015 DS1287_ADDR_REG = RTC_DOM; 1016 DS1287_DATA_REG = rtc->rtc_dom; 1017 DS1287_ADDR_REG = RTC_MON; 1018 DS1287_DATA_REG = rtc->rtc_mon; 1019 DS1287_ADDR_REG = RTC_YEAR; 1020 DS1287_DATA_REG = rtc->rtc_year; 1021 DS1287_ADDR_REG = RTC_CENTURY; 1022 DS1287_DATA_REG = rtc->rtc_century; 1023 1024 /* 1025 * Unfreeze 1026 */ 1027 DS1287_ADDR_REG = RTC_B; 1028 DS1287_DATA_REG = regb; 1029 1030 mutex_exit(&ds1287_reg_mutex); 1031 } 1032 1033 void 1034 write_rtc_alarm(struct rtc_t *rtc) 1035 { 1036 mutex_enter(&ds1287_reg_mutex); 1037 1038 select_bank(1); 1039 DS1287_ADDR_REG = RTC_ASEC; 1040 DS1287_DATA_REG = rtc->rtc_asec; 1041 DS1287_ADDR_REG = RTC_AMIN; 1042 DS1287_DATA_REG = rtc->rtc_amin; 1043 DS1287_ADDR_REG = RTC_AHRS; 1044 DS1287_DATA_REG = rtc->rtc_ahrs; 1045 DS1287_ADDR_REG = RTC_ADOM; 1046 DS1287_DATA_REG = rtc->rtc_adom; 1047 DS1287_ADDR_REG = RTC_AMON; 1048 DS1287_DATA_REG = rtc->rtc_amon; 1049 1050 select_bank(2); 1051 DS1287_ADDR_REG = APC_WDWR; 1052 DS1287_DATA_REG = rtc->apc_wdwr; 1053 DS1287_ADDR_REG = APC_WDMR; 1054 DS1287_DATA_REG = rtc->apc_wdmr; 1055 DS1287_ADDR_REG = APC_WMR; 1056 DS1287_DATA_REG = rtc->apc_wmr; 1057 DS1287_ADDR_REG = APC_WYR; 1058 DS1287_DATA_REG = rtc->apc_wyr; 1059 DS1287_ADDR_REG = APC_WCR; 1060 DS1287_DATA_REG = rtc->apc_wcr; 1061 1062 mutex_exit(&ds1287_reg_mutex); 1063 } 1064 1065 /* 1066 * program the rtc registers for alarm to go off at the specified time 1067 */ 1068 static void 1069 todds_set_power_alarm(timestruc_t ts) 1070 { 1071 todinfo_t tod; 1072 uint8_t apcr2; 1073 struct rtc_t rtc; 1074 1075 ASSERT(MUTEX_HELD(&tod_lock)); 1076 tod = utc_to_tod(ts.tv_sec); 1077 mutex_enter(&ds1287_reg_mutex); 1078 1079 /* Clear Time Match Detect */ 1080 select_bank(2); 1081 DS1287_ADDR_REG = APC_APSR; 1082 apcr2 = DS1287_DATA_REG; 1083 1084 /* Disable Time Match Enable */ 1085 DS1287_ADDR_REG = APC_APCR2; 1086 apcr2 = DS1287_DATA_REG; 1087 DS1287_DATA_REG = (apcr2 & (~APC_TME)); 1088 1089 mutex_exit(&ds1287_reg_mutex); 1090 1091 rtc.rtc_asec = (uint8_t)tod.tod_sec; 1092 rtc.rtc_amin = (uint8_t)tod.tod_min; 1093 rtc.rtc_ahrs = (uint8_t)tod.tod_hour; 1094 rtc.rtc_adom = (uint8_t)tod.tod_day; 1095 rtc.rtc_amon = (uint8_t)tod.tod_month; 1096 1097 rtc.apc_wdwr = (uint8_t)tod.tod_dow; 1098 rtc.apc_wdmr = (uint8_t)tod.tod_day; 1099 rtc.apc_wmr = (uint8_t)tod.tod_month; 1100 rtc.apc_wyr = tod.tod_year % 100; 1101 rtc.apc_wcr = (tod.tod_year / 100) + 19; 1102 1103 write_rtc_alarm(&rtc); 1104 1105 mutex_enter(&ds1287_reg_mutex); 1106 /* Enable Time Match enable */ 1107 select_bank(2); 1108 DS1287_ADDR_REG = APC_APCR2; 1109 DS1287_DATA_REG = (apcr2 | APC_TME); 1110 1111 mutex_exit(&ds1287_reg_mutex); 1112 } 1113 1114 /* 1115 * clear alarm interrupt 1116 */ 1117 static void 1118 todds_clear_power_alarm(void) 1119 { 1120 uint8_t apcr2; 1121 1122 ASSERT(MUTEX_HELD(&tod_lock)); 1123 1124 mutex_enter(&ds1287_reg_mutex); 1125 1126 /* Clear Time Match Detect */ 1127 select_bank(2); 1128 DS1287_ADDR_REG = APC_APSR; 1129 apcr2 = DS1287_DATA_REG; 1130 1131 /* Disable Time Match Enable */ 1132 DS1287_ADDR_REG = APC_APCR2; 1133 apcr2 = DS1287_DATA_REG; 1134 DS1287_DATA_REG = (apcr2 & (~APC_TME)); 1135 1136 mutex_exit(&ds1287_reg_mutex); 1137 } 1138 1139 /* 1140 * Determine the cpu frequency by watching the TOD chip rollover twice. 1141 * Cpu clock rate is determined by computing the ticks added (in tick register) 1142 * during one second interval on TOD. 1143 */ 1144 uint64_t 1145 todds_get_cpufrequency(void) 1146 { 1147 uint64_t cpu_freq; 1148 1149 ASSERT(MUTEX_HELD(&tod_lock)); 1150 mutex_enter(&ds1287_reg_mutex); 1151 1152 select_bank(1); 1153 DS1287_ADDR_REG = RTC_SEC; 1154 cpu_freq = find_cpufrequency(v_rtc_data_reg); 1155 1156 mutex_exit(&ds1287_reg_mutex); 1157 return (cpu_freq); 1158 } 1159 1160 static void 1161 select_bank(int bank) 1162 { 1163 uint8_t rega; 1164 int banksel; 1165 1166 /* Select Bank 1 */ 1167 DS1287_ADDR_REG = RTC_A; 1168 rega = DS1287_DATA_REG; 1169 rega = rega & ~(RTC_DIV0 | RTC_DIV1 | RTC_DIV2); 1170 switch (bank) { 1171 case 0: 1172 banksel = RTC_DIV1; 1173 break; 1174 case 1: 1175 banksel = RTC_DIV0 | RTC_DIV1; 1176 break; 1177 case 2: 1178 banksel = RTC_DIV2; 1179 break; 1180 } 1181 rega |= banksel; 1182 DS1287_DATA_REG = rega; 1183 } 1184 1185 /*ARGSUSED*/ 1186 static uint_t 1187 todds_set_watchdog_timer(uint_t timeoutval) 1188 { 1189 ASSERT(MUTEX_HELD(&tod_lock)); 1190 return (0); 1191 } 1192 1193 static uint_t 1194 todds_clear_watchdog_timer(void) 1195 { 1196 ASSERT(MUTEX_HELD(&tod_lock)); 1197 return (0); 1198 } 1199