1fd358c0dSmyers /* 2fd358c0dSmyers * CDDL HEADER START 3fd358c0dSmyers * 4fd358c0dSmyers * The contents of this file are subject to the terms of the 575212827Sgk73471 * Common Development and Distribution License (the "License"). 675212827Sgk73471 * You may not use this file except in compliance with the License. 7fd358c0dSmyers * 8fd358c0dSmyers * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fd358c0dSmyers * or http://www.opensolaris.org/os/licensing. 10fd358c0dSmyers * See the License for the specific language governing permissions 11fd358c0dSmyers * and limitations under the License. 12fd358c0dSmyers * 13fd358c0dSmyers * When distributing Covered Code, include this CDDL HEADER in each 14fd358c0dSmyers * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fd358c0dSmyers * If applicable, add the following below this CDDL HEADER, with the 16fd358c0dSmyers * fields enclosed by brackets "[]" replaced with your own identifying 17fd358c0dSmyers * information: Portions Copyright [yyyy] [name of copyright owner] 18fd358c0dSmyers * 19fd358c0dSmyers * CDDL HEADER END 20fd358c0dSmyers */ 21fd358c0dSmyers /* 22d2ec54f7Sphitran * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23fd358c0dSmyers * Use is subject to license terms. 24fd358c0dSmyers */ 25fd358c0dSmyers 26fd358c0dSmyers 27fd358c0dSmyers /* 28fd358c0dSmyers * Power Button Driver 29fd358c0dSmyers * 30fd358c0dSmyers * This driver handles interrupt generated by the power button on 31fd358c0dSmyers * platforms with "power" device node which has "button" property. 32fd358c0dSmyers * Currently, these platforms are: 33fd358c0dSmyers * 34fd358c0dSmyers * ACPI-enabled x86/x64 platforms 35fd358c0dSmyers * Ultra-5_10, Ultra-80, Sun-Blade-100, Sun-Blade-150, 36fd358c0dSmyers * Sun-Blade-1500, Sun-Blade-2500, 37fd358c0dSmyers * Sun-Fire-V210, Sun-Fire-V240, Netra-240 38fd358c0dSmyers * 39fd358c0dSmyers * Only one instance is allowed to attach. In order to know when 40fd358c0dSmyers * an application that has opened the device is going away, a new 41fd358c0dSmyers * minor clone is created for each open(9E) request. There are 42fd358c0dSmyers * allocations for creating minor clones between 1 and 255. The ioctl 43fd358c0dSmyers * interface is defined by pbio(7I) and approved as part of 44fd358c0dSmyers * PSARC/1999/393 case. 45fd358c0dSmyers */ 46fd358c0dSmyers 47fd358c0dSmyers #include <sys/types.h> 48fd358c0dSmyers #include <sys/conf.h> 49fd358c0dSmyers #include <sys/ddi.h> 50fd358c0dSmyers #include <sys/sunddi.h> 51fd358c0dSmyers #include <sys/ddi_impldefs.h> 52fd358c0dSmyers #include <sys/cmn_err.h> 53fd358c0dSmyers #include <sys/errno.h> 54fd358c0dSmyers #include <sys/modctl.h> 55fd358c0dSmyers #include <sys/open.h> 56fd358c0dSmyers #include <sys/stat.h> 57fd358c0dSmyers #include <sys/poll.h> 58fd358c0dSmyers #include <sys/pbio.h> 59d2ec54f7Sphitran #include <sys/sysevent/eventdefs.h> 60d2ec54f7Sphitran #include <sys/sysevent/pwrctl.h> 61d58fda43Sjbeloro 62ae115bc7Smrj #if defined(__sparc) 63ae115bc7Smrj #include <sys/machsystm.h> 64ae115bc7Smrj #endif 65ae115bc7Smrj 66fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 67d58fda43Sjbeloro 68fd358c0dSmyers #include <sys/acpi/acpi.h> 69fd358c0dSmyers #include <sys/acpica.h> 70d58fda43Sjbeloro 71d58fda43Sjbeloro #else 72d58fda43Sjbeloro 73d58fda43Sjbeloro #include <sys/epic.h> 74d58fda43Sjbeloro /* 75d58fda43Sjbeloro * Some #defs that must be here as they differ for power.c 76d58fda43Sjbeloro * and epic.c 77d58fda43Sjbeloro */ 78d58fda43Sjbeloro #define EPIC_REGS_OFFSET 0x00 79d58fda43Sjbeloro #define EPIC_REGS_LEN 0x82 80d58fda43Sjbeloro 81d58fda43Sjbeloro 82d58fda43Sjbeloro /* 83d58fda43Sjbeloro * This flag, which is set for platforms, that have EPIC processor 84d58fda43Sjbeloro * to process power button interrupt, helps in executing platform 85d58fda43Sjbeloro * specific code. 86d58fda43Sjbeloro */ 87d58fda43Sjbeloro static char hasEPIC = B_FALSE; 88fd358c0dSmyers #endif /* ACPI_POWER_BUTTON */ 89fd358c0dSmyers 90fd358c0dSmyers /* 91fd358c0dSmyers * Maximum number of clone minors that is allowed. This value 92fd358c0dSmyers * is defined relatively low to save memory. 93fd358c0dSmyers */ 94fd358c0dSmyers #define POWER_MAX_CLONE 256 95fd358c0dSmyers 96fd358c0dSmyers /* 97fd358c0dSmyers * Minor number is instance << 8 + clone minor from range 1-255; clone 0 98fd358c0dSmyers * is reserved for "original" minor. 99fd358c0dSmyers */ 100fd358c0dSmyers #define POWER_MINOR_TO_CLONE(minor) ((minor) & (POWER_MAX_CLONE - 1)) 101fd358c0dSmyers 102fd358c0dSmyers /* 103fd358c0dSmyers * Power Button Abort Delay 104fd358c0dSmyers */ 105fd358c0dSmyers #define ABORT_INCREMENT_DELAY 10 106fd358c0dSmyers 107fd358c0dSmyers /* 1081bde0be8Sjroberts * FWARC 2005/687: power device compatible property 1091bde0be8Sjroberts */ 1101bde0be8Sjroberts #define POWER_DEVICE_TYPE "power-device-type" 1111bde0be8Sjroberts 1121bde0be8Sjroberts /* 113fd358c0dSmyers * Driver global variables 114fd358c0dSmyers */ 115fd358c0dSmyers static void *power_state; 116fd358c0dSmyers static int power_inst = -1; 117fd358c0dSmyers 118fd358c0dSmyers static hrtime_t power_button_debounce = NANOSEC/MILLISEC*10; 119fd358c0dSmyers static hrtime_t power_button_abort_interval = 1.5 * NANOSEC; 120fd358c0dSmyers static int power_button_abort_presses = 3; 121fd358c0dSmyers static int power_button_abort_enable = 1; 122fd358c0dSmyers static int power_button_enable = 1; 123fd358c0dSmyers 124fd358c0dSmyers static int power_button_pressed = 0; 125fd358c0dSmyers static int power_button_cancel = 0; 126fd358c0dSmyers static int power_button_timeouts = 0; 127fd358c0dSmyers static int timeout_cancel = 0; 128fd358c0dSmyers static int additional_presses = 0; 129fd358c0dSmyers 130fd358c0dSmyers /* 131fd358c0dSmyers * Function prototypes 132fd358c0dSmyers */ 133fd358c0dSmyers static int power_attach(dev_info_t *, ddi_attach_cmd_t); 134fd358c0dSmyers static int power_detach(dev_info_t *, ddi_detach_cmd_t); 135fd358c0dSmyers static int power_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 136fd358c0dSmyers static int power_open(dev_t *, int, int, cred_t *); 137fd358c0dSmyers static int power_close(dev_t, int, int, cred_t *); 138fd358c0dSmyers static int power_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 139fd358c0dSmyers static int power_chpoll(dev_t, short, int, short *, struct pollhead **); 140fd358c0dSmyers #ifndef ACPI_POWER_BUTTON 141fd358c0dSmyers static uint_t power_high_intr(caddr_t); 142fd358c0dSmyers #endif 143fd358c0dSmyers static uint_t power_soft_intr(caddr_t); 144fd358c0dSmyers static uint_t power_issue_shutdown(caddr_t); 145fd358c0dSmyers static void power_timeout(caddr_t); 146fd358c0dSmyers static void power_log_message(void); 147fd358c0dSmyers 148fd358c0dSmyers /* 149fd358c0dSmyers * Structure used in the driver 150fd358c0dSmyers */ 151fd358c0dSmyers struct power_soft_state { 152fd358c0dSmyers dev_info_t *dip; /* device info pointer */ 153fd358c0dSmyers kmutex_t power_mutex; /* mutex lock */ 154fd358c0dSmyers kmutex_t power_intr_mutex; /* interrupt mutex lock */ 155fd358c0dSmyers ddi_iblock_cookie_t soft_iblock_cookie; /* holds interrupt cookie */ 156fd358c0dSmyers ddi_iblock_cookie_t high_iblock_cookie; /* holds interrupt cookie */ 157fd358c0dSmyers ddi_softintr_t softintr_id; /* soft interrupt id */ 158fd358c0dSmyers uchar_t clones[POWER_MAX_CLONE]; /* array of minor clones */ 159fd358c0dSmyers int monitor_on; /* clone monitoring the button event */ 160fd358c0dSmyers /* clone 0 indicates no one is */ 161fd358c0dSmyers /* monitoring the button event */ 162fd358c0dSmyers pollhead_t pollhd; /* poll head struct */ 163fd358c0dSmyers int events; /* bit map of occured events */ 164fd358c0dSmyers int shutdown_pending; /* system shutdown in progress */ 165fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 166fd358c0dSmyers boolean_t fixed_attached; /* true means fixed is attached */ 167fd358c0dSmyers boolean_t gpe_attached; /* true means GPE is attached */ 168fd358c0dSmyers ACPI_HANDLE button_obj; /* handle to device power button */ 169fd358c0dSmyers #else 170fd358c0dSmyers ddi_acc_handle_t power_rhandle; /* power button register handle */ 171fd358c0dSmyers uint8_t *power_btn_reg; /* power button register address */ 172fd358c0dSmyers uint8_t power_btn_bit; /* power button register bit */ 173fd358c0dSmyers boolean_t power_regs_mapped; /* flag to tell if regs mapped */ 174fd358c0dSmyers boolean_t power_btn_ioctl; /* flag to specify ioctl request */ 175fd358c0dSmyers #endif 176fd358c0dSmyers }; 177fd358c0dSmyers 178d2ec54f7Sphitran static void power_gen_sysevent(struct power_soft_state *); 179d2ec54f7Sphitran 180fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 181fd358c0dSmyers static int power_attach_acpi(struct power_soft_state *softsp); 182fd358c0dSmyers static void power_detach_acpi(struct power_soft_state *softsp); 183fd358c0dSmyers static UINT32 power_acpi_fixed_event(void *ctx); 184fd358c0dSmyers #else 185fd358c0dSmyers static int power_setup_regs(struct power_soft_state *softsp); 186fd358c0dSmyers static void power_free_regs(struct power_soft_state *softsp); 187fd358c0dSmyers #endif /* ACPI_POWER_BUTTON */ 188fd358c0dSmyers 189fd358c0dSmyers /* 190fd358c0dSmyers * Configuration data structures 191fd358c0dSmyers */ 192fd358c0dSmyers static struct cb_ops power_cb_ops = { 193fd358c0dSmyers power_open, /* open */ 194fd358c0dSmyers power_close, /* close */ 195fd358c0dSmyers nodev, /* strategy */ 196fd358c0dSmyers nodev, /* print */ 197fd358c0dSmyers nodev, /* dump */ 198fd358c0dSmyers nodev, /* read */ 199fd358c0dSmyers nodev, /* write */ 200fd358c0dSmyers power_ioctl, /* ioctl */ 201fd358c0dSmyers nodev, /* devmap */ 202fd358c0dSmyers nodev, /* mmap */ 203fd358c0dSmyers nodev, /* segmap */ 204fd358c0dSmyers power_chpoll, /* poll */ 205fd358c0dSmyers ddi_prop_op, /* cb_prop_op */ 206fd358c0dSmyers NULL, /* streamtab */ 207fd358c0dSmyers D_MP | D_NEW, /* Driver compatibility flag */ 208fd358c0dSmyers CB_REV, /* rev */ 209fd358c0dSmyers nodev, /* cb_aread */ 210fd358c0dSmyers nodev /* cb_awrite */ 211fd358c0dSmyers }; 212fd358c0dSmyers 213fd358c0dSmyers static struct dev_ops power_ops = { 214fd358c0dSmyers DEVO_REV, /* devo_rev, */ 215fd358c0dSmyers 0, /* refcnt */ 216fd358c0dSmyers power_getinfo, /* getinfo */ 217fd358c0dSmyers nulldev, /* identify */ 218fd358c0dSmyers nulldev, /* probe */ 219fd358c0dSmyers power_attach, /* attach */ 220fd358c0dSmyers power_detach, /* detach */ 221fd358c0dSmyers nodev, /* reset */ 222fd358c0dSmyers &power_cb_ops, /* cb_ops */ 223fd358c0dSmyers (struct bus_ops *)NULL, /* bus_ops */ 224*19397407SSherry Moore NULL, /* power */ 225*19397407SSherry Moore ddi_quiesce_not_supported, /* devo_quiesce */ 226fd358c0dSmyers }; 227fd358c0dSmyers 228fd358c0dSmyers static struct modldrv modldrv = { 229fd358c0dSmyers &mod_driverops, /* Type of module. This one is a driver */ 230d2ec54f7Sphitran "power button driver", /* name of module */ 231fd358c0dSmyers &power_ops, /* driver ops */ 232fd358c0dSmyers }; 233fd358c0dSmyers 234fd358c0dSmyers static struct modlinkage modlinkage = { 235fd358c0dSmyers MODREV_1, 236fd358c0dSmyers (void *)&modldrv, 237fd358c0dSmyers NULL 238fd358c0dSmyers }; 239fd358c0dSmyers 240fd358c0dSmyers /* 241fd358c0dSmyers * These are the module initialization routines. 242fd358c0dSmyers */ 243fd358c0dSmyers 244fd358c0dSmyers int 245fd358c0dSmyers _init(void) 246fd358c0dSmyers { 247fd358c0dSmyers int error; 248fd358c0dSmyers 249fd358c0dSmyers if ((error = ddi_soft_state_init(&power_state, 250fd358c0dSmyers sizeof (struct power_soft_state), 0)) != 0) 251fd358c0dSmyers return (error); 252fd358c0dSmyers 253fd358c0dSmyers if ((error = mod_install(&modlinkage)) != 0) 254fd358c0dSmyers ddi_soft_state_fini(&power_state); 255fd358c0dSmyers 256fd358c0dSmyers return (error); 257fd358c0dSmyers } 258fd358c0dSmyers 259fd358c0dSmyers int 260fd358c0dSmyers _fini(void) 261fd358c0dSmyers { 262fd358c0dSmyers int error; 263fd358c0dSmyers 264fd358c0dSmyers if ((error = mod_remove(&modlinkage)) == 0) 265fd358c0dSmyers ddi_soft_state_fini(&power_state); 266fd358c0dSmyers 267fd358c0dSmyers return (error); 268fd358c0dSmyers } 269fd358c0dSmyers 270fd358c0dSmyers int 271fd358c0dSmyers _info(struct modinfo *modinfop) 272fd358c0dSmyers { 273fd358c0dSmyers return (mod_info(&modlinkage, modinfop)); 274fd358c0dSmyers } 275fd358c0dSmyers 276fd358c0dSmyers /*ARGSUSED*/ 277fd358c0dSmyers static int 278fd358c0dSmyers power_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 279fd358c0dSmyers void **result) 280fd358c0dSmyers { 281fd358c0dSmyers struct power_soft_state *softsp; 282fd358c0dSmyers 283fd358c0dSmyers if (power_inst == -1) 284fd358c0dSmyers return (DDI_FAILURE); 285fd358c0dSmyers 286fd358c0dSmyers switch (infocmd) { 287fd358c0dSmyers case DDI_INFO_DEVT2DEVINFO: 288fd358c0dSmyers if ((softsp = ddi_get_soft_state(power_state, power_inst)) 289fd358c0dSmyers == NULL) 290fd358c0dSmyers return (DDI_FAILURE); 291fd358c0dSmyers *result = (void *)softsp->dip; 292fd358c0dSmyers return (DDI_SUCCESS); 293fd358c0dSmyers 294fd358c0dSmyers case DDI_INFO_DEVT2INSTANCE: 295fd358c0dSmyers *result = (void *)(uintptr_t)power_inst; 296fd358c0dSmyers return (DDI_SUCCESS); 297fd358c0dSmyers 298fd358c0dSmyers default: 299fd358c0dSmyers return (DDI_FAILURE); 300fd358c0dSmyers } 301fd358c0dSmyers } 302fd358c0dSmyers 303fd358c0dSmyers static int 304fd358c0dSmyers power_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 305fd358c0dSmyers { 306fd358c0dSmyers struct power_soft_state *softsp; 307fd358c0dSmyers 308fd358c0dSmyers switch (cmd) { 309fd358c0dSmyers case DDI_ATTACH: 310fd358c0dSmyers break; 311fd358c0dSmyers case DDI_RESUME: 312fd358c0dSmyers return (DDI_SUCCESS); 313fd358c0dSmyers default: 314fd358c0dSmyers return (DDI_FAILURE); 315fd358c0dSmyers } 316fd358c0dSmyers 317fd358c0dSmyers /* 318fd358c0dSmyers * If the power node doesn't have "button" property, quietly 319fd358c0dSmyers * fail to attach. 320fd358c0dSmyers */ 321fd358c0dSmyers if (ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 322fd358c0dSmyers "button") == 0) 323fd358c0dSmyers return (DDI_FAILURE); 324fd358c0dSmyers 325fd358c0dSmyers if (power_inst != -1) 326fd358c0dSmyers return (DDI_FAILURE); 327fd358c0dSmyers 328fd358c0dSmyers power_inst = ddi_get_instance(dip); 329fd358c0dSmyers 330fd358c0dSmyers if (ddi_soft_state_zalloc(power_state, power_inst) != DDI_SUCCESS) 331fd358c0dSmyers return (DDI_FAILURE); 332fd358c0dSmyers 333fd358c0dSmyers if (ddi_create_minor_node(dip, "power_button", S_IFCHR, 334fd358c0dSmyers (power_inst << 8) + 0, "ddi_power_button", 0) != DDI_SUCCESS) 335fd358c0dSmyers return (DDI_FAILURE); 336fd358c0dSmyers 337fd358c0dSmyers softsp = ddi_get_soft_state(power_state, power_inst); 338fd358c0dSmyers softsp->dip = dip; 339fd358c0dSmyers 340fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 3419f43a0a2Smyers (void) power_attach_acpi(softsp); 342fd358c0dSmyers #else 343fd358c0dSmyers if (power_setup_regs(softsp) != DDI_SUCCESS) { 344fd358c0dSmyers cmn_err(CE_WARN, "power_attach: failed to setup registers"); 345fd358c0dSmyers goto error; 346fd358c0dSmyers } 347fd358c0dSmyers 348fd358c0dSmyers if (ddi_get_iblock_cookie(dip, 0, 349fd358c0dSmyers &softsp->high_iblock_cookie) != DDI_SUCCESS) { 350fd358c0dSmyers cmn_err(CE_WARN, "power_attach: ddi_get_soft_iblock_cookie " 351fd358c0dSmyers "failed."); 352fd358c0dSmyers goto error; 353fd358c0dSmyers } 354fd358c0dSmyers mutex_init(&softsp->power_intr_mutex, NULL, MUTEX_DRIVER, 355fd358c0dSmyers softsp->high_iblock_cookie); 356fd358c0dSmyers 357fd358c0dSmyers if (ddi_add_intr(dip, 0, &softsp->high_iblock_cookie, NULL, 358fd358c0dSmyers power_high_intr, (caddr_t)softsp) != DDI_SUCCESS) { 359fd358c0dSmyers cmn_err(CE_WARN, "power_attach: failed to add high-level " 360fd358c0dSmyers " interrupt handler."); 361fd358c0dSmyers mutex_destroy(&softsp->power_intr_mutex); 362fd358c0dSmyers goto error; 363fd358c0dSmyers } 364fd358c0dSmyers #endif /* ACPI_POWER_BUTTON */ 365fd358c0dSmyers 366fd358c0dSmyers if (ddi_get_soft_iblock_cookie(dip, DDI_SOFTINT_LOW, 367fd358c0dSmyers &softsp->soft_iblock_cookie) != DDI_SUCCESS) { 368fd358c0dSmyers cmn_err(CE_WARN, "power_attach: ddi_get_soft_iblock_cookie " 369fd358c0dSmyers "failed."); 370fd358c0dSmyers mutex_destroy(&softsp->power_intr_mutex); 371fd358c0dSmyers ddi_remove_intr(dip, 0, NULL); 372fd358c0dSmyers goto error; 373fd358c0dSmyers } 374fd358c0dSmyers 375fd358c0dSmyers mutex_init(&softsp->power_mutex, NULL, MUTEX_DRIVER, 376fd358c0dSmyers (void *)softsp->soft_iblock_cookie); 377fd358c0dSmyers 378fd358c0dSmyers if (ddi_add_softintr(dip, DDI_SOFTINT_LOW, &softsp->softintr_id, 379fd358c0dSmyers NULL, NULL, power_soft_intr, (caddr_t)softsp) != DDI_SUCCESS) { 380fd358c0dSmyers cmn_err(CE_WARN, "power_attach: failed to add soft " 381fd358c0dSmyers "interrupt handler."); 382fd358c0dSmyers mutex_destroy(&softsp->power_mutex); 383fd358c0dSmyers mutex_destroy(&softsp->power_intr_mutex); 384fd358c0dSmyers ddi_remove_intr(dip, 0, NULL); 385fd358c0dSmyers goto error; 386fd358c0dSmyers } 387fd358c0dSmyers 388fd358c0dSmyers ddi_report_dev(dip); 389fd358c0dSmyers 390fd358c0dSmyers return (DDI_SUCCESS); 391fd358c0dSmyers 392fd358c0dSmyers error: 393fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 394fd358c0dSmyers /* 395fd358c0dSmyers * detach ACPI power button 396fd358c0dSmyers */ 397fd358c0dSmyers power_detach_acpi(softsp); 398fd358c0dSmyers #else 399fd358c0dSmyers power_free_regs(softsp); 400fd358c0dSmyers #endif /* ACPI_POWER_BUTTON */ 401fd358c0dSmyers ddi_remove_minor_node(dip, "power_button"); 402fd358c0dSmyers ddi_soft_state_free(power_state, power_inst); 403fd358c0dSmyers return (DDI_FAILURE); 404fd358c0dSmyers } 405fd358c0dSmyers 406fd358c0dSmyers /*ARGSUSED*/ 407fd358c0dSmyers /* 408fd358c0dSmyers * This driver doesn't detach. 409fd358c0dSmyers */ 410fd358c0dSmyers static int 411fd358c0dSmyers power_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 412fd358c0dSmyers { 413fd358c0dSmyers /* 414fd358c0dSmyers * Since the "power" node has "reg" property, as part of 415fd358c0dSmyers * the suspend operation, detach(9E) entry point is called. 416fd358c0dSmyers * There is no state to save, since this register is used 417fd358c0dSmyers * by OBP to power off the system and the state of the 418fd358c0dSmyers * power off is preserved by hardware. 419fd358c0dSmyers */ 420fd358c0dSmyers return ((cmd == DDI_SUSPEND) ? DDI_SUCCESS : 421fd358c0dSmyers DDI_FAILURE); 422fd358c0dSmyers } 423fd358c0dSmyers 424d58fda43Sjbeloro 425fd358c0dSmyers #ifndef ACPI_POWER_BUTTON 426fd358c0dSmyers /* 427fd358c0dSmyers * Handler for the high-level interrupt. 428fd358c0dSmyers */ 429fd358c0dSmyers static uint_t 430fd358c0dSmyers power_high_intr(caddr_t arg) 431fd358c0dSmyers { 432fd358c0dSmyers struct power_soft_state *softsp = (struct power_soft_state *)arg; 433fd358c0dSmyers ddi_acc_handle_t hdl = softsp->power_rhandle; 434fd358c0dSmyers uint8_t reg; 435fd358c0dSmyers 436fd358c0dSmyers hrtime_t tstamp; 437fd358c0dSmyers static hrtime_t o_tstamp = 0; 438fd358c0dSmyers static hrtime_t power_button_tstamp = 0; 439fd358c0dSmyers static int power_button_cnt; 440fd358c0dSmyers 441fd358c0dSmyers if (softsp->power_regs_mapped) { 442fd358c0dSmyers mutex_enter(&softsp->power_intr_mutex); 443d58fda43Sjbeloro 444d58fda43Sjbeloro /* Check if power button interrupt is delivered by EPIC HW */ 445d58fda43Sjbeloro if (hasEPIC) { 446d58fda43Sjbeloro /* read isr - first issue command */ 447d58fda43Sjbeloro EPIC_WR(hdl, softsp->power_btn_reg, 448d58fda43Sjbeloro EPIC_ATOM_INTR_READ); 449d58fda43Sjbeloro /* next, read the reg */ 450d58fda43Sjbeloro EPIC_RD(hdl, softsp->power_btn_reg, reg); 451d58fda43Sjbeloro 452d58fda43Sjbeloro if (reg & EPIC_FIRE_INTERRUPT) { /* PB pressed */ 453d58fda43Sjbeloro /* clear the interrupt */ 454d58fda43Sjbeloro EPIC_WR(hdl, softsp->power_btn_reg, 455d58fda43Sjbeloro EPIC_ATOM_INTR_CLEAR); 456d58fda43Sjbeloro } else { 457d58fda43Sjbeloro if (!softsp->power_btn_ioctl) { 458d58fda43Sjbeloro mutex_exit(&softsp->power_intr_mutex); 459d58fda43Sjbeloro return (DDI_INTR_CLAIMED); 460d58fda43Sjbeloro } 461d58fda43Sjbeloro softsp->power_btn_ioctl = B_FALSE; 462d58fda43Sjbeloro } 463d58fda43Sjbeloro } else { 464fd358c0dSmyers reg = ddi_get8(hdl, softsp->power_btn_reg); 465fd358c0dSmyers if (reg & softsp->power_btn_bit) { 466fd358c0dSmyers reg &= softsp->power_btn_bit; 467fd358c0dSmyers ddi_put8(hdl, softsp->power_btn_reg, reg); 468fd358c0dSmyers (void) ddi_get8(hdl, softsp->power_btn_reg); 469fd358c0dSmyers } else { 470fd358c0dSmyers if (!softsp->power_btn_ioctl) { 471fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 472fd358c0dSmyers return (DDI_INTR_CLAIMED); 473fd358c0dSmyers } 474fd358c0dSmyers softsp->power_btn_ioctl = B_FALSE; 475fd358c0dSmyers } 476d58fda43Sjbeloro } 477fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 478fd358c0dSmyers } 479fd358c0dSmyers 480fd358c0dSmyers tstamp = gethrtime(); 481fd358c0dSmyers 482fd358c0dSmyers /* need to deal with power button debounce */ 483fd358c0dSmyers if (o_tstamp && (tstamp - o_tstamp) < power_button_debounce) { 484fd358c0dSmyers o_tstamp = tstamp; 485fd358c0dSmyers return (DDI_INTR_CLAIMED); 486fd358c0dSmyers } 487fd358c0dSmyers o_tstamp = tstamp; 488fd358c0dSmyers 489fd358c0dSmyers power_button_cnt++; 490fd358c0dSmyers 491fd358c0dSmyers mutex_enter(&softsp->power_intr_mutex); 492fd358c0dSmyers power_button_pressed++; 493fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 494fd358c0dSmyers 495fd358c0dSmyers /* 496fd358c0dSmyers * If power button abort is enabled and power button was pressed 497fd358c0dSmyers * power_button_abort_presses times within power_button_abort_interval 498fd358c0dSmyers * then call abort_sequence_enter(); 499fd358c0dSmyers */ 500fd358c0dSmyers if (power_button_abort_enable) { 501fd358c0dSmyers if (power_button_abort_presses == 1 || 502fd358c0dSmyers tstamp < (power_button_tstamp + 503fd358c0dSmyers power_button_abort_interval)) { 504fd358c0dSmyers if (power_button_cnt == power_button_abort_presses) { 505fd358c0dSmyers mutex_enter(&softsp->power_intr_mutex); 506fd358c0dSmyers power_button_cancel += power_button_timeouts; 507fd358c0dSmyers power_button_pressed = 0; 508fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 509fd358c0dSmyers power_button_cnt = 0; 510fd358c0dSmyers abort_sequence_enter("Power Button Abort"); 511fd358c0dSmyers return (DDI_INTR_CLAIMED); 512fd358c0dSmyers } 513fd358c0dSmyers } else { 514fd358c0dSmyers power_button_cnt = 1; 515fd358c0dSmyers power_button_tstamp = tstamp; 516fd358c0dSmyers } 517fd358c0dSmyers } 518fd358c0dSmyers 519fd358c0dSmyers if (!power_button_enable) 520fd358c0dSmyers return (DDI_INTR_CLAIMED); 521fd358c0dSmyers 522fd358c0dSmyers /* post softint to issue timeout for power button action */ 523fd358c0dSmyers if (softsp->softintr_id != NULL) 524fd358c0dSmyers ddi_trigger_softintr(softsp->softintr_id); 525fd358c0dSmyers 526fd358c0dSmyers return (DDI_INTR_CLAIMED); 527fd358c0dSmyers } 528fd358c0dSmyers #endif /* ifndef ACPI_POWER_BUTTON */ 529fd358c0dSmyers 530fd358c0dSmyers /* 531fd358c0dSmyers * Handle the softints.... 532fd358c0dSmyers * 533fd358c0dSmyers * If only one softint is posted for several button presses, record 534fd358c0dSmyers * the number of additional presses just incase this was actually not quite 535fd358c0dSmyers * an Abort sequence so that we can log this event later. 536fd358c0dSmyers * 537fd358c0dSmyers * Issue a timeout with a duration being a fraction larger than 538fd358c0dSmyers * the specified Abort interval inorder to perform a power down if required. 539fd358c0dSmyers */ 540fd358c0dSmyers static uint_t 541fd358c0dSmyers power_soft_intr(caddr_t arg) 542fd358c0dSmyers { 543fd358c0dSmyers struct power_soft_state *softsp = (struct power_soft_state *)arg; 544fd358c0dSmyers 545fd358c0dSmyers if (!power_button_abort_enable) 546fd358c0dSmyers return (power_issue_shutdown(arg)); 547fd358c0dSmyers 548fd358c0dSmyers mutex_enter(&softsp->power_intr_mutex); 549fd358c0dSmyers if (!power_button_pressed) { 550fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 551fd358c0dSmyers return (DDI_INTR_CLAIMED); 552fd358c0dSmyers } 553fd358c0dSmyers 554fd358c0dSmyers /* 555fd358c0dSmyers * Schedule a timeout to do the necessary 556fd358c0dSmyers * work for shutdown, only one timeout for 557fd358c0dSmyers * n presses if power button was pressed 558fd358c0dSmyers * more than once before softint fired 559fd358c0dSmyers */ 560fd358c0dSmyers if (power_button_pressed > 1) 561fd358c0dSmyers additional_presses += power_button_pressed - 1; 562fd358c0dSmyers 563fd358c0dSmyers timeout_cancel = 0; 564fd358c0dSmyers power_button_pressed = 0; 565fd358c0dSmyers power_button_timeouts++; 566fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 567fd358c0dSmyers (void) timeout((void(*)(void *))power_timeout, 568fd358c0dSmyers softsp, NSEC_TO_TICK(power_button_abort_interval) + 569fd358c0dSmyers ABORT_INCREMENT_DELAY); 570fd358c0dSmyers 571fd358c0dSmyers return (DDI_INTR_CLAIMED); 572fd358c0dSmyers } 573fd358c0dSmyers 574fd358c0dSmyers /* 575fd358c0dSmyers * Upon receiving a timeout the following is determined: 576fd358c0dSmyers * 577fd358c0dSmyers * If an Abort sequence was issued, then we cancel all outstanding timeouts 578fd358c0dSmyers * and additional presses prior to the Abort sequence. 579fd358c0dSmyers * 580fd358c0dSmyers * If we had multiple timeouts issued and the abort sequence was not met, 581fd358c0dSmyers * then we had more than one button press to power down the machine. We 582fd358c0dSmyers * were probably trying to issue an abort. So log a message indicating this 583fd358c0dSmyers * and cancel all outstanding timeouts. 584fd358c0dSmyers * 585fd358c0dSmyers * If we had just one timeout and the abort sequence was not met then 586fd358c0dSmyers * we really did want to power down the machine, so call power_issue_shutdown() 587fd358c0dSmyers * to do the work and schedule a power down 588fd358c0dSmyers */ 589fd358c0dSmyers static void 590fd358c0dSmyers power_timeout(caddr_t arg) 591fd358c0dSmyers { 592fd358c0dSmyers struct power_soft_state *softsp = (struct power_soft_state *)arg; 593fd358c0dSmyers static int first = 0; 594fd358c0dSmyers 595fd358c0dSmyers /* 596fd358c0dSmyers * Abort was generated cancel all outstanding power 597fd358c0dSmyers * button timeouts 598fd358c0dSmyers */ 599fd358c0dSmyers mutex_enter(&softsp->power_intr_mutex); 600fd358c0dSmyers if (power_button_cancel) { 601fd358c0dSmyers power_button_cancel--; 602fd358c0dSmyers power_button_timeouts--; 603fd358c0dSmyers if (!first) { 604fd358c0dSmyers first++; 605fd358c0dSmyers additional_presses = 0; 606fd358c0dSmyers } 607fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 608fd358c0dSmyers return; 609fd358c0dSmyers } 610fd358c0dSmyers first = 0; 611fd358c0dSmyers 612fd358c0dSmyers /* 613fd358c0dSmyers * We get here if the timeout(s) have fired and they were 614fd358c0dSmyers * not issued prior to an abort. 615fd358c0dSmyers * 616fd358c0dSmyers * If we had more than one press in the interval we were 617fd358c0dSmyers * probably trying to issue an abort, but didnt press the 618fd358c0dSmyers * required number within the interval. Hence cancel all 619fd358c0dSmyers * timeouts and do not continue towards shutdown. 620fd358c0dSmyers */ 621fd358c0dSmyers if (!timeout_cancel) { 622fd358c0dSmyers timeout_cancel = power_button_timeouts + 623fd358c0dSmyers additional_presses; 624fd358c0dSmyers 625fd358c0dSmyers power_button_timeouts--; 626fd358c0dSmyers if (!power_button_timeouts) 627fd358c0dSmyers additional_presses = 0; 628fd358c0dSmyers 629fd358c0dSmyers if (timeout_cancel > 1) { 630fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 631fd358c0dSmyers cmn_err(CE_NOTE, "Power Button pressed " 632fd358c0dSmyers "%d times, cancelling all requests", 633fd358c0dSmyers timeout_cancel); 634fd358c0dSmyers return; 635fd358c0dSmyers } 636fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 637fd358c0dSmyers 638fd358c0dSmyers /* Go and do the work to request shutdown */ 639fd358c0dSmyers (void) power_issue_shutdown((caddr_t)softsp); 640fd358c0dSmyers return; 641fd358c0dSmyers } 642fd358c0dSmyers 643fd358c0dSmyers power_button_timeouts--; 644fd358c0dSmyers if (!power_button_timeouts) 645fd358c0dSmyers additional_presses = 0; 646fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 647fd358c0dSmyers } 648fd358c0dSmyers 649fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 650fd358c0dSmyers static void 651fd358c0dSmyers do_shutdown(void) 652fd358c0dSmyers { 653fd358c0dSmyers proc_t *initpp; 654fd358c0dSmyers 655fd358c0dSmyers /* 656fd358c0dSmyers * If we're still booting and init(1) isn't set up yet, simply halt. 657fd358c0dSmyers */ 658fd358c0dSmyers mutex_enter(&pidlock); 659fd358c0dSmyers initpp = prfind(P_INITPID); 660fd358c0dSmyers mutex_exit(&pidlock); 661fd358c0dSmyers if (initpp == NULL) { 662fd358c0dSmyers extern void halt(char *); 663fd358c0dSmyers halt("Power off the System"); /* just in case */ 664fd358c0dSmyers } 665fd358c0dSmyers 666fd358c0dSmyers /* 667fd358c0dSmyers * else, graceful shutdown with inittab and all getting involved 668fd358c0dSmyers */ 669fd358c0dSmyers psignal(initpp, SIGPWR); 670fd358c0dSmyers } 671fd358c0dSmyers #endif 672fd358c0dSmyers 673fd358c0dSmyers static uint_t 674fd358c0dSmyers power_issue_shutdown(caddr_t arg) 675fd358c0dSmyers { 676fd358c0dSmyers struct power_soft_state *softsp = (struct power_soft_state *)arg; 677fd358c0dSmyers 678fd358c0dSmyers mutex_enter(&softsp->power_mutex); 679fd358c0dSmyers softsp->events |= PB_BUTTON_PRESS; 680fd358c0dSmyers if (softsp->monitor_on != 0) { 681fd358c0dSmyers mutex_exit(&softsp->power_mutex); 682fd358c0dSmyers pollwakeup(&softsp->pollhd, POLLRDNORM); 683fd358c0dSmyers pollwakeup(&softsp->pollhd, POLLIN); 684d2ec54f7Sphitran power_gen_sysevent(softsp); 685fd358c0dSmyers return (DDI_INTR_CLAIMED); 686fd358c0dSmyers } 687fd358c0dSmyers 688fd358c0dSmyers if (!softsp->shutdown_pending) { 689fd358c0dSmyers cmn_err(CE_WARN, "Power off requested from power button or " 690fd358c0dSmyers "SC, powering down the system!"); 691fd358c0dSmyers softsp->shutdown_pending = 1; 692fd358c0dSmyers do_shutdown(); 693fd358c0dSmyers 694fd358c0dSmyers /* 695fd358c0dSmyers * Wait a while for "do_shutdown()" to shut down the system 696fd358c0dSmyers * before logging an error message. 697fd358c0dSmyers */ 698fd358c0dSmyers (void) timeout((void(*)(void *))power_log_message, NULL, 699fd358c0dSmyers 100 * hz); 700fd358c0dSmyers } 701fd358c0dSmyers mutex_exit(&softsp->power_mutex); 702fd358c0dSmyers 703fd358c0dSmyers return (DDI_INTR_CLAIMED); 704fd358c0dSmyers } 705fd358c0dSmyers 706d2ec54f7Sphitran static void 707d2ec54f7Sphitran power_gen_sysevent(struct power_soft_state *softsp) 708d2ec54f7Sphitran { 709d2ec54f7Sphitran nvlist_t *attr_list = NULL; 710d2ec54f7Sphitran int err; 711d2ec54f7Sphitran char pathname[MAXPATHLEN]; 712d2ec54f7Sphitran char hid[9] = "\0"; 713d2ec54f7Sphitran 714d2ec54f7Sphitran /* Allocate and build sysevent attribute list */ 715d2ec54f7Sphitran err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 716d2ec54f7Sphitran if (err != 0) { 717d2ec54f7Sphitran cmn_err(CE_WARN, 718d2ec54f7Sphitran "cannot allocate memory for sysevent attributes\n"); 719d2ec54f7Sphitran return; 720d2ec54f7Sphitran } 721d2ec54f7Sphitran 722d2ec54f7Sphitran #ifdef ACPI_POWER_BUTTON 723d2ec54f7Sphitran /* Only control method power button has HID */ 724d2ec54f7Sphitran if (softsp->gpe_attached) { 725d2ec54f7Sphitran (void) strlcpy(hid, "PNP0C0C", sizeof (hid)); 726d2ec54f7Sphitran } 727d2ec54f7Sphitran #endif 728d2ec54f7Sphitran 729d2ec54f7Sphitran err = nvlist_add_string(attr_list, PWRCTL_DEV_HID, hid); 730d2ec54f7Sphitran if (err != 0) { 731d2ec54f7Sphitran cmn_err(CE_WARN, 732d2ec54f7Sphitran "Failed to add attr [%s] for %s/%s event", 733d2ec54f7Sphitran PWRCTL_DEV_HID, EC_PWRCTL, ESC_PWRCTL_POWER_BUTTON); 734d2ec54f7Sphitran nvlist_free(attr_list); 735d2ec54f7Sphitran return; 736d2ec54f7Sphitran } 737d2ec54f7Sphitran 738d2ec54f7Sphitran (void) ddi_pathname(softsp->dip, pathname); 739d2ec54f7Sphitran err = nvlist_add_string(attr_list, PWRCTL_DEV_PHYS_PATH, pathname); 740d2ec54f7Sphitran if (err != 0) { 741d2ec54f7Sphitran cmn_err(CE_WARN, 742d2ec54f7Sphitran "Failed to add attr [%s] for %s/%s event", 743d2ec54f7Sphitran PWRCTL_DEV_PHYS_PATH, EC_PWRCTL, ESC_PWRCTL_POWER_BUTTON); 744d2ec54f7Sphitran nvlist_free(attr_list); 745d2ec54f7Sphitran return; 746d2ec54f7Sphitran } 747d2ec54f7Sphitran 748d2ec54f7Sphitran /* Generate/log sysevent */ 749d2ec54f7Sphitran err = ddi_log_sysevent(softsp->dip, DDI_VENDOR_SUNW, EC_PWRCTL, 750d2ec54f7Sphitran ESC_PWRCTL_POWER_BUTTON, attr_list, NULL, DDI_NOSLEEP); 751d2ec54f7Sphitran if (err != DDI_SUCCESS) { 752d2ec54f7Sphitran cmn_err(CE_WARN, 753d2ec54f7Sphitran "cannot log sysevent, err code %x\n", err); 754d2ec54f7Sphitran } 755d2ec54f7Sphitran 756d2ec54f7Sphitran nvlist_free(attr_list); 757d2ec54f7Sphitran } 758d2ec54f7Sphitran 759fd358c0dSmyers /* 760fd358c0dSmyers * Open the device. 761fd358c0dSmyers */ 762fd358c0dSmyers /*ARGSUSED*/ 763fd358c0dSmyers static int 764fd358c0dSmyers power_open(dev_t *devp, int openflags, int otyp, cred_t *credp) 765fd358c0dSmyers { 766fd358c0dSmyers struct power_soft_state *softsp; 767fd358c0dSmyers int clone; 768fd358c0dSmyers 769fd358c0dSmyers if (otyp != OTYP_CHR) 770fd358c0dSmyers return (EINVAL); 771fd358c0dSmyers 772fd358c0dSmyers if ((softsp = ddi_get_soft_state(power_state, power_inst)) == 773fd358c0dSmyers NULL) 774fd358c0dSmyers return (ENXIO); 775fd358c0dSmyers 776fd358c0dSmyers mutex_enter(&softsp->power_mutex); 777fd358c0dSmyers for (clone = 1; clone < POWER_MAX_CLONE; clone++) 778fd358c0dSmyers if (!softsp->clones[clone]) 779fd358c0dSmyers break; 780fd358c0dSmyers 781fd358c0dSmyers if (clone == POWER_MAX_CLONE) { 782fd358c0dSmyers cmn_err(CE_WARN, "power_open: No more allocation left " 783fd358c0dSmyers "to create a clone minor."); 784fd358c0dSmyers mutex_exit(&softsp->power_mutex); 785fd358c0dSmyers return (ENXIO); 786fd358c0dSmyers } 787fd358c0dSmyers 788fd358c0dSmyers *devp = makedevice(getmajor(*devp), (power_inst << 8) + clone); 789fd358c0dSmyers softsp->clones[clone] = 1; 790fd358c0dSmyers mutex_exit(&softsp->power_mutex); 791fd358c0dSmyers 792fd358c0dSmyers return (0); 793fd358c0dSmyers } 794fd358c0dSmyers 795fd358c0dSmyers /* 796fd358c0dSmyers * Close the device. 797fd358c0dSmyers */ 798fd358c0dSmyers /*ARGSUSED*/ 799fd358c0dSmyers static int 800fd358c0dSmyers power_close(dev_t dev, int openflags, int otyp, cred_t *credp) 801fd358c0dSmyers { 802fd358c0dSmyers struct power_soft_state *softsp; 803fd358c0dSmyers int clone; 804fd358c0dSmyers 805fd358c0dSmyers if (otyp != OTYP_CHR) 806fd358c0dSmyers return (EINVAL); 807fd358c0dSmyers 808fd358c0dSmyers if ((softsp = ddi_get_soft_state(power_state, power_inst)) == 809fd358c0dSmyers NULL) 810fd358c0dSmyers return (ENXIO); 811fd358c0dSmyers 812fd358c0dSmyers clone = POWER_MINOR_TO_CLONE(getminor(dev)); 813fd358c0dSmyers mutex_enter(&softsp->power_mutex); 814fd358c0dSmyers if (softsp->monitor_on == clone) 815fd358c0dSmyers softsp->monitor_on = 0; 816fd358c0dSmyers softsp->clones[clone] = 0; 817fd358c0dSmyers mutex_exit(&softsp->power_mutex); 818fd358c0dSmyers 819fd358c0dSmyers return (0); 820fd358c0dSmyers } 821fd358c0dSmyers 822fd358c0dSmyers /*ARGSUSED*/ 823fd358c0dSmyers static int 824fd358c0dSmyers power_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred_p, 825fd358c0dSmyers int *rval_p) 826fd358c0dSmyers { 827fd358c0dSmyers struct power_soft_state *softsp; 828fd358c0dSmyers int clone; 829fd358c0dSmyers 830fd358c0dSmyers if ((softsp = ddi_get_soft_state(power_state, power_inst)) == 831fd358c0dSmyers NULL) 832fd358c0dSmyers return (ENXIO); 833fd358c0dSmyers 834fd358c0dSmyers clone = POWER_MINOR_TO_CLONE(getminor(dev)); 835fd358c0dSmyers switch (cmd) { 836fd358c0dSmyers case PB_BEGIN_MONITOR: 837fd358c0dSmyers mutex_enter(&softsp->power_mutex); 838fd358c0dSmyers if (softsp->monitor_on) { 839fd358c0dSmyers mutex_exit(&softsp->power_mutex); 840fd358c0dSmyers return (EBUSY); 841fd358c0dSmyers } 842fd358c0dSmyers softsp->monitor_on = clone; 843fd358c0dSmyers mutex_exit(&softsp->power_mutex); 844fd358c0dSmyers return (0); 845fd358c0dSmyers 846fd358c0dSmyers case PB_END_MONITOR: 847fd358c0dSmyers mutex_enter(&softsp->power_mutex); 848fd358c0dSmyers 849fd358c0dSmyers /* 850fd358c0dSmyers * If PB_END_MONITOR is called without first 851fd358c0dSmyers * calling PB_BEGIN_MONITOR, an error will be 852fd358c0dSmyers * returned. 853fd358c0dSmyers */ 854fd358c0dSmyers if (!softsp->monitor_on) { 855fd358c0dSmyers mutex_exit(&softsp->power_mutex); 856fd358c0dSmyers return (ENXIO); 857fd358c0dSmyers } 858fd358c0dSmyers 859fd358c0dSmyers /* 860fd358c0dSmyers * This clone is not monitoring the button. 861fd358c0dSmyers */ 862fd358c0dSmyers if (softsp->monitor_on != clone) { 863fd358c0dSmyers mutex_exit(&softsp->power_mutex); 864fd358c0dSmyers return (EINVAL); 865fd358c0dSmyers } 866fd358c0dSmyers softsp->monitor_on = 0; 867fd358c0dSmyers mutex_exit(&softsp->power_mutex); 868fd358c0dSmyers return (0); 869fd358c0dSmyers 870fd358c0dSmyers case PB_GET_EVENTS: 871fd358c0dSmyers mutex_enter(&softsp->power_mutex); 872fd358c0dSmyers if (ddi_copyout((void *)&softsp->events, (void *)arg, 873fd358c0dSmyers sizeof (int), mode) != 0) { 874fd358c0dSmyers mutex_exit(&softsp->power_mutex); 875fd358c0dSmyers return (EFAULT); 876fd358c0dSmyers } 877fd358c0dSmyers 878fd358c0dSmyers /* 879fd358c0dSmyers * This ioctl returned the events detected since last 880fd358c0dSmyers * call. Note that any application can get the events 881fd358c0dSmyers * and clear the event register. 882fd358c0dSmyers */ 883fd358c0dSmyers softsp->events = 0; 884fd358c0dSmyers mutex_exit(&softsp->power_mutex); 885fd358c0dSmyers return (0); 886fd358c0dSmyers 887fd358c0dSmyers /* 888fd358c0dSmyers * This ioctl is used by the test suite. 889fd358c0dSmyers */ 890fd358c0dSmyers case PB_CREATE_BUTTON_EVENT: 891fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 892fd358c0dSmyers (UINT32)power_acpi_fixed_event((void *)softsp); 893fd358c0dSmyers #else 894fd358c0dSmyers if (softsp->power_regs_mapped) { 895fd358c0dSmyers mutex_enter(&softsp->power_intr_mutex); 896fd358c0dSmyers softsp->power_btn_ioctl = B_TRUE; 897fd358c0dSmyers mutex_exit(&softsp->power_intr_mutex); 898fd358c0dSmyers } 899fd358c0dSmyers (void) power_high_intr((caddr_t)softsp); 900fd358c0dSmyers #endif /* ACPI_POWER_BUTTON */ 901fd358c0dSmyers return (0); 902fd358c0dSmyers 903fd358c0dSmyers default: 904fd358c0dSmyers return (ENOTTY); 905fd358c0dSmyers } 906fd358c0dSmyers } 907fd358c0dSmyers 908fd358c0dSmyers /*ARGSUSED*/ 909fd358c0dSmyers static int 910fd358c0dSmyers power_chpoll(dev_t dev, short events, int anyyet, 911fd358c0dSmyers short *reventsp, struct pollhead **phpp) 912fd358c0dSmyers { 913fd358c0dSmyers struct power_soft_state *softsp; 914fd358c0dSmyers 915fd358c0dSmyers if ((softsp = ddi_get_soft_state(power_state, power_inst)) == NULL) 916fd358c0dSmyers return (ENXIO); 917fd358c0dSmyers 918fd358c0dSmyers mutex_enter(&softsp->power_mutex); 919fd358c0dSmyers *reventsp = 0; 920fd358c0dSmyers if (softsp->events) 921fd358c0dSmyers *reventsp = POLLRDNORM|POLLIN; 922fd358c0dSmyers else { 923fd358c0dSmyers if (!anyyet) 924fd358c0dSmyers *phpp = &softsp->pollhd; 925fd358c0dSmyers } 926fd358c0dSmyers mutex_exit(&softsp->power_mutex); 927fd358c0dSmyers 928fd358c0dSmyers return (0); 929fd358c0dSmyers } 930fd358c0dSmyers 931fd358c0dSmyers static void 932fd358c0dSmyers power_log_message(void) 933fd358c0dSmyers { 934fd358c0dSmyers struct power_soft_state *softsp; 935fd358c0dSmyers 936fd358c0dSmyers if ((softsp = ddi_get_soft_state(power_state, power_inst)) == NULL) { 937fd358c0dSmyers cmn_err(CE_WARN, "Failed to get internal state!"); 938fd358c0dSmyers return; 939fd358c0dSmyers } 940fd358c0dSmyers 941fd358c0dSmyers mutex_enter(&softsp->power_mutex); 942fd358c0dSmyers softsp->shutdown_pending = 0; 943fd358c0dSmyers cmn_err(CE_WARN, "Failed to shut down the system!"); 944fd358c0dSmyers mutex_exit(&softsp->power_mutex); 945fd358c0dSmyers } 946fd358c0dSmyers 947fd358c0dSmyers #ifdef ACPI_POWER_BUTTON 948fd358c0dSmyers /* 949fd358c0dSmyers * Given a handle to a device object, locate a _PRW object 950fd358c0dSmyers * if present and fetch the GPE info for this device object 951fd358c0dSmyers */ 952fd358c0dSmyers static ACPI_STATUS 953fd358c0dSmyers power_get_prw_gpe(ACPI_HANDLE dev, ACPI_HANDLE *gpe_dev, UINT32 *gpe_num) 954fd358c0dSmyers { 955fd358c0dSmyers ACPI_BUFFER buf; 956fd358c0dSmyers ACPI_STATUS status; 957fd358c0dSmyers ACPI_HANDLE prw; 958fd358c0dSmyers ACPI_OBJECT *gpe; 959fd358c0dSmyers 960fd358c0dSmyers /* 961fd358c0dSmyers * Evaluate _PRW if present 962fd358c0dSmyers */ 963fd358c0dSmyers status = AcpiGetHandle(dev, "_PRW", &prw); 964fd358c0dSmyers if (status != AE_OK) 965fd358c0dSmyers return (status); 966fd358c0dSmyers buf.Length = ACPI_ALLOCATE_BUFFER; 967fd358c0dSmyers status = AcpiEvaluateObjectTyped(prw, NULL, NULL, &buf, 968fd358c0dSmyers ACPI_TYPE_PACKAGE); 969fd358c0dSmyers if (status != AE_OK) 970fd358c0dSmyers return (status); 971fd358c0dSmyers 972fd358c0dSmyers /* 973fd358c0dSmyers * Sanity-check the package; need at least two elements 974fd358c0dSmyers */ 975fd358c0dSmyers status = AE_ERROR; 976fd358c0dSmyers if (((ACPI_OBJECT *)buf.Pointer)->Package.Count < 2) 977fd358c0dSmyers goto done; 978fd358c0dSmyers 979fd358c0dSmyers gpe = &((ACPI_OBJECT *)buf.Pointer)->Package.Elements[0]; 980fd358c0dSmyers if (gpe->Type == ACPI_TYPE_INTEGER) { 981fd358c0dSmyers *gpe_dev = NULL; 982fd358c0dSmyers *gpe_num = gpe->Integer.Value; 983fd358c0dSmyers status = AE_OK; 984fd358c0dSmyers } else if (gpe->Type == ACPI_TYPE_PACKAGE) { 985fd358c0dSmyers if ((gpe->Package.Count != 2) || 986fd358c0dSmyers (gpe->Package.Elements[0].Type != ACPI_TYPE_DEVICE) || 987fd358c0dSmyers (gpe->Package.Elements[1].Type != ACPI_TYPE_INTEGER)) 988fd358c0dSmyers goto done; 989fd358c0dSmyers *gpe_dev = gpe->Package.Elements[0].Reference.Handle; 990fd358c0dSmyers *gpe_num = gpe->Package.Elements[1].Integer.Value; 991fd358c0dSmyers status = AE_OK; 992fd358c0dSmyers } 993fd358c0dSmyers 994fd358c0dSmyers done: 995fd358c0dSmyers AcpiOsFree(buf.Pointer); 996fd358c0dSmyers return (status); 997fd358c0dSmyers } 998fd358c0dSmyers 999fd358c0dSmyers 1000fd358c0dSmyers /* 1001fd358c0dSmyers * 1002fd358c0dSmyers */ 10039f43a0a2Smyers /*ARGSUSED*/ 1004fd358c0dSmyers static ACPI_STATUS 1005fd358c0dSmyers acpi_device(ACPI_HANDLE obj, UINT32 nesting, void *context, void **rv) 1006fd358c0dSmyers { 10079f43a0a2Smyers 1008fd358c0dSmyers *((ACPI_HANDLE *)context) = obj; 1009fd358c0dSmyers return (AE_OK); 1010fd358c0dSmyers } 1011fd358c0dSmyers 1012fd358c0dSmyers /* 1013fd358c0dSmyers * 1014fd358c0dSmyers */ 1015fd358c0dSmyers static ACPI_HANDLE 1016fd358c0dSmyers probe_acpi_pwrbutton() 1017fd358c0dSmyers { 1018fd358c0dSmyers ACPI_HANDLE obj = NULL; 1019fd358c0dSmyers 10209f43a0a2Smyers (void) AcpiGetDevices("PNP0C0C", acpi_device, (void *)&obj, NULL); 1021fd358c0dSmyers return (obj); 1022fd358c0dSmyers } 1023fd358c0dSmyers 1024fd358c0dSmyers static UINT32 1025fd358c0dSmyers power_acpi_fixed_event(void *ctx) 1026fd358c0dSmyers { 1027fd358c0dSmyers 1028fd358c0dSmyers mutex_enter(&((struct power_soft_state *)ctx)->power_intr_mutex); 1029fd358c0dSmyers power_button_pressed++; 1030fd358c0dSmyers mutex_exit(&((struct power_soft_state *)ctx)->power_intr_mutex); 1031fd358c0dSmyers 1032fd358c0dSmyers /* post softint to issue timeout for power button action */ 1033fd358c0dSmyers if (((struct power_soft_state *)ctx)->softintr_id != NULL) 1034fd358c0dSmyers ddi_trigger_softintr( 1035fd358c0dSmyers ((struct power_soft_state *)ctx)->softintr_id); 1036fd358c0dSmyers 1037fd358c0dSmyers return (AE_OK); 1038fd358c0dSmyers } 1039fd358c0dSmyers 10409f43a0a2Smyers /*ARGSUSED*/ 1041fd358c0dSmyers static void 1042fd358c0dSmyers power_acpi_notify_event(ACPI_HANDLE obj, UINT32 val, void *ctx) 1043fd358c0dSmyers { 1044fd358c0dSmyers if (val == 0x80) 10459f43a0a2Smyers (void) power_acpi_fixed_event(ctx); 1046fd358c0dSmyers } 1047fd358c0dSmyers 1048fd358c0dSmyers /* 1049fd358c0dSmyers * 1050fd358c0dSmyers */ 1051fd358c0dSmyers static int 1052fd358c0dSmyers power_probe_method_button(struct power_soft_state *softsp) 1053fd358c0dSmyers { 1054fd358c0dSmyers ACPI_HANDLE button_obj; 1055fd358c0dSmyers UINT32 gpe_num; 1056fd358c0dSmyers ACPI_HANDLE gpe_dev; 1057fd358c0dSmyers 1058fd358c0dSmyers button_obj = probe_acpi_pwrbutton(); 1059fd358c0dSmyers softsp->button_obj = button_obj; /* remember obj */ 1060fd358c0dSmyers if ((button_obj != NULL) && 1061fd358c0dSmyers (power_get_prw_gpe(button_obj, &gpe_dev, &gpe_num) == AE_OK) && 1062fd358c0dSmyers (AcpiSetGpeType(gpe_dev, gpe_num, ACPI_GPE_TYPE_WAKE_RUN) == 1063fd358c0dSmyers AE_OK) && 1064fd358c0dSmyers (AcpiEnableGpe(gpe_dev, gpe_num, ACPI_NOT_ISR) == AE_OK) && 1065fd358c0dSmyers (AcpiInstallNotifyHandler(button_obj, ACPI_DEVICE_NOTIFY, 1066fd358c0dSmyers power_acpi_notify_event, (void*)softsp) == AE_OK)) 1067fd358c0dSmyers return (1); 1068fd358c0dSmyers return (0); 1069fd358c0dSmyers } 1070fd358c0dSmyers 1071fd358c0dSmyers /* 1072fd358c0dSmyers * 1073fd358c0dSmyers */ 1074fd358c0dSmyers static int 1075fd358c0dSmyers power_probe_fixed_button(struct power_soft_state *softsp) 1076fd358c0dSmyers { 1077fd358c0dSmyers FADT_DESCRIPTOR *fadt; 1078fd358c0dSmyers 1079fd358c0dSmyers if (AcpiGetFirmwareTable(FADT_SIG, 1, ACPI_LOGICAL_ADDRESSING, 1080fd358c0dSmyers (ACPI_TABLE_HEADER **) &fadt) != AE_OK) 1081fd358c0dSmyers return (0); 1082fd358c0dSmyers 1083fd358c0dSmyers if (!fadt->PwrButton) { 1084fd358c0dSmyers if (AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON, 1085fd358c0dSmyers power_acpi_fixed_event, (void *)softsp) == AE_OK) 1086fd358c0dSmyers return (1); 1087fd358c0dSmyers } 1088fd358c0dSmyers return (0); 1089fd358c0dSmyers } 1090fd358c0dSmyers 1091fd358c0dSmyers 1092fd358c0dSmyers /* 1093fd358c0dSmyers * 1094fd358c0dSmyers */ 1095fd358c0dSmyers static int 1096fd358c0dSmyers power_attach_acpi(struct power_soft_state *softsp) 1097fd358c0dSmyers { 1098fd358c0dSmyers 1099fd358c0dSmyers /* 1100fd358c0dSmyers * If we've attached anything already, return an error 1101fd358c0dSmyers */ 1102fd358c0dSmyers if ((softsp->gpe_attached) || (softsp->fixed_attached)) 1103fd358c0dSmyers return (DDI_FAILURE); 1104fd358c0dSmyers 1105fd358c0dSmyers /* 1106fd358c0dSmyers * attempt to attach both a fixed-event handler and a GPE 1107fd358c0dSmyers * handler; remember what we got 1108fd358c0dSmyers */ 1109fd358c0dSmyers softsp->fixed_attached = (power_probe_fixed_button(softsp) != 0); 1110fd358c0dSmyers softsp->gpe_attached = (power_probe_method_button(softsp) != 0); 1111fd358c0dSmyers 1112fd358c0dSmyers /* 1113fd358c0dSmyers * If we've attached anything now, return success 1114fd358c0dSmyers */ 1115fd358c0dSmyers if ((softsp->gpe_attached) || (softsp->fixed_attached)) 1116fd358c0dSmyers return (DDI_SUCCESS); 1117fd358c0dSmyers 1118fd358c0dSmyers return (DDI_FAILURE); 1119fd358c0dSmyers } 1120fd358c0dSmyers 1121fd358c0dSmyers /* 1122fd358c0dSmyers * 1123fd358c0dSmyers */ 1124fd358c0dSmyers static void 1125fd358c0dSmyers power_detach_acpi(struct power_soft_state *softsp) 1126fd358c0dSmyers { 1127fd358c0dSmyers if (softsp->gpe_attached) { 1128fd358c0dSmyers if (AcpiRemoveNotifyHandler(softsp->button_obj, 1129fd358c0dSmyers ACPI_DEVICE_NOTIFY, power_acpi_notify_event) != AE_OK) 1130fd358c0dSmyers cmn_err(CE_WARN, "!power: failed to remove Notify" 1131fd358c0dSmyers " handler"); 1132fd358c0dSmyers } 1133fd358c0dSmyers 1134fd358c0dSmyers if (softsp->fixed_attached) { 1135fd358c0dSmyers if (AcpiRemoveFixedEventHandler(ACPI_EVENT_POWER_BUTTON, 1136fd358c0dSmyers power_acpi_fixed_event) != AE_OK) 1137fd358c0dSmyers cmn_err(CE_WARN, "!power: failed to remove Power" 1138fd358c0dSmyers " Button handler"); 1139fd358c0dSmyers } 1140fd358c0dSmyers } 1141fd358c0dSmyers 1142fd358c0dSmyers #else 1143fd358c0dSmyers /* 1144d58fda43Sjbeloro * Code for platforms that have EPIC processor for processing power 1145d58fda43Sjbeloro * button interrupts. 1146d58fda43Sjbeloro */ 1147d58fda43Sjbeloro static int 1148d58fda43Sjbeloro power_setup_epic_regs(dev_info_t *dip, struct power_soft_state *softsp) 1149d58fda43Sjbeloro { 1150d58fda43Sjbeloro ddi_device_acc_attr_t attr; 1151d58fda43Sjbeloro uint8_t *reg_base; 1152d58fda43Sjbeloro 1153d58fda43Sjbeloro attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 1154d58fda43Sjbeloro attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC; 1155d58fda43Sjbeloro attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 1156d58fda43Sjbeloro if (ddi_regs_map_setup(dip, 0, (caddr_t *)®_base, 1157d58fda43Sjbeloro EPIC_REGS_OFFSET, EPIC_REGS_LEN, &attr, 1158d58fda43Sjbeloro &softsp->power_rhandle) != DDI_SUCCESS) { 1159d58fda43Sjbeloro return (DDI_FAILURE); 1160d58fda43Sjbeloro } 1161d58fda43Sjbeloro 1162d58fda43Sjbeloro softsp->power_btn_reg = reg_base; 1163d58fda43Sjbeloro softsp->power_regs_mapped = B_TRUE; 1164d58fda43Sjbeloro 1165d58fda43Sjbeloro /* Clear power button interrupt first */ 1166d58fda43Sjbeloro EPIC_WR(softsp->power_rhandle, softsp->power_btn_reg, 1167d58fda43Sjbeloro EPIC_ATOM_INTR_CLEAR); 1168d58fda43Sjbeloro 1169d58fda43Sjbeloro /* Enable EPIC interrupt for power button single press event */ 1170d58fda43Sjbeloro EPIC_WR(softsp->power_rhandle, softsp->power_btn_reg, 1171d58fda43Sjbeloro EPIC_ATOM_INTR_ENABLE); 1172d58fda43Sjbeloro 1173d58fda43Sjbeloro /* 1174d58fda43Sjbeloro * At this point, EPIC interrupt processing is fully initialised. 1175d58fda43Sjbeloro */ 1176d58fda43Sjbeloro hasEPIC = B_TRUE; 1177d58fda43Sjbeloro return (DDI_SUCCESS); 1178d58fda43Sjbeloro } 1179d58fda43Sjbeloro 1180d58fda43Sjbeloro /* 1181d58fda43Sjbeloro * 1182fd358c0dSmyers * power button register definitions for acpi register on m1535d 1183fd358c0dSmyers */ 1184fd358c0dSmyers #define M1535D_PWR_BTN_REG_01 0x1 1185fd358c0dSmyers #define M1535D_PWR_BTN_EVENT_FLAG 0x1 1186fd358c0dSmyers 1187fd358c0dSmyers static int 1188fd358c0dSmyers power_setup_m1535_regs(dev_info_t *dip, struct power_soft_state *softsp) 1189fd358c0dSmyers { 1190fd358c0dSmyers ddi_device_acc_attr_t attr; 1191fd358c0dSmyers uint8_t *reg_base; 1192fd358c0dSmyers 1193fd358c0dSmyers attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 1194fd358c0dSmyers attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC; 1195fd358c0dSmyers attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 1196fd358c0dSmyers if (ddi_regs_map_setup(dip, 0, (caddr_t *)®_base, 0, 0, &attr, 1197fd358c0dSmyers &softsp->power_rhandle) != DDI_SUCCESS) { 1198fd358c0dSmyers return (DDI_FAILURE); 1199fd358c0dSmyers } 1200fd358c0dSmyers softsp->power_btn_reg = ®_base[M1535D_PWR_BTN_REG_01]; 1201fd358c0dSmyers softsp->power_btn_bit = M1535D_PWR_BTN_EVENT_FLAG; 1202fd358c0dSmyers softsp->power_regs_mapped = B_TRUE; 1203fd358c0dSmyers return (DDI_SUCCESS); 1204fd358c0dSmyers } 1205fd358c0dSmyers 1206fd358c0dSmyers /* 1207d58fda43Sjbeloro * MBC Fire/SSI Interrupt Status Register definitions 1208d58fda43Sjbeloro */ 1209d58fda43Sjbeloro #define FIRE_SSI_ISR 0x0 1210d58fda43Sjbeloro #define FIRE_SSI_INTR_ENA 0x8 1211d58fda43Sjbeloro #define FIRE_SSI_SHUTDOWN_REQ 0x4 1212d58fda43Sjbeloro 1213d58fda43Sjbeloro static int 1214d58fda43Sjbeloro power_setup_mbc_regs(dev_info_t *dip, struct power_soft_state *softsp) 1215d58fda43Sjbeloro { 1216d58fda43Sjbeloro ddi_device_acc_attr_t attr; 1217d58fda43Sjbeloro uint8_t *reg_base; 1218d58fda43Sjbeloro ddi_acc_handle_t hdl; 1219d58fda43Sjbeloro uint8_t reg; 1220d58fda43Sjbeloro 1221d58fda43Sjbeloro attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 1222d58fda43Sjbeloro attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC; 1223d58fda43Sjbeloro attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 1224d58fda43Sjbeloro if (ddi_regs_map_setup(dip, 0, (caddr_t *)®_base, 0, 0, &attr, 1225d58fda43Sjbeloro &softsp->power_rhandle) != DDI_SUCCESS) { 1226d58fda43Sjbeloro return (DDI_FAILURE); 1227d58fda43Sjbeloro } 1228d58fda43Sjbeloro softsp->power_btn_reg = ®_base[FIRE_SSI_ISR]; 1229d58fda43Sjbeloro softsp->power_btn_bit = FIRE_SSI_SHUTDOWN_REQ; 123075212827Sgk73471 hdl = softsp->power_rhandle; 123175212827Sgk73471 /* 123275212827Sgk73471 * Clear MBC Fire Power Button interrupt, if set. 123375212827Sgk73471 */ 123475212827Sgk73471 reg = ddi_get8(hdl, softsp->power_btn_reg); 123575212827Sgk73471 if (reg & softsp->power_btn_bit) { 123675212827Sgk73471 reg &= softsp->power_btn_bit; 123775212827Sgk73471 ddi_put8(hdl, softsp->power_btn_reg, reg); 123875212827Sgk73471 (void) ddi_get8(hdl, softsp->power_btn_reg); 123975212827Sgk73471 } 1240d58fda43Sjbeloro /* 1241d58fda43Sjbeloro * Enable MBC Fire Power Button interrupt. 1242d58fda43Sjbeloro */ 1243d58fda43Sjbeloro reg = ddi_get8(hdl, ®_base[FIRE_SSI_INTR_ENA]); 1244d58fda43Sjbeloro reg |= FIRE_SSI_SHUTDOWN_REQ; 1245d58fda43Sjbeloro ddi_put8(hdl, ®_base[FIRE_SSI_INTR_ENA], reg); 1246d58fda43Sjbeloro 1247d58fda43Sjbeloro softsp->power_regs_mapped = B_TRUE; 1248d58fda43Sjbeloro 1249d58fda43Sjbeloro return (DDI_SUCCESS); 1250d58fda43Sjbeloro } 1251d58fda43Sjbeloro 1252d58fda43Sjbeloro /* 1253fd358c0dSmyers * Setup register map for the power button 12541bde0be8Sjroberts * NOTE:- we only map registers for platforms if 12551bde0be8Sjroberts * the OBP power device has any of the following 12561bde0be8Sjroberts * properties: 12571bde0be8Sjroberts * 12581bde0be8Sjroberts * a) Boston: power-device-type set to "SUNW,mbc" 12591bde0be8Sjroberts * b) Seattle: power-device-type set to "SUNW,pic18lf65j10" 12601bde0be8Sjroberts * c) Chalupa: compatible set to "ali1535d+-power" 12611bde0be8Sjroberts * 12621bde0be8Sjroberts * Cases (a) and (b) are defined in FWARC 2005/687. 12631bde0be8Sjroberts * If none of the above conditions are true, then we 12641bde0be8Sjroberts * do not need to map in any registers, and this 12651bde0be8Sjroberts * function can simply return DDI_SUCCESS. 1266fd358c0dSmyers */ 1267fd358c0dSmyers static int 1268fd358c0dSmyers power_setup_regs(struct power_soft_state *softsp) 1269fd358c0dSmyers { 1270fd358c0dSmyers char *binding_name; 12711bde0be8Sjroberts char *power_type = NULL; 12721bde0be8Sjroberts int retval = DDI_SUCCESS; 1273fd358c0dSmyers 1274fd358c0dSmyers softsp->power_regs_mapped = B_FALSE; 1275fd358c0dSmyers softsp->power_btn_ioctl = B_FALSE; 1276fd358c0dSmyers binding_name = ddi_binding_name(softsp->dip); 12771bde0be8Sjroberts if (ddi_prop_lookup_string(DDI_DEV_T_ANY, softsp->dip, 12781bde0be8Sjroberts DDI_PROP_DONTPASS, POWER_DEVICE_TYPE, 12791bde0be8Sjroberts &power_type) == DDI_PROP_SUCCESS) { 12801bde0be8Sjroberts if (strcmp(power_type, "SUNW,mbc") == 0) { 12811bde0be8Sjroberts retval = power_setup_mbc_regs(softsp->dip, softsp); 12821bde0be8Sjroberts } else if (strcmp(power_type, "SUNW,pic18lf65j10") == 0) { 12831bde0be8Sjroberts retval = power_setup_epic_regs(softsp->dip, softsp); 12841bde0be8Sjroberts } else { 12851bde0be8Sjroberts cmn_err(CE_WARN, "unexpected power-device-type: %s\n", 12861bde0be8Sjroberts power_type); 12871bde0be8Sjroberts retval = DDI_FAILURE; 12881bde0be8Sjroberts } 12891bde0be8Sjroberts ddi_prop_free(power_type); 12901bde0be8Sjroberts } else if (strcmp(binding_name, "ali1535d+-power") == 0) { 12911bde0be8Sjroberts retval = power_setup_m1535_regs(softsp->dip, softsp); 12921bde0be8Sjroberts } 1293fd358c0dSmyers 1294d58fda43Sjbeloro /* 12951bde0be8Sjroberts * If power-device-type does not exist AND the binding name is not 12961bde0be8Sjroberts * "ali1535d+-power", that means there is no additional HW and hence 12971bde0be8Sjroberts * no extra processing is necessary. In that case, retval should still 12981bde0be8Sjroberts * be set to its initial value of DDI_SUCCESS. 1299d58fda43Sjbeloro */ 13001bde0be8Sjroberts return (retval); 1301fd358c0dSmyers } 1302fd358c0dSmyers 1303fd358c0dSmyers static void 1304fd358c0dSmyers power_free_regs(struct power_soft_state *softsp) 1305fd358c0dSmyers { 1306fd358c0dSmyers if (softsp->power_regs_mapped) 1307fd358c0dSmyers ddi_regs_map_free(&softsp->power_rhandle); 1308fd358c0dSmyers } 1309fd358c0dSmyers #endif /* ACPI_POWER_BUTTON */ 1310