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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright 2015 Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org>
28 */
29
30 /*
31 * Driver for ACPI Battery, Lid, and Hotkey Control
32 */
33 #include <sys/hotkey_drv.h>
34 #include <sys/sysevent/pwrctl.h>
35
36
37 #define ACPI_DRV_MOD_STRING "ACPI driver"
38
39 #define ACPI_DRV_MAX_BAT_NUM 8
40 #define ACPI_DRV_MAX_AC_NUM 10
41
42 #define BST_FLAG_DISCHARGING (0x1)
43 #define BST_FLAG_CHARGING (0x2)
44 #define BST_FLAG_CRITICAL (0x4)
45
46 /* Set if the battery is present */
47 #define STA_FLAG_BATT_PRESENT (0x10)
48
49 #define ACPI_DEVNAME_CBAT "PNP0C0A"
50 #define ACPI_DEVNAME_AC "ACPI0003"
51 #define ACPI_DEVNAME_LID "PNP0C0D"
52
53 #define ACPI_DRV_EVENTS (POLLIN | POLLRDNORM)
54
55 #ifdef DEBUG
56
57 #define ACPI_DRV_PRINT_BUFFER_SIZE 512
58 static char acpi_drv_prt_buf[ACPI_DRV_PRINT_BUFFER_SIZE];
59 static kmutex_t acpi_drv_prt_mutex;
60
61 static int acpi_drv_debug = 0;
62 #define ACPI_DRV_DBG(lev, devp, ...) \
63 do { \
64 if (acpi_drv_debug) acpi_drv_printf((devp), \
65 (lev), __VA_ARGS__); \
66 _NOTE(CONSTCOND) } while (0)
67 #define ACPI_DRV_PRT_NOTIFY(hdl, val) \
68 do { \
69 if (acpi_drv_debug) acpi_drv_prt_notify((hdl), (val)); \
70 _NOTE(CONSTCOND) } while (0)
71
72 #else
73
74 #define ACPI_DRV_DBG(lev, devp, ...)
75 #define ACPI_DRV_PRT_NOTIFY(hdl, val)
76
77 #endif /* DEBUG */
78
79 /* ACPI notify types */
80 enum acpi_drv_notify {
81 ACPI_DRV_NTF_UNKNOWN = -1, /* No notifications seen, ever. */
82 ACPI_DRV_NTF_CHANGED,
83 ACPI_DRV_NTF_OK
84 };
85
86 static int acpi_drv_dev_present(struct acpi_drv_dev *);
87 #define acpi_drv_ac_present(a) (((a)->dev.type == ACPI_DRV_TYPE_AC) ? \
88 acpi_drv_dev_present(&(a)->dev) : -1)
89 #define acpi_drv_cbat_present(a) (((a)->dev.type == ACPI_DRV_TYPE_CBAT) \
90 ? acpi_drv_dev_present(&(a)->dev) : -1)
91
92 static dev_info_t *acpi_drv_dip = NULL;
93 static kmutex_t acpi_drv_mutex;
94 static struct pollhead acpi_drv_pollhead;
95 static timeout_id_t acpi_drv_cbat_rescan_timeout;
96
97 /* Control Method Battery state */
98 struct acpi_drv_cbat_state {
99 struct acpi_drv_dev dev;
100 /* Caches of _BST and _BIF */
101 enum acpi_drv_notify bat_bifok;
102 acpi_bif_t bif_cache;
103 enum acpi_drv_notify bat_bstok;
104 acpi_bst_t bst_cache;
105
106 uint32_t charge_warn;
107 uint32_t charge_low;
108
109 kstat_t *bat_bif_ksp;
110 kstat_t *bat_bst_ksp;
111 } acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
112 static int nbat = 0;
113
114 /*
115 * Synthesis battery state
116 * When there are multiple batteries present, the battery subsystem
117 * is not required to perform any synthesis of a composite battery
118 * from the data of the separate batteries. In cases where the
119 * battery subsystem does not synthesize a composite battery from
120 * the separate battery's data, the OS must provide that synthesis.
121 */
122 static uint32_t acpi_drv_syn_rem_cap;
123 static uint32_t acpi_drv_syn_last_cap;
124 static uint32_t acpi_drv_syn_oem_warn_cap;
125 static uint32_t acpi_drv_syn_oem_low_cap;
126
127 static int acpi_drv_warn_enabled;
128 static uint32_t acpi_drv_syn_warn_per;
129 static uint32_t acpi_drv_syn_low_per;
130 static uint32_t acpi_drv_syn_warn_cap;
131 static uint32_t acpi_drv_syn_low_cap;
132 /* Tracking boundery passing of _BST charge levels */
133 static uint32_t acpi_drv_syn_last_level;
134
135 /* AC state */
136 static struct acpi_drv_ac_state {
137 struct acpi_drv_dev dev;
138 } acpi_drv_ac[ACPI_DRV_MAX_AC_NUM];
139 static int nac = 0;
140
141 /*
142 * Current power source device
143 * Note: assume only one device can be the power source device.
144 */
145 static int acpi_drv_psr_type = ACPI_DRV_TYPE_UNKNOWN;
146 static struct acpi_drv_dev *acpi_drv_psr_devp = NULL;
147
148 struct obj_desc {
149 char *name;
150 int offset;
151 int size;
152 int type;
153 };
154
155 /* Object copy definitions */
156 #define OFFSETOF(s, m) ((size_t)(&(((s *)0)->m)))
157 #define SIZEOF(s, m) (sizeof (((s *)0)->m))
158 #define FIELD(n, s, m, t) \
159 { n, OFFSETOF(s, m), SIZEOF(s, m), t }
160 #define FIELD_NULL { NULL, -1, 0, ACPI_TYPE_ANY }
161
162 static struct obj_desc bif_desc[] = {
163 FIELD("bif_unit", acpi_bif_t, bif_unit, ACPI_TYPE_INTEGER),
164 FIELD("bif_design_cap", acpi_bif_t, bif_design_cap, ACPI_TYPE_INTEGER),
165 FIELD("bif_last_cap", acpi_bif_t, bif_last_cap, ACPI_TYPE_INTEGER),
166 FIELD("bif_tech", acpi_bif_t, bif_tech, ACPI_TYPE_INTEGER),
167 FIELD("bif_voltage", acpi_bif_t, bif_voltage, ACPI_TYPE_INTEGER),
168 FIELD("bif_warn_cap", acpi_bif_t, bif_warn_cap, ACPI_TYPE_INTEGER),
169 FIELD("bif_low_cap", acpi_bif_t, bif_low_cap, ACPI_TYPE_INTEGER),
170 FIELD("bif_gran1_cap", acpi_bif_t, bif_gran1_cap, ACPI_TYPE_INTEGER),
171 FIELD("bif_gran2_cap", acpi_bif_t, bif_gran2_cap, ACPI_TYPE_INTEGER),
172 FIELD("bif_model", acpi_bif_t, bif_model, ACPI_TYPE_STRING),
173 FIELD("bif_serial", acpi_bif_t, bif_serial, ACPI_TYPE_STRING),
174 FIELD("bif_type", acpi_bif_t, bif_type, ACPI_TYPE_STRING),
175 FIELD("bif_oem_info", acpi_bif_t, bif_oem_info, ACPI_TYPE_STRING),
176 FIELD_NULL
177 };
178
179 static struct obj_desc bst_desc[] = {
180 FIELD("bst_state", acpi_bst_t, bst_state, ACPI_TYPE_INTEGER),
181 FIELD("bst_rate", acpi_bst_t, bst_rate, ACPI_TYPE_INTEGER),
182 FIELD("bst_rem_cap", acpi_bst_t, bst_rem_cap, ACPI_TYPE_INTEGER),
183 FIELD("bst_voltage", acpi_bst_t, bst_voltage, ACPI_TYPE_INTEGER),
184 FIELD_NULL
185 };
186
187 /* kstat definitions */
188 static kstat_t *acpi_drv_power_ksp;
189 static kstat_t *acpi_drv_warn_ksp;
190
191 acpi_drv_power_kstat_t acpi_drv_power_kstat = {
192 { SYSTEM_POWER, KSTAT_DATA_STRING },
193 { SUPPORTED_BATTERY_COUNT, KSTAT_DATA_UINT32 },
194 };
195
196 acpi_drv_warn_kstat_t acpi_drv_warn_kstat = {
197 { BW_ENABLED, KSTAT_DATA_UINT32 },
198 { BW_POWEROFF_THRESHOLD, KSTAT_DATA_UINT32 },
199 { BW_SHUTDOWN_THRESHOLD, KSTAT_DATA_UINT32 },
200 };
201
202 /* BIF */
203 acpi_drv_bif_kstat_t acpi_drv_bif_kstat = {
204 { BIF_UNIT, KSTAT_DATA_UINT32 },
205 { BIF_DESIGN_CAP, KSTAT_DATA_UINT32 },
206 { BIF_LAST_CAP, KSTAT_DATA_UINT32 },
207 { BIF_TECH, KSTAT_DATA_UINT32 },
208 { BIF_VOLTAGE, KSTAT_DATA_UINT32 },
209 { BIF_WARN_CAP, KSTAT_DATA_UINT32 },
210 { BIF_LOW_CAP, KSTAT_DATA_UINT32 },
211 { BIF_GRAN1_CAP, KSTAT_DATA_UINT32 },
212 { BIF_GRAN2_CAP, KSTAT_DATA_UINT32 },
213 { BIF_MODEL, KSTAT_DATA_STRING },
214 { BIF_SERIAL, KSTAT_DATA_STRING },
215 { BIF_TYPE, KSTAT_DATA_STRING },
216 { BIF_OEM_INFO, KSTAT_DATA_STRING },
217 };
218
219 /* BST */
220 acpi_drv_bst_kstat_t acpi_drv_bst_kstat = {
221 { BST_STATE, KSTAT_DATA_UINT32 },
222 { BST_RATE, KSTAT_DATA_UINT32 },
223 { BST_REM_CAP, KSTAT_DATA_UINT32 },
224 { BST_VOLTAGE, KSTAT_DATA_UINT32 },
225 };
226
227 struct acpi_drv_lid_state {
228 struct acpi_drv_dev dev;
229 enum acpi_drv_notify state_ok;
230 int state;
231 } lid;
232 static int nlid = 0;
233
234 struct hotkey_drv acpi_hotkey;
235
236 static int acpi_drv_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
237 static int acpi_drv_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
238 static int acpi_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
239 void **resultp);
240 static int acpi_drv_open(dev_t *devp, int flag, int otyp, cred_t *crp);
241 static int acpi_drv_close(dev_t dev, int flag, int otyp, cred_t *crp);
242 static int acpi_drv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
243 cred_t *cr, int *rval);
244 static int acpi_drv_chpoll(dev_t dev, short events, int anyyet,
245 short *reventsp, struct pollhead **phpp);
246 static int acpi_drv_ac_ioctl(int index, int cmd, intptr_t arg, int mode,
247 cred_t *cr, int *rval);
248 static int acpi_drv_cbat_ioctl(int index, int cmd, intptr_t arg, int mode,
249 cred_t *cr, int *rval);
250 static int acpi_drv_lid_ioctl(int index, int cmd, intptr_t arg, int mode,
251 cred_t *cr, int *rval);
252 #ifdef DEBUG
253 static void acpi_drv_printf(struct acpi_drv_dev *devp, uint_t lev,
254 const char *fmt, ...);
255 #endif
256
257 static int acpi_drv_update_bif(struct acpi_drv_cbat_state *bp);
258 static int acpi_drv_update_bst(struct acpi_drv_cbat_state *bp);
259 static int acpi_drv_update_lid(struct acpi_drv_dev *bp);
260 static int acpi_drv_set_warn(acpi_drv_warn_t *bwp);
261 static struct acpi_drv_cbat_state *acpi_drv_idx2cbat(int idx);
262 static struct acpi_drv_ac_state *acpi_drv_idx2ac(int idx);
263 static int acpi_drv_acpi_init(void);
264 static void acpi_drv_acpi_fini(void);
265 static int acpi_drv_kstat_init(void);
266 static void acpi_drv_kstat_fini(void);
267
268 static int acpi_drv_kstat_bif_update(kstat_t *, int);
269 static int acpi_drv_kstat_bst_update(kstat_t *, int);
270
271 static void acpi_drv_cbat_rescan(void *);
272
273 static struct cb_ops acpi_drv_cb_ops = {
274 acpi_drv_open, /* open */
275 acpi_drv_close, /* close */
276 nodev, /* strategy */
277 nodev, /* print */
278 nodev, /* dump */
279 nodev, /* read */
280 nodev, /* write */
281 acpi_drv_ioctl, /* ioctl */
282 nodev, /* devmap */
283 nodev, /* mmap */
284 nodev, /* segmap */
285 acpi_drv_chpoll, /* chpoll */
286 ddi_prop_op, /* prop_op */
287 NULL, /* streamtab */
288 D_NEW | D_MP,
289 CB_REV,
290 nodev,
291 nodev
292 };
293
294 static struct dev_ops acpi_drv_dev_ops = {
295 DEVO_REV,
296 0, /* refcnt */
297 acpi_drv_getinfo, /* getinfo */
298 nulldev, /* identify */
299 nulldev, /* probe */
300 acpi_drv_attach, /* attach */
301 acpi_drv_detach, /* detach */
302 nodev, /* reset */
303 &acpi_drv_cb_ops,
304 NULL, /* no bus operations */
305 NULL, /* power */
306 ddi_quiesce_not_needed, /* quiesce */
307 };
308
309 static struct modldrv modldrv1 = {
310 &mod_driverops,
311 ACPI_DRV_MOD_STRING,
312 &acpi_drv_dev_ops
313 };
314
315 static struct modlinkage modlinkage = {
316 MODREV_1,
317 (void *)&modldrv1,
318 NULL,
319 };
320
321 int
322 _init(void)
323 {
324 int ret;
325
326 mutex_init(&acpi_drv_mutex, NULL, MUTEX_DRIVER, NULL);
327 #ifdef DEBUG
328 mutex_init(&acpi_drv_prt_mutex, NULL, MUTEX_DRIVER, NULL);
329 #endif
330
331 if ((ret = mod_install(&modlinkage)) != 0) {
332 mutex_destroy(&acpi_drv_mutex);
333 #ifdef DEBUG
334 mutex_destroy(&acpi_drv_prt_mutex);
335 #endif
336 }
337 return (ret);
338 }
339
340 int
341 _fini(void)
342 {
343 int ret;
344
345 if ((ret = mod_remove(&modlinkage)) == 0) {
346 #ifdef DEBUG
347 mutex_destroy(&acpi_drv_prt_mutex);
348 #endif
349 mutex_destroy(&acpi_drv_mutex);
350 }
351
352 return (ret);
353 }
354
355 int
356 _info(struct modinfo *mp)
357 {
358 return (mod_info(&modlinkage, mp));
359 }
360
361 static int
362 acpi_drv_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
363 {
364 switch (cmd) {
365 case DDI_ATTACH:
366 /* Limit to one instance of driver */
367 if (acpi_drv_dip) {
368 return (DDI_FAILURE);
369 }
370 break;
371 case DDI_RESUME:
372 case DDI_PM_RESUME:
373 return (DDI_SUCCESS);
374 default:
375 return (DDI_FAILURE);
376 }
377
378 acpi_drv_dip = devi;
379
380 /* Init ACPI related stuff */
381 if (acpi_drv_acpi_init() != ACPI_DRV_OK) {
382 goto error;
383 }
384
385 /* Init kstat related stuff */
386 if (acpi_drv_kstat_init() != ACPI_DRV_OK) {
387 goto error;
388 }
389
390 acpi_drv_cbat_rescan_timeout = timeout(acpi_drv_cbat_rescan, NULL,
391 drv_usectohz(MICROSEC));
392
393 return (DDI_SUCCESS);
394
395 error:
396 ddi_remove_minor_node(devi, NULL);
397 acpi_drv_kstat_fini();
398 acpi_drv_acpi_fini();
399 acpi_drv_dip = NULL;
400 return (DDI_FAILURE);
401 }
402
403 static int
404 acpi_drv_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
405 {
406 timeout_id_t tmp_rescan_timeout;
407
408 if (cmd != DDI_DETACH) {
409 return (DDI_FAILURE);
410 }
411
412 /*
413 * Clear the timeout id to indicate that the handler should not
414 * reschedule itself.
415 */
416 mutex_enter(&acpi_drv_mutex);
417 tmp_rescan_timeout = acpi_drv_cbat_rescan_timeout;
418 acpi_drv_cbat_rescan_timeout = 0;
419 mutex_exit(&acpi_drv_mutex);
420
421 (void) untimeout(tmp_rescan_timeout);
422
423 mutex_enter(&acpi_drv_mutex);
424 ddi_remove_minor_node(devi, NULL);
425
426 acpi_drv_kstat_fini();
427 acpi_drv_acpi_fini();
428 mutex_exit(&acpi_drv_mutex);
429 return (DDI_SUCCESS);
430 }
431
432 /* ARGSUSED */
433 static int
434 acpi_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
435 {
436 switch (cmd) {
437 case DDI_INFO_DEVT2DEVINFO:
438 *resultp = acpi_drv_dip;
439 return (DDI_SUCCESS);
440 case DDI_INFO_DEVT2INSTANCE:
441 *resultp = (void*) 0;
442 return (DDI_SUCCESS);
443 default:
444 return (DDI_FAILURE);
445 }
446 }
447
448 /*ARGSUSED*/
449 static int
450 acpi_drv_open(dev_t *devp, int flag, int otyp, cred_t *crp)
451 {
452 if (acpi_drv_dip == NULL) {
453 return (ENXIO);
454 }
455
456 return (0);
457 }
458
459 /*ARGSUSED*/
460 static int
461 acpi_drv_close(dev_t dev, int flag, int otyp, cred_t *crp)
462 {
463 return (0);
464 }
465
466 /*ARGSUSED*/
467 static int
468 acpi_drv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr,
469 int *rval)
470 {
471 int minor;
472 int type, index;
473 int res = 0;
474
475 minor = getminor(dev);
476 type = MINOR2TYPE(minor);
477 index = MINOR2IDX(minor);
478
479 mutex_enter(&acpi_drv_mutex);
480
481 switch (type) {
482 case ACPI_DRV_TYPE_CBAT:
483 res = acpi_drv_cbat_ioctl(index, cmd, arg, mode, cr, rval);
484 break;
485 case ACPI_DRV_TYPE_AC:
486 res = acpi_drv_ac_ioctl(index, cmd, arg, mode, cr, rval);
487 break;
488 case ACPI_DRV_TYPE_LID:
489 res = acpi_drv_lid_ioctl(index, cmd, arg, mode, cr, rval);
490 break;
491 case ACPI_DRV_TYPE_HOTKEY:
492 res = acpi_drv_hotkey_ioctl(cmd, arg, mode, cr, rval);
493 break;
494 default:
495 res = EINVAL;
496 break;
497 }
498
499 mutex_exit(&acpi_drv_mutex);
500 return (res);
501 }
502
503 /*ARGSUSED*/
504 static int
505 acpi_drv_cbat_ioctl(int index, int cmd, intptr_t arg, int mode, cred_t *cr,
506 int *rval)
507 {
508 int res = 0;
509 acpi_drv_warn_t bwarn;
510 struct acpi_drv_cbat_state *bp;
511
512 ASSERT(mutex_owned(&acpi_drv_mutex));
513
514 bp = acpi_drv_idx2cbat(index);
515 if (!bp || bp->dev.valid != 1) {
516 return (ENXIO);
517 }
518
519 switch (cmd) {
520 /*
521 * Return _BIF(Battery Information) of battery[index],
522 * if battery plugged.
523 */
524 case ACPI_DRV_IOC_INFO:
525 if (bp->dev.present == 0) {
526 res = ENXIO;
527 break;
528 }
529
530 res = acpi_drv_update_bif(bp);
531 if (res != ACPI_DRV_OK) {
532 break;
533 }
534 if (copyout(&bp->bif_cache, (void *)arg,
535 sizeof (bp->bif_cache))) {
536 res = EFAULT;
537 }
538 break;
539
540 /*
541 * Return _BST(Battery Status) of battery[index],
542 * if battery plugged.
543 */
544 case ACPI_DRV_IOC_STATUS:
545 if (bp->dev.present == 0) {
546 res = ENXIO;
547 break;
548 }
549
550 res = acpi_drv_update_bst(bp);
551 if (res != ACPI_DRV_OK) {
552 break;
553 }
554 if (copyout(&bp->bst_cache, (void *)arg,
555 sizeof (bp->bst_cache))) {
556 res = EFAULT;
557 }
558 break;
559
560 /* Return the state of the battery bays in the system */
561 case ACPI_DRV_IOC_BAY:
562 {
563 batt_bay_t bay;
564
565 bay.bay_number = nbat;
566 bay.battery_map = 0;
567 for (bp = &acpi_drv_cbat[0];
568 bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM]; bp++) {
569 if (bp->dev.valid) {
570 if (bp->dev.present) {
571 bay.battery_map |=
572 (1 << bp->dev.index);
573 }
574 }
575 }
576 if (copyout(&bay, (void *)arg, sizeof (bay))) {
577 res = EFAULT;
578 break;
579 }
580 }
581 break;
582
583 /*
584 * Return the current power source device if available:
585 * 0 -- battery supplying power
586 * 1 -- AC supplying power
587 */
588 case ACPI_DRV_IOC_POWER_STATUS:
589 {
590 int val;
591
592 /* State not available */
593 if (acpi_drv_psr_type == ACPI_DRV_TYPE_UNKNOWN) {
594 res = ENXIO;
595 break;
596 }
597 val = (acpi_drv_psr_type == ACPI_DRV_TYPE_AC) ? 1 : 0;
598 if (copyout(&val, (void *)arg, sizeof (val))) {
599 res = EFAULT;
600 break;
601 }
602 }
603 break;
604
605 /* Get charge-warn and charge-low levels for the whole system */
606 case ACPI_DRV_IOC_GET_WARNING:
607 bwarn.bw_enabled = acpi_drv_warn_enabled;
608 bwarn.bw_charge_warn = acpi_drv_syn_warn_per;
609 bwarn.bw_charge_low = acpi_drv_syn_low_per;
610 if (copyout(&bwarn, (void *)arg, sizeof (&bwarn))) {
611 res = EFAULT;
612 }
613 break;
614
615 /* Set charge-warn and charge-low levels for the whole system */
616 case ACPI_DRV_IOC_SET_WARNING:
617 if (drv_priv(cr)) {
618 res = EPERM;
619 break;
620 }
621 if (copyin((void *)arg, &bwarn, sizeof (bwarn))) {
622 res = EFAULT;
623 break;
624 }
625 res = acpi_drv_set_warn(&bwarn);
626 break;
627
628 default:
629 res = EINVAL;
630 break;
631 }
632
633 return (res);
634 }
635
636 /*ARGSUSED*/
637 static int
638 acpi_drv_ac_ioctl(int index, int cmd, intptr_t arg, int mode, cred_t *cr,
639 int *rval)
640 {
641 int res = 0;
642 int ac_state;
643 struct acpi_drv_ac_state *acp;
644
645 ASSERT(mutex_owned(&acpi_drv_mutex));
646
647 acp = acpi_drv_idx2ac(index);
648 if (!acp || acp->dev.valid != 1) {
649 return (ENXIO);
650 }
651
652 switch (cmd) {
653 /* Return the number of AC adapters in the system */
654 case ACPI_DRV_IOC_AC_COUNT:
655 if (copyout(&nac, (void *)arg, sizeof (nac))) {
656 res = EFAULT;
657 }
658 break;
659
660 /*
661 * Return the state of AC[index] if available:
662 * 0 -- Off-line
663 * 1 -- On-line
664 */
665 case ACPI_DRV_IOC_POWER_STATUS:
666 if (!acp || acp->dev.valid != 1) {
667 res = ENXIO;
668 break;
669 }
670 /* State not available */
671 if ((ac_state = acpi_drv_ac_present(acp)) == -1) {
672 res = ENXIO;
673 break;
674 }
675 if (copyout(&ac_state, (void *)arg, sizeof (ac_state))) {
676 res = EFAULT;
677 }
678 break;
679
680 default:
681 res = EINVAL;
682 break;
683 }
684
685 return (res);
686 }
687
688 /*ARGSUSED*/
689 static int
690 acpi_drv_lid_ioctl(int index, int cmd, intptr_t arg, int mode, cred_t *cr,
691 int *rval)
692 {
693 int res = 0;
694
695 /*
696 * lid.state 0 means lid is closed.
697 * lid.state non-zero means lid is open.
698 */
699 switch (cmd) {
700 case ACPI_DRV_IOC_LID_STATUS:
701 if (lid.state_ok == ACPI_DRV_NTF_UNKNOWN) {
702 /* State not available */
703 res = acpi_drv_update_lid(&lid.dev);
704 if (res != ACPI_DRV_OK) {
705 res = ENXIO;
706 break;
707 }
708 }
709 if (copyout(&lid.state, (void *)arg, sizeof (lid.state))) {
710 res = EFAULT;
711 }
712 break;
713 case ACPI_DRV_IOC_LID_UPDATE:
714 res = acpi_drv_update_lid(&lid.dev);
715 if (res != ACPI_DRV_OK) {
716 res = ENXIO;
717 break;
718 }
719 if (copyout(&lid.state, (void *)arg, sizeof (lid.state))) {
720 res = EFAULT;
721 }
722 break;
723
724 default:
725 res = EINVAL;
726 break;
727 }
728 return (res);
729 }
730
731 /*ARGSUSED*/
732 static int
733 acpi_drv_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
734 struct pollhead **phpp)
735 {
736 if (!anyyet) {
737 *phpp = &acpi_drv_pollhead;
738 }
739 *reventsp = 0;
740 return (0);
741 }
742
743 #ifdef DEBUG
744 static void
745 acpi_drv_printf(struct acpi_drv_dev *devp, uint_t lev,
746 const char *fmt, ...)
747 {
748 va_list args;
749
750 mutex_enter(&acpi_drv_prt_mutex);
751
752 va_start(args, fmt);
753 (void) vsprintf(acpi_drv_prt_buf, fmt, args);
754 va_end(args);
755
756 if (devp) {
757 cmn_err(lev, "%s.%s: %s", devp->hid, devp->uid,
758 acpi_drv_prt_buf);
759 } else {
760 cmn_err(lev, "%s", acpi_drv_prt_buf);
761 }
762 mutex_exit(&acpi_drv_prt_mutex);
763 }
764
765 static void
766 acpi_drv_prt_notify(ACPI_HANDLE hdl, UINT32 val)
767 {
768 ACPI_BUFFER buf;
769 char str[1024];
770
771 buf.Length = sizeof (str);
772 buf.Pointer = str;
773 (void) AcpiGetName(hdl, ACPI_FULL_PATHNAME, &buf);
774 cmn_err(CE_NOTE, "AcpiNotify(%s, 0x%02x)", str, val);
775 }
776 #endif /* DEBUG */
777
778 void
779 acpi_drv_gen_sysevent(struct acpi_drv_dev *devp, char *ev, uint32_t val)
780 {
781 nvlist_t *attr_list = NULL;
782 int err;
783 char pathname[MAXPATHLEN];
784
785 /* Allocate and build sysevent attribute list */
786 err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
787 if (err != 0) {
788 ACPI_DRV_DBG(CE_WARN, NULL,
789 "cannot allocate memory for sysevent attributes\n");
790 return;
791 }
792
793 /* Add attributes */
794 err = nvlist_add_string(attr_list, PWRCTL_DEV_HID, devp->hid);
795 if (err != 0) {
796 ACPI_DRV_DBG(CE_WARN, NULL,
797 "Failed to add attr [%s] for %s/%s event",
798 PWRCTL_DEV_HID, EC_PWRCTL, ev);
799 nvlist_free(attr_list);
800 return;
801 }
802
803 err = nvlist_add_string(attr_list, PWRCTL_DEV_UID, devp->uid);
804 if (err != 0) {
805 ACPI_DRV_DBG(CE_WARN, NULL,
806 "Failed to add attr [%s] for %s/%s event",
807 PWRCTL_DEV_UID, EC_PWRCTL, ev);
808 nvlist_free(attr_list);
809 return;
810 }
811
812 err = nvlist_add_uint32(attr_list, PWRCTL_DEV_INDEX, devp->index);
813 if (err != 0) {
814 ACPI_DRV_DBG(CE_WARN, NULL,
815 "Failed to add attr [%s] for %s/%s event",
816 PWRCTL_DEV_INDEX, EC_PWRCTL, ev);
817 nvlist_free(attr_list);
818 return;
819 }
820
821 (void) ddi_pathname(acpi_drv_dip, pathname);
822 err = nvlist_add_string(attr_list, PWRCTL_DEV_PHYS_PATH, pathname);
823 if (err != 0) {
824 ACPI_DRV_DBG(CE_WARN, NULL,
825 "Failed to add attr [%s] for %s/%s event",
826 PWRCTL_DEV_PHYS_PATH, EC_PWRCTL, ev);
827 nvlist_free(attr_list);
828 return;
829 }
830
831 if (strcmp(ev, ESC_PWRCTL_WARN) && strcmp(ev, ESC_PWRCTL_LOW)) {
832 goto finish;
833 }
834
835 err = nvlist_add_uint32(attr_list, PWRCTL_CHARGE_LEVEL, val);
836 if (err != 0) {
837 ACPI_DRV_DBG(CE_WARN, NULL,
838 "Failed to add attr [%s] for %s/%s event",
839 PWRCTL_CHARGE_LEVEL, EC_PWRCTL, ev);
840 nvlist_free(attr_list);
841 return;
842 }
843
844 finish:
845 ACPI_DRV_DBG(CE_NOTE, NULL, "SysEv(%s, %s.%s, %d)",
846 ev, devp->hid, devp->uid, val);
847 /* Generate/log sysevent */
848 err = ddi_log_sysevent(acpi_drv_dip, DDI_VENDOR_SUNW, EC_PWRCTL,
849 ev, attr_list, NULL, DDI_NOSLEEP);
850 #ifdef DEBUG
851 if (err != DDI_SUCCESS) {
852 ACPI_DRV_DBG(CE_WARN, NULL,
853 "cannot log sysevent, err code %x\n", err);
854 }
855 #endif
856
857 nvlist_free(attr_list);
858 }
859
860 static int
861 acpi_drv_obj_copy(ACPI_OBJECT *op, char *bp, struct obj_desc *dp)
862 {
863 ACPI_OBJECT *ep;
864 char *fp;
865
866 ep = &op->Package.Elements[0];
867 for (; dp->offset != -1; dp++) {
868 fp = bp + dp->offset;
869 if (dp->type == ACPI_TYPE_INTEGER &&
870 ep->Type == dp->type) {
871 #ifdef DEBUG
872 if (dp->size <= 4) {
873 ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: %u",
874 dp->name,
875 (uint32_t)ep->Integer.Value);
876 } else {
877 #ifdef _LP64
878 ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: %lu",
879 dp->name, (uint64_t)ep->Integer.Value);
880 }
881 #else
882 ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: %llu",
883 dp->name, (uint64_t)ep->Integer.Value);
884 }
885 #endif /* _LP64 */
886 #endif /* DEBUG */
887 *(uint32_t *)fp = ep->Integer.Value;
888 } else if (dp->type == ACPI_TYPE_STRING &&
889 ep->Type == dp->type) {
890 ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: \"%s\"",
891 dp->name, ep->String.Pointer);
892 (void) strlcpy(fp, ep->String.Pointer, dp->size);
893 } else if (dp->type == ACPI_TYPE_STRING &&
894 ep->Type == ACPI_TYPE_BUFFER) {
895 #ifdef DEBUG
896 int len;
897 char buf[MAXNAMELEN + 1];
898
899 len = (MAXNAMELEN < ep->Buffer.Length) ?
900 MAXNAMELEN : ep->Buffer.Length;
901 bcopy(ep->Buffer.Pointer, buf, len);
902 buf[len] = 0;
903 ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: [%d] \"%s\"",
904 dp->name, len, buf);
905 #endif
906
907 ASSERT(MAXNAMELEN >= ep->Buffer.Length);
908 bcopy(ep->Buffer.Pointer, fp, ep->Buffer.Length);
909 } else {
910 ACPI_DRV_DBG(CE_WARN, NULL,
911 "Bad field at offset %d: type %d",
912 dp->offset, ep->Type);
913 if (dp->type != ACPI_TYPE_STRING) {
914 return (ACPI_DRV_ERR);
915 }
916 }
917 ep++;
918 }
919
920 return (ACPI_DRV_OK);
921 }
922
923 /*
924 * Returns the current power source devices. Used for the AC adapter and is
925 * located under the AC adapter object in name space. Used to determine if
926 * system is running off the AC adapter. This will report that the system is
927 * not running on the AC adapter if any of the batteries in the system is
928 * being forced to discharge through _BMC.
929 *
930 * Return value:
931 * 0 -- Off-line, ie. battery supplying system power
932 * 1 -- On-line, ie. AC supplying system power
933 * -1 -- Unknown, some error ocurred.
934 * Note: It will also update the driver ac state.
935 */
936 static int
937 acpi_drv_get_psr(struct acpi_drv_ac_state *acp)
938 {
939 struct acpi_drv_dev *devp = &acp->dev;
940 int ac;
941
942 if (!devp->valid) {
943 ACPI_DRV_DBG(CE_WARN, NULL, "device not valid");
944 return (-1);
945 }
946
947 if (acpica_eval_int(devp->hdl, "_PSR", &ac) == AE_OK) {
948 ACPI_DRV_DBG(CE_NOTE, devp, "_PSR = %d", ac);
949 devp->present = ac;
950 } else {
951 ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _PSR failed");
952 devp->present = -1;
953 }
954
955 return (ac);
956 }
957
958 /*
959 * For most systems, the _STA for this device will always
960 * return a value with bits 0-3 set and will toggle bit 4
961 * to indicate the actual presence of a battery.
962 *
963 * Return value:
964 * 0 -- battery not present
965 * 1 -- battery present
966 * -1 -- Unknown, some error ocurred.
967 * Note: It will also update the driver cbat state.
968 */
969 static int
970 acpi_drv_get_sta(struct acpi_drv_cbat_state *bp)
971 {
972 struct acpi_drv_dev *devp = &bp->dev;
973 int val;
974
975 if (!devp->valid) {
976 ACPI_DRV_DBG(CE_WARN, NULL, "device not valid");
977 return (-1);
978 }
979
980 if (acpica_eval_int(devp->hdl, "_STA", &val) == AE_OK) {
981 ACPI_DRV_DBG(CE_NOTE, devp, "_STA = 0x%x", val);
982 devp->present = ((val & STA_FLAG_BATT_PRESENT) != 0);
983 } else {
984 ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _STA failed");
985 devp->present = -1;
986 }
987
988 return (val);
989 }
990
991 static int
992 acpi_drv_update_bif(struct acpi_drv_cbat_state *bp)
993 {
994 ACPI_BUFFER buf;
995 ACPI_OBJECT *objp;
996
997 /* BIF is only available when battery plugged */
998 ASSERT(bp->dev.present != 0);
999
1000 /* Update internal BIF cache */
1001 bp->bat_bifok = ACPI_DRV_NTF_UNKNOWN;
1002
1003 buf.Length = ACPI_ALLOCATE_BUFFER;
1004 if (ACPI_FAILURE(AcpiEvaluateObjectTyped(bp->dev.hdl, "_BIF",
1005 NULL, &buf, ACPI_TYPE_PACKAGE))) {
1006 ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _BIF failed");
1007 return (ACPI_DRV_ERR);
1008 }
1009
1010 objp = buf.Pointer;
1011 ACPI_DRV_DBG(CE_NOTE, &bp->dev, "get _BIF");
1012 if (acpi_drv_obj_copy(objp, (char *)&bp->bif_cache, bif_desc) ==
1013 ACPI_DRV_ERR) {
1014 AcpiOsFree(objp);
1015 return (ACPI_DRV_ERR);
1016 }
1017 AcpiOsFree(objp);
1018 bp->bat_bifok = ACPI_DRV_NTF_OK;
1019 return (ACPI_DRV_OK);
1020 }
1021
1022 static int
1023 acpi_drv_update_bst(struct acpi_drv_cbat_state *bp)
1024 {
1025 ACPI_BUFFER buf;
1026 ACPI_OBJECT *objp;
1027
1028 /* BST is only available when battery plugged */
1029 ASSERT(bp->dev.present != 0);
1030
1031 /* Update internal BST cache */
1032 bp->bat_bstok = ACPI_DRV_NTF_UNKNOWN;
1033
1034 buf.Length = ACPI_ALLOCATE_BUFFER;
1035 if (ACPI_FAILURE(AcpiEvaluateObjectTyped(bp->dev.hdl, "_BST",
1036 NULL, &buf, ACPI_TYPE_PACKAGE))) {
1037 ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _BST failed");
1038 return (ACPI_DRV_ERR);
1039 }
1040
1041 objp = buf.Pointer;
1042 ACPI_DRV_DBG(CE_NOTE, &bp->dev, "get _BST");
1043 if (acpi_drv_obj_copy(objp, (char *)&bp->bst_cache, bst_desc) ==
1044 ACPI_DRV_ERR) {
1045 AcpiOsFree(objp);
1046 return (ACPI_DRV_ERR);
1047 }
1048 AcpiOsFree(objp);
1049
1050 if (bp->bst_cache.bst_rate == 0) {
1051 bp->bst_cache.bst_state &= ~(ACPI_DRV_BST_CHARGING |
1052 ACPI_DRV_BST_DISCHARGING);
1053 }
1054 bp->bat_bstok = ACPI_DRV_NTF_OK;
1055 return (ACPI_DRV_OK);
1056 }
1057
1058 /*
1059 * Return value:
1060 * 1 -- device On-line
1061 * 0 -- device Off-line
1062 * -1 -- Unknown, some error ocurred.
1063 */
1064 static int
1065 acpi_drv_dev_present(struct acpi_drv_dev *devp)
1066 {
1067 if (!devp->valid) {
1068 ACPI_DRV_DBG(CE_WARN, NULL, "device not valid");
1069 return (-1);
1070 }
1071
1072 ASSERT(devp->type != ACPI_DRV_TYPE_UNKNOWN);
1073
1074 /* Update the device state */
1075 if (devp->present == -1) {
1076 if (devp->type == ACPI_DRV_TYPE_AC) {
1077 (void) acpi_drv_get_psr((struct acpi_drv_ac_state *)
1078 devp);
1079 } else if (devp->type == ACPI_DRV_TYPE_CBAT) {
1080 (void) acpi_drv_get_sta((struct acpi_drv_cbat_state *)
1081 devp);
1082 }
1083 }
1084
1085 return (devp->present);
1086 }
1087
1088 /*
1089 * Check if the device p existance state has changed.
1090 * Return value:
1091 * 1 -- changed
1092 * 0 -- no change
1093 * -1 -- unknown
1094 */
1095 static int
1096 acpi_drv_update_present(struct acpi_drv_dev *p)
1097 {
1098 int old_present = p->present;
1099 int new_present;
1100
1101 ASSERT(p && p->valid);
1102
1103 p->present = -1;
1104 new_present = acpi_drv_dev_present(p);
1105 if (new_present == -1) {
1106 return (-1);
1107 }
1108 if (new_present != old_present) {
1109 return (1);
1110 }
1111 return (0);
1112 }
1113
1114 static void
1115 acpi_drv_set_psr(struct acpi_drv_dev *p)
1116 {
1117 acpi_drv_psr_devp = p;
1118 if (p != NULL) {
1119 ACPI_DRV_DBG(CE_NOTE, p, "psr = .");
1120 acpi_drv_psr_type = p->type;
1121 } else {
1122 ACPI_DRV_DBG(CE_NOTE, p, "psr = ?");
1123 acpi_drv_psr_type = ACPI_DRV_TYPE_UNKNOWN;
1124 }
1125 }
1126
1127 /*
1128 * OSPM can determine independent warning and low battery
1129 * capacity values based on the OEM-designed levels, but
1130 * cannot set these values lower than the OEM-designed values.
1131 */
1132 static int
1133 acpi_drv_set_warn(acpi_drv_warn_t *bwp)
1134 {
1135 uint32_t warn, low;
1136
1137 warn = acpi_drv_syn_last_cap * bwp->bw_charge_warn / 100;
1138 low = acpi_drv_syn_last_cap * bwp->bw_charge_low / 100;
1139
1140 /* Update internal state */
1141 if (bwp->bw_enabled) {
1142 if (low >= warn || warn < acpi_drv_syn_oem_warn_cap ||
1143 low < acpi_drv_syn_oem_low_cap) {
1144 ACPI_DRV_DBG(CE_WARN, NULL, "charge level error");
1145 return (EINVAL);
1146 }
1147
1148 ACPI_DRV_DBG(CE_NOTE, NULL, "set warn: warn=%d low=%d", warn,
1149 low);
1150
1151 acpi_drv_syn_warn_per = bwp->bw_charge_warn;
1152 acpi_drv_syn_low_per = bwp->bw_charge_low;
1153 acpi_drv_syn_warn_cap = warn;
1154 acpi_drv_syn_low_cap = low;
1155 acpi_drv_warn_enabled = 1;
1156 } else {
1157 acpi_drv_warn_enabled = 0;
1158 }
1159
1160 return (0);
1161 }
1162
1163 /*
1164 * Update information for the synthesis battery
1165 *
1166 * Note: Sometimes the value to be returned from _BST or _BIF will be
1167 * temporarily unknown. In this case, the method may return the value
1168 * 0xFFFFFFFF as a placeholder. When the value becomes known, the
1169 * appropriate notification (0x80 for _BST or 0x81 for BIF) should be
1170 * issued, in like manner to any other change in the data returned by
1171 * these methods. This will cause OSPM to re-evaluate the method obtaining
1172 * the correct data value.
1173 */
1174 static void
1175 acpi_drv_update_cap(int bif_changed)
1176 {
1177 struct acpi_drv_cbat_state *bp;
1178
1179 if (bif_changed != 0) {
1180 acpi_drv_syn_oem_warn_cap = 0xffffffff;
1181 acpi_drv_syn_oem_low_cap = 0xffffffff;
1182 acpi_drv_syn_last_cap = 0xffffffff;
1183 }
1184 acpi_drv_syn_last_level = acpi_drv_syn_rem_cap;
1185 acpi_drv_syn_rem_cap = 0xffffffff; /* initially unknown */
1186
1187 for (bp = &acpi_drv_cbat[0]; bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
1188 bp++) {
1189 if (bp->dev.valid) {
1190 /* Escape the empty bays */
1191 if (acpi_drv_cbat_present(bp) <= 0) {
1192 continue;
1193 }
1194
1195 if (bif_changed != 0 &&
1196 bp->bat_bifok == ACPI_DRV_NTF_OK) {
1197 acpi_bif_t *bif;
1198
1199 bif = &bp->bif_cache;
1200
1201 if (acpi_drv_syn_last_cap == 0xffffffff) {
1202 acpi_drv_syn_last_cap = 0;
1203 }
1204 acpi_drv_syn_last_cap += bif->bif_last_cap;
1205
1206 if (bif->bif_warn_cap == 0xffffffff ||
1207 bif->bif_low_cap == 0xffffffff) {
1208 ACPI_DRV_DBG(CE_WARN, &bp->dev,
1209 "BIF value "
1210 "invalid, warn_cap=0x%x "
1211 "low_cap=0x%x", bif->bif_warn_cap,
1212 bif->bif_low_cap);
1213 continue;
1214 }
1215 if (acpi_drv_syn_oem_warn_cap == 0xffffffff) {
1216 acpi_drv_syn_oem_warn_cap = 0;
1217 }
1218 if (acpi_drv_syn_oem_low_cap == 0xffffffff) {
1219 acpi_drv_syn_oem_low_cap = 0;
1220 }
1221
1222 /*
1223 * Use the highest level as the synthesis
1224 * level.
1225 */
1226 if (bif->bif_warn_cap >
1227 acpi_drv_syn_oem_warn_cap) {
1228 acpi_drv_syn_oem_low_cap =
1229 bif->bif_low_cap;
1230 acpi_drv_syn_oem_warn_cap =
1231 bif->bif_warn_cap;
1232 }
1233 }
1234 #ifdef DEBUG
1235 else if (bif_changed) {
1236 ACPI_DRV_DBG(CE_NOTE, &bp->dev,
1237 "BIF not ready");
1238 }
1239 #endif
1240
1241 if (bp->bat_bstok == ACPI_DRV_NTF_OK) {
1242 acpi_bst_t *bst;
1243
1244 bst = &bp->bst_cache;
1245
1246 /*
1247 * Batteries that are rechargeable and are in
1248 * the discharging state are required to return
1249 * a valid Battery Present Rate value.
1250 * 0xFFFFFFFF - Unknown rate/capacity
1251 */
1252 if (bst->bst_rem_cap == 0xffffffff) {
1253 ACPI_DRV_DBG(CE_WARN, &bp->dev,
1254 "BST value invalid, "
1255 "rate=0x%x cap=0x%x",
1256 bst->bst_rate, bst->bst_rem_cap);
1257 continue;
1258 }
1259
1260 if (acpi_drv_syn_rem_cap == 0xffffffff) {
1261 acpi_drv_syn_rem_cap = 0;
1262 }
1263 acpi_drv_syn_rem_cap += bst->bst_rem_cap;
1264 /* Check for overflow */
1265 ASSERT(acpi_drv_syn_rem_cap >=
1266 bst->bst_rem_cap);
1267 }
1268 #ifdef DEBUG
1269 else {
1270 ACPI_DRV_DBG(CE_NOTE, &bp->dev,
1271 "BST not ready");
1272 }
1273 #endif
1274 }
1275 }
1276
1277 ACPI_DRV_DBG(CE_NOTE, NULL, "syn_cap: %d syn_oem_warn: %d "
1278 "syn_oem_low: %d", acpi_drv_syn_rem_cap, acpi_drv_syn_oem_warn_cap,
1279 acpi_drv_syn_oem_low_cap);
1280 }
1281
1282 static struct acpi_drv_cbat_state *
1283 acpi_drv_idx2cbat(int idx)
1284 {
1285 if (idx >= ACPI_DRV_MAX_BAT_NUM) {
1286 return (NULL);
1287 }
1288 return (&acpi_drv_cbat[idx]);
1289 }
1290
1291 static struct acpi_drv_ac_state *
1292 acpi_drv_idx2ac(int idx)
1293 {
1294 if (idx >= ACPI_DRV_MAX_AC_NUM) {
1295 return (NULL);
1296 }
1297 return (&acpi_drv_ac[idx]);
1298 }
1299
1300 /*ARGSUSED*/
1301 static void
1302 acpi_drv_cbat_notify(ACPI_HANDLE hdl, UINT32 val, void *ctx)
1303 {
1304 struct acpi_drv_cbat_state *bp = ctx;
1305 struct acpi_drv_dev *devp = &bp->dev;
1306 int bif_changed;
1307 uint32_t eval;
1308 char *ev;
1309 acpi_bst_t *bst;
1310
1311 mutex_enter(&acpi_drv_mutex);
1312 ACPI_DRV_PRT_NOTIFY(hdl, val);
1313
1314 switch (val) {
1315 /*
1316 * BST has changed
1317 * Whenever the Battery State value changes, the
1318 * system will generate an SCI to notify the OS.
1319 *
1320 * Note: trip point is not used to implement the
1321 * warning levels.
1322 */
1323 case 0x80:
1324 /*
1325 * We always get 0x80 and 0x81 at battery plug/unplug,
1326 * but 0x80 may come first. In case that situation, we have
1327 * to update battery present state here too to update bst
1328 * correctly.
1329 */
1330 bif_changed = acpi_drv_update_present(devp);
1331
1332 if (devp->present == 0) {
1333 if (acpi_drv_psr_devp == devp) {
1334 acpi_drv_set_psr(NULL);
1335 }
1336 goto done;
1337 }
1338
1339 if (acpi_drv_update_bst(bp) != ACPI_DRV_OK) {
1340 break;
1341 }
1342 acpi_drv_update_cap(bif_changed);
1343
1344 bst = &bp->bst_cache;
1345 eval = bst->bst_rem_cap;
1346
1347 if (bst->bst_state & BST_FLAG_DISCHARGING) {
1348 acpi_drv_set_psr(devp);
1349 }
1350 /*
1351 * The Critical battery state indicates that all
1352 * available batteries are discharged and do not
1353 * appear to be able to supply power to run the
1354 * system any longer. When this occurs, the OS
1355 * should attempt to perform an emergency shutdown.
1356 * Right now we do not shutdown. This would
1357 * need some discussion first since it could be
1358 * controversial.
1359 */
1360 #ifdef DEBUG
1361 if (bst->bst_state & BST_FLAG_CRITICAL) {
1362 ACPI_DRV_DBG(CE_WARN, devp, "BST_FLAG_CRITICAL set");
1363
1364 /*
1365 * BST_FLAG_CRITICAL may set even with AC,
1366 * plugged, when plug/unplug battery. Check
1367 * to avoid erroneous shutdown.
1368 */
1369 if (acpi_drv_psr_devp == devp &&
1370 bst->bst_rem_cap != 0xffffffff) {
1371 ACPI_DRV_DBG(CE_WARN, NULL,
1372 "Battery in critical state");
1373 }
1374 } else
1375 #endif
1376 if (acpi_drv_warn_enabled &&
1377 (bst->bst_state & BST_FLAG_DISCHARGING)) {
1378 /*
1379 * This value is an estimation of the amount of
1380 * energy or battery capacity required by the
1381 * system to transition to any supported sleeping
1382 * state. When the OS detects that the total
1383 * available battery capacity is less than this
1384 * value, it will transition the system to a user
1385 * defined system state (S1-S5).
1386 */
1387 if (acpi_drv_syn_last_level > acpi_drv_syn_low_cap &&
1388 acpi_drv_syn_rem_cap <= acpi_drv_syn_low_cap) {
1389 acpi_drv_gen_sysevent(devp, ESC_PWRCTL_LOW,
1390 eval);
1391 /*
1392 * When the total available energy (mWh) or capacity
1393 * (mAh) in the batteries falls below this level,
1394 * the OS will notify the user through the UI.
1395 */
1396 } else if (acpi_drv_syn_last_level >
1397 acpi_drv_syn_warn_cap &&
1398 acpi_drv_syn_rem_cap <= acpi_drv_syn_warn_cap) {
1399 acpi_drv_gen_sysevent(devp, ESC_PWRCTL_WARN,
1400 eval);
1401 }
1402 }
1403
1404 done:
1405 acpi_drv_gen_sysevent(devp, ESC_PWRCTL_STATE_CHANGE, 0);
1406 pollwakeup(&acpi_drv_pollhead, ACPI_DRV_EVENTS);
1407 break;
1408
1409 /* battery has been removed completely */
1410 case 0x03:
1411 /* BIF has changed */
1412 case 0x81:
1413 /*
1414 * Note: Do not eliminate multiple ADD/REMOVE here,
1415 * because they may corresponding to different batterys.
1416 */
1417 (void) acpi_drv_update_present(devp);
1418 if (devp->present == 1) {
1419 if (acpi_drv_update_bif(bp) != ACPI_DRV_OK) {
1420 break;
1421 }
1422 }
1423
1424 acpi_drv_update_cap(1);
1425
1426 eval = devp->present;
1427 ev = eval ? ESC_PWRCTL_ADD : ESC_PWRCTL_REMOVE;
1428 acpi_drv_gen_sysevent(devp, ev, 0);
1429 pollwakeup(&acpi_drv_pollhead, ACPI_DRV_EVENTS);
1430 break;
1431
1432 case 0x82:
1433 default:
1434 break;
1435 }
1436
1437 mutex_exit(&acpi_drv_mutex);
1438 }
1439
1440 static int
1441 acpi_drv_update_lid(struct acpi_drv_dev *p)
1442 {
1443 struct acpi_drv_lid_state *lp = (struct acpi_drv_lid_state *)p;
1444
1445 if (acpica_eval_int(p->hdl, "_LID", &lp->state) == AE_OK) {
1446 lp->state_ok = ACPI_DRV_NTF_OK;
1447 return (ACPI_DRV_OK);
1448 }
1449 return (ACPI_DRV_ERR);
1450 }
1451
1452 /*ARGSUSED*/
1453 static void
1454 acpi_drv_ac_notify(ACPI_HANDLE hdl, UINT32 val, void *ctx)
1455 {
1456 struct acpi_drv_ac_state *acp = ctx;
1457 struct acpi_drv_dev *devp = &acp->dev;
1458 int old_present;
1459 char *ev;
1460 int eval;
1461
1462 ACPI_DRV_PRT_NOTIFY(hdl, val);
1463 if (val != 0x80) {
1464 return;
1465 }
1466
1467 mutex_enter(&acpi_drv_mutex);
1468 /*
1469 * Note: if unplug and then quickly plug back, two ADD
1470 * events will be generated.
1471 */
1472 old_present = devp->present;
1473 eval = acpi_drv_get_psr(acp);
1474
1475 /* Eliminate redundant events */
1476 if (eval != -1 && eval != old_present) {
1477 /* Keep tracking the current power source device */
1478 if (eval == 1) {
1479 ev = ESC_PWRCTL_ADD;
1480 acpi_drv_set_psr(devp);
1481 } else {
1482 ev = ESC_PWRCTL_REMOVE;
1483 /* If AC was supplying the power, it's not now */
1484 if (acpi_drv_psr_devp == devp) {
1485 acpi_drv_set_psr(NULL);
1486 }
1487 }
1488
1489 acpi_drv_gen_sysevent(devp, ev, 0);
1490 pollwakeup(&acpi_drv_pollhead, ACPI_DRV_EVENTS);
1491 }
1492
1493 mutex_exit(&acpi_drv_mutex);
1494 }
1495
1496 static void
1497 acpi_drv_lid_notify(ACPI_HANDLE hdl, UINT32 val, void *ctx)
1498 {
1499 struct acpi_drv_lid_state *p = ctx;
1500
1501 ACPI_DRV_PRT_NOTIFY(hdl, val);
1502 if (val == 0x80) {
1503 mutex_enter(&acpi_drv_mutex);
1504 if (acpi_drv_update_lid(&p->dev) == ACPI_DRV_OK) {
1505 acpi_drv_gen_sysevent(&p->dev, p->state ?
1506 ESC_PWRCTL_ADD : ESC_PWRCTL_REMOVE, 0);
1507 }
1508 mutex_exit(&acpi_drv_mutex);
1509 }
1510 }
1511
1512 static int
1513 acpi_drv_obj_init(struct acpi_drv_dev *p)
1514 {
1515 ACPI_DEVICE_INFO *info;
1516 ACPI_NOTIFY_HANDLER ntf_handler = NULL;
1517 ACPI_STATUS ret;
1518 char name[KSTAT_STRLEN];
1519
1520 ASSERT(p != NULL && p->hdl != NULL);
1521
1522 p->valid = 0;
1523
1524 /* Info size is variable depending on existance of _CID */
1525 ret = AcpiGetObjectInfo(p->hdl, &info);
1526 if (ACPI_FAILURE(ret)) {
1527 ACPI_DRV_DBG(CE_WARN, NULL,
1528 "AcpiGetObjectInfo() fail: %d", (int32_t)ret);
1529 return (ACPI_DRV_ERR);
1530 }
1531
1532 if ((info->Valid & ACPI_VALID_HID) == 0) {
1533 ACPI_DRV_DBG(CE_WARN, NULL,
1534 "AcpiGetObjectInfo(): _HID not available");
1535 p->hid[0] = 0;
1536 } else {
1537 (void) strlcpy(p->hid, info->HardwareId.String, ID_LEN);
1538 }
1539
1540 /*
1541 * This object is optional, but is required when the device
1542 * has no other way to report a persistent unique device ID.
1543 */
1544 if ((info->Valid & ACPI_VALID_UID) == 0) {
1545 ACPI_DRV_DBG(CE_WARN, NULL,
1546 "AcpiGetObjectInfo(): _UID not available");
1547 /* Use 0 as the default _UID */
1548 p->uid[0] = 0;
1549 } else {
1550 (void) strlcpy(p->uid, info->UniqueId.String, ID_LEN);
1551 }
1552
1553 AcpiOsFree(info);
1554 p->valid = 1;
1555
1556 if (strcmp(p->hid, ACPI_DEVNAME_CBAT) == 0) {
1557 struct acpi_drv_cbat_state *bp =
1558 (struct acpi_drv_cbat_state *)p;
1559 kstat_t *ksp;
1560
1561 p->type = ACPI_DRV_TYPE_CBAT;
1562 p->index = nbat - 1;
1563
1564 /* Update device present state */
1565 (void) acpi_drv_update_present(p);
1566 if (p->present) {
1567 (void) acpi_drv_update_bif(bp);
1568 (void) acpi_drv_update_bst(bp);
1569
1570 /* Init the current power source */
1571 if (bp->bst_cache.bst_state & BST_FLAG_DISCHARGING) {
1572 acpi_drv_set_psr(p);
1573 }
1574 }
1575 ntf_handler = acpi_drv_cbat_notify;
1576 ACPI_DRV_DBG(CE_NOTE, p, "battery %s",
1577 (p->present ? "present" : "absent"));
1578
1579 /* Create minor node for battery */
1580 (void) snprintf(name, sizeof (name), "battery%d", p->index);
1581 if (ddi_create_minor_node(acpi_drv_dip, name, S_IFCHR,
1582 MINOR_BATT(p->index), DDI_PSEUDO, 0) == DDI_FAILURE)
1583 ACPI_DRV_DBG(CE_WARN, NULL,
1584 "%s: minor node create failed", name);
1585
1586 /*
1587 * Allocate, initialize and install BIF and BST kstat
1588 */
1589 /* BIF kstat */
1590 (void) snprintf(name, KSTAT_STRLEN-1, "%s%d",
1591 ACPI_DRV_BIF_KSTAT_NAME, bp->dev.index);
1592 ksp = kstat_create(ACPI_DRV_NAME, 0, name, "misc",
1593 KSTAT_TYPE_NAMED,
1594 sizeof (acpi_drv_bif_kstat) / sizeof (kstat_named_t),
1595 KSTAT_FLAG_VIRTUAL);
1596 if (ksp != NULL) {
1597 ACPI_DRV_DBG(CE_NOTE, NULL, "kstat_create(%s) ok",
1598 name);
1599
1600 bp->bat_bif_ksp = ksp;
1601 ksp->ks_data = &acpi_drv_bif_kstat;
1602 ksp->ks_update = acpi_drv_kstat_bif_update;
1603 ksp->ks_data_size += MAXNAMELEN * 4;
1604 ksp->ks_private = bp;
1605
1606 kstat_install(ksp);
1607 } else {
1608 ACPI_DRV_DBG(CE_WARN, NULL,
1609 "kstat_create(%s) fail", name);
1610 }
1611
1612 /* BST kstat */
1613 (void) snprintf(name, KSTAT_STRLEN-1, "%s%d",
1614 ACPI_DRV_BST_KSTAT_NAME, bp->dev.index);
1615 ksp = kstat_create(ACPI_DRV_NAME, 0, name, "misc",
1616 KSTAT_TYPE_NAMED,
1617 sizeof (acpi_drv_bst_kstat) / sizeof (kstat_named_t),
1618 KSTAT_FLAG_VIRTUAL);
1619 if (ksp != NULL) {
1620 ACPI_DRV_DBG(CE_NOTE, NULL, "kstat_create(%s) ok",
1621 name);
1622
1623 bp->bat_bst_ksp = ksp;
1624 ksp->ks_data = &acpi_drv_bst_kstat;
1625 ksp->ks_update = acpi_drv_kstat_bst_update;
1626 ksp->ks_data_size += MAXNAMELEN * 4;
1627 ksp->ks_private = bp;
1628
1629 kstat_install(ksp);
1630 } else {
1631 ACPI_DRV_DBG(CE_WARN, NULL,
1632 "kstat_create(%s) fail", name);
1633 }
1634 } else if (strcmp(p->hid, ACPI_DEVNAME_AC) == 0) {
1635 p->type = ACPI_DRV_TYPE_AC;
1636 p->index = nac - 1;
1637
1638 /* Update device present state */
1639 (void) acpi_drv_update_present(p);
1640 if (p->present) {
1641 /* Init the current power source */
1642 acpi_drv_set_psr(p);
1643 }
1644 ntf_handler = acpi_drv_ac_notify;
1645 ACPI_DRV_DBG(CE_NOTE, p, "AC %s",
1646 (p->present ? "on-line" : "off-line"));
1647
1648 /* Create minor node for AC */
1649 (void) snprintf(name, sizeof (name), "ac%d", p->index);
1650 if (ddi_create_minor_node(acpi_drv_dip, name, S_IFCHR,
1651 MINOR_AC(p->index), DDI_PSEUDO, 0) == DDI_FAILURE)
1652 ACPI_DRV_DBG(CE_WARN, NULL,
1653 "%s: minor node create failed", name);
1654 } else if (strcmp(p->hid, ACPI_DEVNAME_LID) == 0) {
1655 p->type = ACPI_DRV_TYPE_LID;
1656 p->index = 0;
1657 lid.state_ok = ACPI_DRV_NTF_UNKNOWN;
1658 (void) acpi_drv_update_lid(p);
1659 ntf_handler = acpi_drv_lid_notify;
1660 ACPI_DRV_DBG(CE_NOTE, p, "added");
1661
1662 /* Create minor node for lid. */
1663 if (ddi_create_minor_node(acpi_drv_dip, "lid", S_IFCHR,
1664 MINOR_LID(p->index), DDI_PSEUDO, 0) == DDI_FAILURE)
1665 ACPI_DRV_DBG(CE_WARN, NULL,
1666 "lid: minor node create failed");
1667 } else {
1668 ACPI_DRV_DBG(CE_NOTE, p, "unknown device");
1669 p->valid = 0;
1670 }
1671
1672 /* Register ACPI battery related events */
1673 if (ntf_handler != NULL) {
1674 if (ACPI_FAILURE(AcpiInstallNotifyHandler(p->hdl,
1675 ACPI_ALL_NOTIFY, ntf_handler, p))) {
1676 ACPI_DRV_DBG(CE_NOTE, NULL,
1677 "Notify handler for %s.%s install failed",
1678 p->hid, p->uid);
1679 return (ACPI_DRV_ERR);
1680 }
1681 }
1682
1683 return (ACPI_DRV_OK);
1684 }
1685
1686 /*ARGSUSED*/
1687 static ACPI_STATUS
1688 acpi_drv_find_cb(ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context,
1689 void **ReturnValue)
1690 {
1691 struct acpi_drv_dev *devp;
1692 int *type = (int *)Context;
1693
1694 if (*type == ACPI_DRV_TYPE_CBAT) {
1695 struct acpi_drv_cbat_state *bp;
1696
1697 for (bp = acpi_drv_cbat;
1698 bp != &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
1699 bp++)
1700 if (bp->dev.hdl == ObjHandle)
1701 return (AE_OK);
1702
1703 if (nbat == ACPI_DRV_MAX_BAT_NUM) {
1704 ACPI_DRV_DBG(CE_WARN, NULL,
1705 "Need to support more batteries: "
1706 "BATTERY_MAX = %d", ACPI_DRV_MAX_BAT_NUM);
1707 return (AE_LIMIT);
1708 }
1709 bp = &acpi_drv_cbat[nbat++];
1710 devp = (struct acpi_drv_dev *)bp;
1711 } else if (*type == ACPI_DRV_TYPE_AC) {
1712 struct acpi_drv_ac_state *ap;
1713
1714 for (ap = acpi_drv_ac;
1715 ap != &acpi_drv_ac[ACPI_DRV_MAX_AC_NUM];
1716 ap++)
1717 if (ap->dev.hdl == ObjHandle)
1718 return (AE_OK);
1719
1720 if (nac == ACPI_DRV_MAX_AC_NUM) {
1721 ACPI_DRV_DBG(CE_WARN, NULL, "Need to support more ACs: "
1722 "AC_MAX = %d", ACPI_DRV_MAX_AC_NUM);
1723 return (AE_LIMIT);
1724 }
1725 ap = &acpi_drv_ac[nac++];
1726 devp = (struct acpi_drv_dev *)ap;
1727 } else if (*type == ACPI_DRV_TYPE_LID) {
1728 struct acpi_drv_lid_state *lp;
1729
1730 lp = &lid;
1731 if (lp->dev.hdl == ObjHandle)
1732 return (AE_OK);
1733
1734 nlid++;
1735 devp = (struct acpi_drv_dev *)lp;
1736 } else {
1737 ACPI_DRV_DBG(CE_WARN, NULL, "acpi_drv_find_cb(): "
1738 "Unknown device");
1739 return (AE_ERROR);
1740 }
1741
1742 devp->hdl = ObjHandle;
1743
1744 /* Try to get as many working objs as possible */
1745 (void) acpi_drv_obj_init(devp);
1746 return (AE_OK);
1747 }
1748
1749 /*ARGSUSED*/
1750 static void
1751 acpi_drv_cbat_rescan(void *arg)
1752 {
1753 int *retp, type = ACPI_DRV_TYPE_CBAT;
1754
1755 mutex_enter(&acpi_drv_mutex);
1756
1757 /*
1758 * The detach routine clears the timeout id to tell us not to
1759 * reschedule ourselves. If thats the case there's also no point
1760 * in looking for new ACPI battery devices, so just return.
1761 */
1762 if (acpi_drv_cbat_rescan_timeout == 0) {
1763 mutex_exit(&acpi_drv_mutex);
1764 return;
1765 }
1766
1767 (void) AcpiGetDevices(ACPI_DEVNAME_CBAT, acpi_drv_find_cb, &type,
1768 (void *)&retp);
1769
1770 acpi_drv_cbat_rescan_timeout = timeout(acpi_drv_cbat_rescan, NULL,
1771 drv_usectohz(MICROSEC));
1772 mutex_exit(&acpi_drv_mutex);
1773 }
1774
1775 static int
1776 acpi_drv_acpi_init(void)
1777 {
1778 int *retp, type;
1779 int status = ACPI_DRV_ERR;
1780 hotkey_drv_t *htkp;
1781
1782 /* Check to see if ACPI CA services are available */
1783 if (AcpiSubsystemStatus() != AE_OK) {
1784 ACPI_DRV_DBG(CE_WARN, NULL, "ACPI CA not ready");
1785 return (status);
1786 }
1787
1788 /* Init Control Method Batterys */
1789 type = ACPI_DRV_TYPE_CBAT;
1790 if (ACPI_SUCCESS(AcpiGetDevices(ACPI_DEVNAME_CBAT, acpi_drv_find_cb,
1791 &type, (void *)&retp)) && nbat) {
1792 status = ACPI_DRV_OK;
1793 }
1794
1795 /* Init AC */
1796 type = ACPI_DRV_TYPE_AC;
1797 if (ACPI_SUCCESS(AcpiGetDevices(ACPI_DEVNAME_AC, acpi_drv_find_cb,
1798 &type, (void *)&retp)) && nac) {
1799 status = ACPI_DRV_OK;
1800 }
1801
1802 /* Init LID */
1803 type = ACPI_DRV_TYPE_LID;
1804 if (ACPI_SUCCESS(AcpiGetDevices(ACPI_DEVNAME_LID, acpi_drv_find_cb,
1805 &type, (void *)&retp)) && nlid) {
1806 status = ACPI_DRV_OK;
1807 }
1808
1809 /* Init Hotkey Device */
1810 type = ACPI_DRV_TYPE_HOTKEY;
1811 htkp = &acpi_hotkey;
1812 bzero(htkp, sizeof (hotkey_drv_t));
1813 htkp->dip = acpi_drv_dip;
1814 htkp->hotkey_lock = &acpi_drv_mutex;
1815 if (hotkey_init(htkp) == ACPI_DRV_OK) {
1816 status = ACPI_DRV_OK;
1817 }
1818
1819 acpi_drv_update_cap(1);
1820
1821 return (status);
1822 }
1823
1824 static void
1825 acpi_drv_acpi_fini(void)
1826 {
1827 int i;
1828 struct acpi_drv_cbat_state *bp;
1829
1830 for (bp = &acpi_drv_cbat[0]; bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
1831 bp++) {
1832 if (bp->dev.valid) {
1833 (void) AcpiRemoveNotifyHandler(bp->dev.hdl,
1834 ACPI_DEVICE_NOTIFY, acpi_drv_cbat_notify);
1835 }
1836 }
1837 for (i = 0; i < nac; i++) {
1838 (void) AcpiRemoveNotifyHandler(acpi_drv_ac[i].dev.hdl,
1839 ACPI_DEVICE_NOTIFY, acpi_drv_ac_notify);
1840 }
1841 (void) AcpiRemoveNotifyHandler(lid.dev.hdl, ACPI_DEVICE_NOTIFY,
1842 acpi_drv_lid_notify);
1843
1844 if (acpi_hotkey.hotkey_method != HOTKEY_METHOD_NONE)
1845 (void) hotkey_fini(&acpi_hotkey);
1846 }
1847
1848 /*ARGSUSED*/
1849 static int
1850 acpi_drv_kstat_power_update(kstat_t *ksp, int flag)
1851 {
1852 if (flag == KSTAT_WRITE) {
1853 return (EACCES);
1854 }
1855
1856 mutex_enter(&acpi_drv_mutex);
1857 if (acpi_drv_psr_type == ACPI_DRV_TYPE_UNKNOWN) {
1858 mutex_exit(&acpi_drv_mutex);
1859 return (EIO);
1860 }
1861 kstat_named_setstr(&acpi_drv_power_kstat.acpi_drv_power,
1862 acpi_drv_psr_type == ACPI_DRV_TYPE_AC ? AC : BATTERY);
1863 acpi_drv_power_kstat.acpi_drv_supported_battery_count.value.ui32 =
1864 (uint32_t)nbat;
1865 mutex_exit(&acpi_drv_mutex);
1866
1867 return (0);
1868 }
1869
1870 /*ARGSUSED*/
1871 static int
1872 acpi_drv_kstat_warn_update(kstat_t *ksp, int flag)
1873 {
1874 if (flag == KSTAT_WRITE) {
1875 int ret = 0;
1876 acpi_drv_warn_t bw;
1877 acpi_drv_warn_kstat_t kbw;
1878
1879 kbw = *(acpi_drv_warn_kstat_t *)acpi_drv_warn_ksp->ks_data;
1880
1881 mutex_enter(&acpi_drv_mutex);
1882 bw.bw_enabled = kbw.acpi_drv_bw_enabled.value.ui32;
1883 bw.bw_charge_warn = kbw.acpi_drv_bw_charge_warn.value.ui32;
1884 bw.bw_charge_low = kbw.acpi_drv_bw_charge_low.value.ui32;
1885 ret = acpi_drv_set_warn(&bw);
1886 mutex_exit(&acpi_drv_mutex);
1887
1888 return (ret);
1889 } else {
1890 acpi_drv_warn_kstat_t *wp = &acpi_drv_warn_kstat;
1891
1892 mutex_enter(&acpi_drv_mutex);
1893 wp->acpi_drv_bw_enabled.value.ui32 = acpi_drv_warn_enabled;
1894 wp->acpi_drv_bw_charge_warn.value.ui32 = acpi_drv_syn_warn_per;
1895 wp->acpi_drv_bw_charge_low.value.ui32 = acpi_drv_syn_low_per;
1896 mutex_exit(&acpi_drv_mutex);
1897
1898 return (0);
1899 }
1900 }
1901
1902 static int
1903 acpi_drv_kstat_bif_update(kstat_t *ksp, int flag)
1904 {
1905 struct acpi_drv_cbat_state *bp;
1906 acpi_bif_t *bif;
1907 acpi_drv_bif_kstat_t *kp;
1908
1909 if (flag == KSTAT_WRITE) {
1910 return (EACCES);
1911 }
1912
1913 bp = (struct acpi_drv_cbat_state *)ksp->ks_private;
1914 mutex_enter(&acpi_drv_mutex);
1915
1916 if (acpi_drv_cbat_present(bp) <= 0) {
1917 mutex_exit(&acpi_drv_mutex);
1918 return (ENXIO);
1919 }
1920
1921 bzero(&bif, sizeof (bif));
1922 if (acpi_drv_update_bif(bp) != ACPI_DRV_OK) {
1923 mutex_exit(&acpi_drv_mutex);
1924 return (ENXIO);
1925 }
1926
1927 bif = &bp->bif_cache;
1928 kp = &acpi_drv_bif_kstat;
1929
1930 /* Update BIF */
1931 kp->acpi_drv_bif_unit.value.ui32 = bif->bif_unit;
1932 kp->acpi_drv_bif_design_cap.value.ui32 = bif->bif_design_cap;
1933 kp->acpi_drv_bif_last_cap.value.ui32 = bif->bif_last_cap;
1934 kp->acpi_drv_bif_tech.value.ui32 = bif->bif_tech;
1935 kp->acpi_drv_bif_voltage.value.ui32 = bif->bif_voltage;
1936 kp->acpi_drv_bif_warn_cap.value.ui32 = bif->bif_warn_cap;
1937 kp->acpi_drv_bif_low_cap.value.ui32 = bif->bif_low_cap;
1938 kp->acpi_drv_bif_gran1_cap.value.ui32 = bif->bif_gran1_cap;
1939 kp->acpi_drv_bif_gran2_cap.value.ui32 = bif->bif_gran2_cap;
1940
1941 kstat_named_setstr(&kp->acpi_drv_bif_model, bif->bif_model);
1942 kstat_named_setstr(&kp->acpi_drv_bif_serial, bif->bif_serial);
1943 kstat_named_setstr(&kp->acpi_drv_bif_type, bif->bif_type);
1944 kstat_named_setstr(&kp->acpi_drv_bif_oem_info, bif->bif_oem_info);
1945
1946 mutex_exit(&acpi_drv_mutex);
1947 return (0);
1948 }
1949
1950 static int
1951 acpi_drv_kstat_bst_update(kstat_t *ksp, int flag)
1952 {
1953 struct acpi_drv_cbat_state *bp;
1954 acpi_bst_t *bst;
1955 acpi_drv_bst_kstat_t *kp;
1956
1957 if (flag == KSTAT_WRITE) {
1958 return (EACCES);
1959 }
1960
1961 bp = (struct acpi_drv_cbat_state *)ksp->ks_private;
1962 mutex_enter(&acpi_drv_mutex);
1963
1964 if (acpi_drv_cbat_present(bp) <= 0) {
1965 mutex_exit(&acpi_drv_mutex);
1966 return (ENXIO);
1967 }
1968
1969 bzero(&bst, sizeof (bst));
1970 if (acpi_drv_update_bst(bp) != ACPI_DRV_OK) {
1971 mutex_exit(&acpi_drv_mutex);
1972 return (ENXIO);
1973 }
1974
1975 bst = &bp->bst_cache;
1976 kp = &acpi_drv_bst_kstat;
1977
1978 /* Update BST */
1979 kp->acpi_drv_bst_state.value.ui32 = bst->bst_state;
1980 kp->acpi_drv_bst_rate.value.ui32 = bst->bst_rate;
1981 kp->acpi_drv_bst_rem_cap.value.ui32 = bst->bst_rem_cap;
1982 kp->acpi_drv_bst_voltage.value.ui32 = bst->bst_voltage;
1983
1984 mutex_exit(&acpi_drv_mutex);
1985 return (0);
1986 }
1987
1988 static int
1989 acpi_drv_kstat_init(void)
1990 {
1991 /*
1992 * Allocate, initialize and install powerstatus and
1993 * supported_battery_count kstat.
1994 */
1995 acpi_drv_power_ksp = kstat_create(ACPI_DRV_NAME, 0,
1996 ACPI_DRV_POWER_KSTAT_NAME, "misc",
1997 KSTAT_TYPE_NAMED,
1998 sizeof (acpi_drv_power_kstat) / sizeof (kstat_named_t),
1999 KSTAT_FLAG_VIRTUAL);
2000 if (acpi_drv_power_ksp == NULL) {
2001 ACPI_DRV_DBG(CE_WARN, NULL,
2002 "kstat_create(%s) fail", ACPI_DRV_POWER_KSTAT_NAME);
2003 return (ACPI_DRV_ERR);
2004 }
2005
2006 acpi_drv_power_ksp->ks_data = &acpi_drv_power_kstat;
2007 acpi_drv_power_ksp->ks_update = acpi_drv_kstat_power_update;
2008 acpi_drv_power_ksp->ks_data_size += MAXNAMELEN;
2009 kstat_install(acpi_drv_power_ksp);
2010
2011 /*
2012 * Allocate, initialize and install battery_capacity_warning kstat.
2013 */
2014 acpi_drv_warn_ksp = kstat_create(ACPI_DRV_NAME, 0,
2015 ACPI_DRV_BTWARN_KSTAT_NAME, "misc",
2016 KSTAT_TYPE_NAMED,
2017 sizeof (acpi_drv_warn_kstat) / sizeof (kstat_named_t),
2018 KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE);
2019 if (acpi_drv_warn_ksp == NULL) {
2020 ACPI_DRV_DBG(CE_WARN, NULL,
2021 "kstat_create(%s) fail", ACPI_DRV_BTWARN_KSTAT_NAME);
2022 return (ACPI_DRV_ERR);
2023 }
2024
2025 acpi_drv_warn_ksp->ks_data = &acpi_drv_warn_kstat;
2026 acpi_drv_warn_ksp->ks_update = acpi_drv_kstat_warn_update;
2027 kstat_install(acpi_drv_warn_ksp);
2028
2029 return (ACPI_DRV_OK);
2030 }
2031
2032 static void
2033 acpi_drv_kstat_fini()
2034 {
2035 struct acpi_drv_cbat_state *bp;
2036
2037 if (acpi_drv_power_ksp != NULL) {
2038 kstat_delete(acpi_drv_power_ksp);
2039 }
2040 if (acpi_drv_warn_ksp != NULL) {
2041 kstat_delete(acpi_drv_warn_ksp);
2042 }
2043 for (bp = &acpi_drv_cbat[0]; bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
2044 bp++) {
2045 if (bp->dev.valid) {
2046 if (bp->bat_bif_ksp != NULL) {
2047 kstat_delete(bp->bat_bif_ksp);
2048 }
2049 if (bp->bat_bst_ksp != NULL) {
2050 kstat_delete(bp->bat_bst_ksp);
2051 }
2052 }
2053 }
2054 }
2055
2056 int
2057 acpi_drv_set_int(ACPI_HANDLE dev, char *method, uint32_t aint)
2058 {
2059 ACPI_OBJECT_LIST al;
2060 ACPI_OBJECT ao;
2061
2062 al.Pointer = &ao;
2063 al.Count = 1;
2064 ao.Type = ACPI_TYPE_INTEGER;
2065 ao.Integer.Value = aint;
2066 return (AcpiEvaluateObject(dev, method, &al, NULL));
2067 }
2068
2069 int
2070 acpi_drv_dev_init(struct acpi_drv_dev *p)
2071 {
2072 ACPI_DEVICE_INFO *info;
2073 ACPI_STATUS ret;
2074
2075 ASSERT(p != NULL && p->hdl != NULL);
2076
2077 p->valid = 0;
2078
2079 /* Info size is variable depending on existance of _CID */
2080 ret = AcpiGetObjectInfo(p->hdl, &info);
2081 if (ACPI_FAILURE(ret)) {
2082 ACPI_DRV_DBG(CE_WARN, NULL,
2083 "AcpiGetObjectInfo() fail: %d", (int32_t)ret);
2084 return (ACPI_DRV_ERR);
2085 }
2086
2087 if ((info->Valid & ACPI_VALID_HID) == 0) {
2088 ACPI_DRV_DBG(CE_WARN, NULL,
2089 "!AcpiGetObjectInfo(): _HID not available");
2090 p->hid[0] = 0;
2091 } else {
2092 (void) strlcpy(p->hid, info->HardwareId.String, ID_LEN);
2093 }
2094
2095 /*
2096 * This object is optional, but is required when the device
2097 * has no other way to report a persistent unique device ID.
2098 */
2099 if ((info->Valid & ACPI_VALID_UID) == 0) {
2100 ACPI_DRV_DBG(CE_WARN, NULL,
2101 "!AcpiGetObjectInfo(): _UID not available");
2102 /* Use 0 as the default _UID */
2103 p->uid[0] = 0;
2104 } else {
2105 (void) strlcpy(p->uid, info->UniqueId.String, ID_LEN);
2106 }
2107
2108 if (info->Valid & ACPI_VALID_ADR) {
2109 p->valid = 1;
2110 p->type = ACPI_DRV_TYPE_HOTKEY;
2111 }
2112
2113 AcpiOsFree(info);
2114
2115 return (ACPI_DRV_OK);
2116 }