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