1 /* $NetBSD: acpi_display.c,v 1.25 2024/08/18 00:43:07 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2010 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Gregoire Sutre.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * ACPI Display Adapter Driver.
34 *
35 * Appendix B of the ACPI specification presents ACPI extensions for display
36 * adapters. Systems containing a built-in display adapter are required to
37 * implement these extensions (in their ACPI BIOS). This driver uses these
38 * extensions to provide generic support for brightness control and display
39 * switching.
40 *
41 * If brightness control methods are absent or non-functional, ACPI brightness
42 * notifications are relayed to the PMF framework.
43 *
44 * This driver sets the BIOS switch policy (_DOS method) as follows:
45 * - The BIOS should automatically switch the active display output, with no
46 * interaction required on the OS part.
47 * - The BIOS should not automatically control the brightness levels.
48 *
49 * Brightness and BIOS switch policy can be adjusted from userland, via the
50 * sysctl variables acpivga<n>.policy and acpiout<n>.brightness under hw.acpi.
51 */
52
53 /*
54 * The driver uses mutex(9) protection since changes to the hardware/software
55 * state may be initiated both by the BIOS (ACPI notifications) and by the user
56 * (sysctl). The ACPI display adapter's mutex is shared with all ACPI display
57 * output devices attached to it.
58 *
59 * The mutex only prevents undesired interleavings of ACPI notify handlers,
60 * sysctl callbacks, and pmf(9) suspend/resume routines. Race conditions with
61 * autoconf(9) detachment routines could, in theory, still occur.
62 *
63 * The array of connected output devices (sc_odinfo) is, after attachment, only
64 * used in ACPI notify handler callbacks. Since two such callbacks cannot be
65 * running simultaneously, this information does not need protection.
66 */
67
68 #include <sys/cdefs.h>
69 __KERNEL_RCSID(0, "$NetBSD: acpi_display.c,v 1.25 2024/08/18 00:43:07 riastradh Exp $");
70
71 #include <sys/param.h>
72 #include <sys/device.h>
73 #include <sys/kmem.h>
74 #include <sys/module.h>
75 #include <sys/mutex.h>
76 #include <sys/pserialize.h>
77 #include <sys/pslist.h>
78 #include <sys/sysctl.h>
79 #include <sys/systm.h>
80 #include <sys/xcall.h>
81
82 #include <dev/pci/pcireg.h>
83 #include <dev/pci/pcidevs.h>
84
85 #include <dev/acpi/acpi_display.h>
86 #include <dev/acpi/acpireg.h>
87 #include <dev/acpi/acpivar.h>
88
89 #define _COMPONENT ACPI_DISPLAY_COMPONENT
90 ACPI_MODULE_NAME ("acpi_display")
91
92 /* Notifications specific to display adapter devices (ACPI 4.0a, Sec. B.5). */
93 #define ACPI_NOTIFY_CycleOutputDevice 0x80
94 #define ACPI_NOTIFY_OutputDeviceStatusChange 0x81
95 #define ACPI_NOTIFY_CycleDisplayOutputHotkeyPressed 0x82
96 #define ACPI_NOTIFY_NextDisplayOutputHotkeyPressed 0x83
97 #define ACPI_NOTIFY_PreviousDisplayOutputHotkeyPressed 0x84
98
99 /* Notifications specific to display output devices (ACPI 4.0a, Sec. B.7). */
100 #define ACPI_NOTIFY_CycleBrightness 0x85
101 #define ACPI_NOTIFY_IncreaseBrightness 0x86
102 #define ACPI_NOTIFY_DecreaseBrightness 0x87
103 #define ACPI_NOTIFY_ZeroBrightness 0x88
104 #define ACPI_NOTIFY_DisplayDeviceOff 0x89
105
106 /* Format of the BIOS switch policy set by _DOS (ACPI 4.0a, Sec. B.4.1). */
107 typedef union acpidisp_bios_policy_t {
108 uint8_t raw;
109 struct {
110 uint8_t output:2;
111 uint8_t brightness:1;
112 uint8_t reserved:5;
113 } __packed fmt;
114 } acpidisp_bios_policy_t;
115
116 /* Default BIOS switch policy (ACPI 4.0a, Sec. B.4.1). */
117 static const acpidisp_bios_policy_t acpidisp_default_bios_policy = {
118 .raw = 0x1
119 };
120
121 /* BIOS output switch policies (ACPI 4.0a, Sec. B.4.1). */
122 #define ACPI_DISP_POLICY_OUTPUT_NORMAL 0x0
123 #define ACPI_DISP_POLICY_OUTPUT_AUTO 0x1
124 #define ACPI_DISP_POLICY_OUTPUT_LOCKED 0x2
125 #define ACPI_DISP_POLICY_OUTPUT_HOTKEY 0x3
126
127 /* BIOS brightness switch policies (ACPI 4.0a, Sec. B.4.1). */
128 #define ACPI_DISP_POLICY_BRIGHTNESS_AUTO 0x0
129 #define ACPI_DISP_POLICY_BRIGHTNESS_NORMAL 0x1
130
131 /* Format of output device attributes (ACPI 4.0a, Table B-2). */
132 typedef union acpidisp_od_attrs_t {
133 uint16_t device_id;
134 uint32_t raw;
135 struct {
136 uint8_t index:4;
137 uint8_t port:4;
138 uint8_t type:4;
139 uint8_t vendor_specific:4;
140 uint8_t bios_detect:1;
141 uint8_t non_vga:1;
142 uint8_t head_id:3;
143 uint16_t reserved:10;
144 uint8_t device_id_scheme:1;
145 } __packed fmt;
146 } acpidisp_od_attrs_t;
147
148 /* Common legacy output device IDs (ACPI 2.0c, Table B-3). */
149 #define ACPI_DISP_OUT_LEGACY_DEVID_MONITOR 0x0100
150 #define ACPI_DISP_OUT_LEGACY_DEVID_PANEL 0x0110
151 #define ACPI_DISP_OUT_LEGACY_DEVID_TV 0x0200
152
153 /* Output device display types (ACPI 4.0a, Table B-2). */
154 #define ACPI_DISP_OUT_ATTR_TYPE_OTHER 0x0
155 #define ACPI_DISP_OUT_ATTR_TYPE_VGA 0x1
156 #define ACPI_DISP_OUT_ATTR_TYPE_TV 0x2
157 #define ACPI_DISP_OUT_ATTR_TYPE_EXTDIG 0x3
158 #define ACPI_DISP_OUT_ATTR_TYPE_INTDFP 0x4
159
160 /* Format of output device status (ACPI 4.0a, Table B-4). */
161 typedef union acpidisp_od_status_t {
162 uint32_t raw;
163 struct {
164 uint8_t exists:1;
165 uint8_t activated:1;
166 uint8_t ready:1;
167 uint8_t not_defective:1;
168 uint8_t attached:1;
169 uint32_t reserved:27;
170 } __packed fmt;
171 } acpidisp_od_status_t;
172
173 /* Format of output device state (ACPI 4.0a, Table B-6). */
174 typedef union acpidisp_od_state_t {
175 uint32_t raw;
176 struct {
177 uint8_t active:1;
178 uint32_t reserved:29;
179 uint8_t no_switch:1;
180 uint8_t commit:1;
181 } __packed fmt;
182 } acpidisp_od_state_t;
183
184 /*
185 * acpidisp_outdev:
186 *
187 * Description of an ACPI display output device. This structure groups
188 * together:
189 * - the output device attributes, given in the display adapter's _DOD
190 * method (ACPI 4.0a, Sec. B.4.2).
191 * - the corresponding instance of the acpiout driver (if any).
192 */
193 struct acpidisp_outdev {
194 acpidisp_od_attrs_t od_attrs; /* Attributes */
195 device_t od_device; /* Matching base device */
196 };
197
198 /*
199 * acpidisp_odinfo:
200 *
201 * Information on connected output devices (ACPI 4.0a, Sec. B.4.2). This
202 * structure enumerates all devices (_DOD package) connected to a display
203 * adapter. Currently, this information is only used for display output
204 * switching via hotkey.
205 *
206 * Invariants (after initialization):
207 *
208 * (oi_dev != NULL) && (oi_dev_count > 0)
209 */
210 struct acpidisp_odinfo {
211 struct acpidisp_outdev *oi_dev; /* Array of output devices */
212 uint32_t oi_dev_count; /* Number of output devices */
213 };
214
215 /*
216 * acpidisp_vga_softc:
217 *
218 * Software state of an ACPI display adapter.
219 *
220 * Invariants (after attachment):
221 *
222 * ((sc_caps & ACPI_DISP_VGA_CAP__DOD) == 0) => (sc_odinfo == NULL)
223 */
224 struct acpidisp_vga_softc {
225 device_t sc_dev; /* Base device info */
226 struct acpi_devnode *sc_node; /* ACPI device node */
227 struct sysctllog *sc_log; /* Sysctl log */
228 kmutex_t sc_mtx; /* Mutex (shared w/ outputs) */
229 uint16_t sc_caps; /* Capabilities (methods) */
230 acpidisp_bios_policy_t sc_policy; /* BIOS switch policy (_DOS) */
231 struct acpidisp_odinfo *sc_odinfo; /* Connected output devices */
232 };
233
234 /*
235 * ACPI display adapter capabilities (methods).
236 */
237 #define ACPI_DISP_VGA_CAP__DOS __BIT(0)
238 #define ACPI_DISP_VGA_CAP__DOD __BIT(1)
239 #define ACPI_DISP_VGA_CAP__ROM __BIT(2)
240 #define ACPI_DISP_VGA_CAP__GPD __BIT(3)
241 #define ACPI_DISP_VGA_CAP__SPD __BIT(4)
242 #define ACPI_DISP_VGA_CAP__VPO __BIT(5)
243
244 /*
245 * acpidisp_acpivga_attach_args:
246 *
247 * Attachment structure for the acpivga interface. Used to attach display
248 * output devices under a display adapter.
249 */
250 struct acpidisp_acpivga_attach_args {
251 struct acpi_devnode *aa_node; /* ACPI device node */
252 kmutex_t *aa_mtx; /* Shared mutex */
253 };
254
255 /*
256 * acpidisp_brctl:
257 *
258 * Brightness control (ACPI 4.0a, Sec. B.6.2 to B.6.4). This structure
259 * contains the supported brightness levels (_BCL package) and the current
260 * level. Following Windows 7 brightness control, we ignore the fullpower
261 * and battery levels (as it simplifies the code).
262 *
263 * The array bc_level is sorted in strictly ascending order.
264 *
265 * Invariants (after initialization):
266 *
267 * (bc_level != NULL) && (bc_level_count > 0)
268 */
269 struct acpidisp_brctl {
270 uint8_t *bc_level; /* Array of levels */
271 uint16_t bc_level_count; /* Number of levels */
272 uint8_t bc_current; /* Current level */
273
274 /*
275 * Quirk if firmware returns wrong values for _BQC
276 * (acpidisp_get_brightness)
277 */
278 bool bc_bqc_broken;
279 };
280
281 /*
282 * Minimum brightness increment/decrement in response to increase/decrease
283 * brightness hotkey notifications. Must be strictly positive.
284 */
285 #define ACPI_DISP_BRCTL_STEP 5
286
287 /*
288 * acpidisp_out_softc:
289 *
290 * Software state of an ACPI display output device.
291 *
292 * Invariants (after attachment):
293 *
294 * ((sc_caps & ACPI_DISP_OUT_CAP__BCL) == 0) => (sc_brctl == NULL)
295 * ((sc_caps & ACPI_DISP_OUT_CAP__BCM) == 0) => (sc_brctl == NULL)
296 */
297 struct acpidisp_out_softc {
298 device_t sc_dev; /* Base device info */
299 struct acpi_devnode *sc_node; /* ACPI device node */
300 struct sysctllog *sc_log; /* Sysctl log */
301 kmutex_t *sc_mtx; /* Mutex (shared w/ adapter) */
302 uint16_t sc_caps; /* Capabilities (methods) */
303 struct acpidisp_brctl *sc_brctl; /* Brightness control */
304 };
305
306 /*
307 * ACPI display output device capabilities (methods).
308 */
309 #define ACPI_DISP_OUT_CAP__BCL __BIT(0)
310 #define ACPI_DISP_OUT_CAP__BCM __BIT(1)
311 #define ACPI_DISP_OUT_CAP__BQC __BIT(2)
312 #define ACPI_DISP_OUT_CAP__DDC __BIT(3)
313 #define ACPI_DISP_OUT_CAP__DCS __BIT(4)
314 #define ACPI_DISP_OUT_CAP__DGS __BIT(5)
315 #define ACPI_DISP_OUT_CAP__DSS __BIT(6)
316
317 static int acpidisp_vga_match(device_t, cfdata_t, void *);
318 static void acpidisp_vga_attach(device_t, device_t, void *);
319 static int acpidisp_vga_detach(device_t, int);
320 static void acpidisp_vga_childdetached(device_t, device_t);
321
322 static void acpidisp_vga_scan_outdevs(struct acpidisp_vga_softc *);
323 static int acpidisp_acpivga_print(void *, const char *);
324
325 static int acpidisp_out_match(device_t, cfdata_t, void *);
326 static void acpidisp_out_attach(device_t, device_t, void *);
327 static int acpidisp_out_detach(device_t, int);
328
329 CFATTACH_DECL2_NEW(acpivga, sizeof(struct acpidisp_vga_softc),
330 acpidisp_vga_match, acpidisp_vga_attach, acpidisp_vga_detach, NULL,
331 NULL, acpidisp_vga_childdetached);
332
333 CFATTACH_DECL_NEW(acpiout, sizeof(struct acpidisp_out_softc),
334 acpidisp_out_match, acpidisp_out_attach, acpidisp_out_detach, NULL);
335
336 static bool acpidisp_vga_resume(device_t, const pmf_qual_t *);
337 static bool acpidisp_out_suspend(device_t, const pmf_qual_t *);
338 static bool acpidisp_out_resume(device_t, const pmf_qual_t *);
339
340 static uint16_t acpidisp_vga_capabilities(const struct acpi_devnode *);
341 static uint16_t acpidisp_out_capabilities(const struct acpi_devnode *);
342 static void acpidisp_vga_print_capabilities(device_t, uint16_t);
343 static void acpidisp_out_print_capabilities(device_t, uint16_t);
344
345 static void acpidisp_vga_notify_handler(ACPI_HANDLE, uint32_t, void *);
346 static void acpidisp_out_notify_handler(ACPI_HANDLE, uint32_t, void *);
347
348 static void acpidisp_vga_cycle_output_device_callback(void *);
349 static void acpidisp_vga_output_device_change_callback(void *);
350 static void acpidisp_out_increase_brightness_callback(void *);
351 static void acpidisp_out_decrease_brightness_callback(void *);
352 static void acpidisp_out_cycle_brightness_callback(void *);
353 static void acpidisp_out_zero_brightness_callback(void *);
354
355 static void acpidisp_vga_sysctl_setup(struct acpidisp_vga_softc *);
356 static void acpidisp_out_sysctl_setup(struct acpidisp_out_softc *);
357 #ifdef ACPI_DEBUG
358 static int acpidisp_vga_sysctl_policy(SYSCTLFN_PROTO);
359 #endif
360 static int acpidisp_vga_sysctl_policy_output(SYSCTLFN_PROTO);
361 #ifdef ACPI_DISP_SWITCH_SYSCTLS
362 static int acpidisp_out_sysctl_status(SYSCTLFN_PROTO);
363 static int acpidisp_out_sysctl_state(SYSCTLFN_PROTO);
364 #endif
365 static int acpidisp_out_sysctl_brightness(SYSCTLFN_PROTO);
366
367 static struct acpidisp_odinfo *
368 acpidisp_init_odinfo(const struct acpidisp_vga_softc *);
369 static void acpidisp_vga_bind_outdevs(struct acpidisp_vga_softc *);
370 static struct acpidisp_brctl *
371 acpidisp_init_brctl(const struct acpidisp_out_softc *);
372
373 static int acpidisp_set_policy(const struct acpidisp_vga_softc *,
374 uint8_t);
375 static int acpidisp_get_status(const struct acpidisp_out_softc *,
376 uint32_t *);
377 static int acpidisp_get_state(const struct acpidisp_out_softc *,
378 uint32_t *);
379 static int acpidisp_set_state(const struct acpidisp_out_softc *,
380 uint32_t);
381 static int acpidisp_get_brightness(const struct acpidisp_out_softc *,
382 uint8_t *);
383 static int acpidisp_set_brightness(const struct acpidisp_out_softc *,
384 uint8_t);
385 static int acpidisp_quirk_get_brightness(const struct acpidisp_out_softc *);
386
387 static void acpidisp_print_odinfo(device_t, const struct acpidisp_odinfo *);
388 static void acpidisp_print_brctl(device_t, const struct acpidisp_brctl *);
389 static void acpidisp_print_od_attrs(acpidisp_od_attrs_t);
390
391 static bool acpidisp_has_method(ACPI_HANDLE, const char *,
392 ACPI_OBJECT_TYPE);
393 static ACPI_STATUS
394 acpidisp_eval_package(ACPI_HANDLE, const char *, ACPI_OBJECT **,
395 unsigned int);
396 static void acpidisp_array_search(const uint8_t *, uint16_t, int, uint8_t *,
397 uint8_t *);
398
399 /*
400 * Display notification callbacks -- used by i915
401 */
402
403 struct acpidisp_notifier {
404 void (*adn_func)(ACPI_HANDLE, uint32_t, void *);
405 void *adn_cookie;
406 struct pslist_entry adn_entry;
407 };
408
409 static struct {
410 kmutex_t lock;
411 struct pslist_head list;
412 } acpidisp_notifiers;
413
414 struct acpidisp_notifier *
acpidisp_register_notify(void (* func)(ACPI_HANDLE,uint32_t,void *),void * cookie)415 acpidisp_register_notify(void (*func)(ACPI_HANDLE, uint32_t, void *),
416 void *cookie)
417 {
418 struct acpidisp_notifier *adn;
419
420 adn = kmem_zalloc(sizeof(*adn), KM_SLEEP);
421 adn->adn_func = func;
422 adn->adn_cookie = cookie;
423 PSLIST_ENTRY_INIT(adn, adn_entry);
424
425 mutex_enter(&acpidisp_notifiers.lock);
426 PSLIST_WRITER_INSERT_HEAD(&acpidisp_notifiers.list, adn, adn_entry);
427 mutex_exit(&acpidisp_notifiers.lock);
428
429 return adn;
430 }
431
432 void
acpidisp_deregister_notify(struct acpidisp_notifier * adn)433 acpidisp_deregister_notify(struct acpidisp_notifier *adn)
434 {
435
436 mutex_enter(&acpidisp_notifiers.lock);
437 PSLIST_WRITER_REMOVE(adn, adn_entry);
438 mutex_exit(&acpidisp_notifiers.lock);
439
440 xc_barrier(0);
441 kmem_free(adn, sizeof(*adn));
442 }
443
444 static void
acpidisp_notify(ACPI_HANDLE handle,uint32_t notify)445 acpidisp_notify(ACPI_HANDLE handle, uint32_t notify)
446 {
447 struct acpidisp_notifier *adn;
448 int s;
449
450 s = pserialize_read_enter();
451 PSLIST_READER_FOREACH(adn, &acpidisp_notifiers.list,
452 struct acpidisp_notifier, adn_entry) {
453 (*adn->adn_func)(handle, notify, adn->adn_cookie);
454 }
455 pserialize_read_exit(s);
456 }
457
458 /*
459 * Autoconfiguration for the acpivga driver.
460 */
461
462 static int
acpidisp_vga_match(device_t parent,cfdata_t match,void * aux)463 acpidisp_vga_match(device_t parent, cfdata_t match, void *aux)
464 {
465 struct acpi_attach_args *aa = aux;
466 struct acpi_devnode *ad = aa->aa_node;
467 struct acpi_pci_info *ap;
468 pcireg_t id, class;
469 pcitag_t tag;
470
471 if (ad->ad_type != ACPI_TYPE_DEVICE)
472 return 0;
473
474 ap = ad->ad_pciinfo;
475
476 if (ap == NULL)
477 return 0;
478
479 if ((ap->ap_flags & ACPI_PCI_INFO_DEVICE) == 0)
480 return 0;
481
482 if (ap->ap_function == 0xffff)
483 return 0;
484
485 KASSERT(ap->ap_bus < 256);
486 KASSERT(ap->ap_device < 32);
487 KASSERT(ap->ap_function < 8);
488
489 /*
490 * Check that the PCI device is present, verify
491 * the class of the PCI device, and finally see
492 * if the ACPI device is capable of something.
493 */
494 tag = pci_make_tag(aa->aa_pc, ap->ap_bus,
495 ap->ap_device, ap->ap_function);
496
497 id = pci_conf_read(aa->aa_pc, tag, PCI_ID_REG);
498
499 if (PCI_VENDOR(id) == PCI_VENDOR_INVALID || PCI_VENDOR(id) == 0)
500 return 0;
501
502 class = pci_conf_read(aa->aa_pc, tag, PCI_CLASS_REG);
503
504 if (PCI_CLASS(class) != PCI_CLASS_DISPLAY)
505 return 0;
506
507 if (acpidisp_vga_capabilities(ad) == 0)
508 return 0;
509
510 return 1;
511 }
512
513 static void
acpidisp_vga_attach(device_t parent,device_t self,void * aux)514 acpidisp_vga_attach(device_t parent, device_t self, void *aux)
515 {
516 struct acpidisp_vga_softc *asc = device_private(self);
517 struct acpi_attach_args *aa = aux;
518 struct acpi_devnode *ad = aa->aa_node;
519
520 aprint_naive(": ACPI Display Adapter\n");
521 aprint_normal(": ACPI Display Adapter\n");
522
523 asc->sc_node = ad;
524 asc->sc_dev = self;
525 asc->sc_log = NULL;
526
527 mutex_init(&asc->sc_mtx, MUTEX_DEFAULT, IPL_NONE);
528
529 asc->sc_caps = acpidisp_vga_capabilities(ad);
530 asc->sc_policy = acpidisp_default_bios_policy;
531 asc->sc_odinfo = NULL;
532
533 acpidisp_vga_print_capabilities(self, asc->sc_caps);
534
535 /*
536 * Enumerate connected output devices, attach
537 * output display devices, and bind the attached
538 * output devices to the enumerated ones.
539 */
540 asc->sc_odinfo = acpidisp_init_odinfo(asc);
541
542 acpidisp_vga_scan_outdevs(asc);
543
544 if (asc->sc_odinfo != NULL) {
545 acpidisp_vga_bind_outdevs(asc);
546 acpidisp_print_odinfo(self, asc->sc_odinfo);
547 }
548
549 /*
550 * Set BIOS automatic switch policy.
551 *
552 * Many laptops do not support output device switching with
553 * the methods specified in the ACPI extensions for display
554 * adapters. Therefore, we leave the BIOS output switch policy
555 * on "auto" instead of setting it to "normal".
556 */
557 asc->sc_policy.fmt.output = ACPI_DISP_POLICY_OUTPUT_AUTO;
558 asc->sc_policy.fmt.brightness = ACPI_DISP_POLICY_BRIGHTNESS_NORMAL;
559
560 if (acpidisp_set_policy(asc, asc->sc_policy.raw))
561 asc->sc_policy = acpidisp_default_bios_policy;
562
563 acpidisp_vga_sysctl_setup(asc);
564
565 (void)pmf_device_register(self, NULL, acpidisp_vga_resume);
566 (void)acpi_register_notify(asc->sc_node, acpidisp_vga_notify_handler);
567 }
568
569 static int
acpidisp_vga_detach(device_t self,int flags)570 acpidisp_vga_detach(device_t self, int flags)
571 {
572 struct acpidisp_vga_softc *asc = device_private(self);
573 struct acpidisp_odinfo *oi = asc->sc_odinfo;
574 int rc;
575
576 pmf_device_deregister(self);
577
578 if (asc->sc_log != NULL)
579 sysctl_teardown(&asc->sc_log);
580
581 asc->sc_policy = acpidisp_default_bios_policy;
582 acpidisp_set_policy(asc, asc->sc_policy.raw);
583
584 acpi_deregister_notify(asc->sc_node);
585
586 if ((rc = config_detach_children(self, flags)) != 0)
587 return rc;
588
589 if (oi != NULL) {
590 kmem_free(oi->oi_dev,
591 oi->oi_dev_count * sizeof(*oi->oi_dev));
592 kmem_free(oi, sizeof(*oi));
593 }
594
595 mutex_destroy(&asc->sc_mtx);
596
597 return 0;
598 }
599
600 void
acpidisp_vga_childdetached(device_t self,device_t child)601 acpidisp_vga_childdetached(device_t self, device_t child)
602 {
603 struct acpidisp_vga_softc *asc = device_private(self);
604 struct acpidisp_odinfo *oi = asc->sc_odinfo;
605 struct acpidisp_outdev *od;
606 struct acpi_devnode *ad;
607 uint32_t i;
608
609 SIMPLEQ_FOREACH(ad, &asc->sc_node->ad_child_head, ad_child_list) {
610
611 if (ad->ad_device == child)
612 ad->ad_device = NULL;
613 }
614
615 if (oi == NULL)
616 return;
617
618 for (i = 0, od = oi->oi_dev; i < oi->oi_dev_count; i++, od++) {
619 if (od->od_device == child)
620 od->od_device = NULL;
621 }
622 }
623
624 /*
625 * Attachment of acpiout under acpivga.
626 */
627
628 static void
acpidisp_vga_scan_outdevs(struct acpidisp_vga_softc * asc)629 acpidisp_vga_scan_outdevs(struct acpidisp_vga_softc *asc)
630 {
631 struct acpidisp_acpivga_attach_args aa;
632 struct acpi_devnode *ad;
633
634 /*
635 * Display output devices are ACPI children of the display adapter.
636 */
637 SIMPLEQ_FOREACH(ad, &asc->sc_node->ad_child_head, ad_child_list) {
638
639 if (ad->ad_device != NULL) /* This should not happen. */
640 continue;
641
642 aa.aa_node = ad;
643 aa.aa_mtx = &asc->sc_mtx;
644
645 ad->ad_device = config_found(asc->sc_dev,
646 &aa, acpidisp_acpivga_print, CFARGS_NONE);
647 }
648 }
649
650 static int
acpidisp_acpivga_print(void * aux,const char * pnp)651 acpidisp_acpivga_print(void *aux, const char *pnp)
652 {
653 struct acpidisp_acpivga_attach_args *aa = aux;
654 struct acpi_devnode *ad = aa->aa_node;
655
656 if (pnp) {
657 aprint_normal("%s at %s", ad->ad_name, pnp);
658 } else {
659 aprint_normal(" (%s", ad->ad_name);
660 if (ad->ad_devinfo->Valid & ACPI_VALID_ADR)
661 aprint_normal(", 0x%04"PRIx64, ad->ad_devinfo->Address);
662 aprint_normal(")");
663 }
664
665 return UNCONF;
666 }
667
668 /*
669 * Autoconfiguration for the acpiout driver.
670 */
671
672 static int
acpidisp_out_match(device_t parent,cfdata_t match,void * aux)673 acpidisp_out_match(device_t parent, cfdata_t match, void *aux)
674 {
675 struct acpidisp_acpivga_attach_args *aa = aux;
676 struct acpi_devnode *ad = aa->aa_node;
677
678 if (ad->ad_type != ACPI_TYPE_DEVICE)
679 return 0;
680
681 /*
682 * The method _ADR is required for display output
683 * devices (ACPI 4.0a, Sec. B.6.1).
684 */
685 if (!(acpidisp_has_method(ad->ad_handle, "_ADR", ACPI_TYPE_INTEGER)))
686 return 0;
687
688 return 1;
689 }
690
691 static void
acpidisp_out_attach(device_t parent,device_t self,void * aux)692 acpidisp_out_attach(device_t parent, device_t self, void *aux)
693 {
694 struct acpidisp_out_softc *osc = device_private(self);
695 struct acpidisp_acpivga_attach_args *aa = aux;
696 struct acpi_devnode *ad = aa->aa_node;
697 struct acpidisp_brctl *bc;
698
699 aprint_naive("\n");
700 aprint_normal(": ACPI Display Output Device\n");
701
702 osc->sc_dev = self;
703 osc->sc_node = ad;
704 osc->sc_log = NULL;
705 osc->sc_mtx = aa->aa_mtx;
706 osc->sc_caps = acpidisp_out_capabilities(ad);
707 osc->sc_brctl = NULL;
708
709 acpidisp_out_print_capabilities(self, osc->sc_caps);
710
711 osc->sc_brctl = acpidisp_init_brctl(osc);
712 bc = osc->sc_brctl;
713 if (bc != NULL) {
714 bc->bc_current = bc->bc_level[bc->bc_level_count - 1];
715
716 /*
717 * Synchronize ACPI and driver brightness levels, and
718 * check that brightness control is working.
719 */
720 if (acpidisp_get_brightness(osc, &bc->bc_current) &&
721 acpidisp_set_brightness(osc, bc->bc_current)) {
722 kmem_free(bc->bc_level,
723 bc->bc_level_count * sizeof(*bc->bc_level));
724 kmem_free(bc, sizeof(*bc));
725 osc->sc_brctl = NULL;
726 } else {
727 if (acpidisp_quirk_get_brightness(osc)) {
728 aprint_error_dev(self,
729 "failed to test _BQC quirk\n");
730 }
731 acpidisp_print_brctl(self, osc->sc_brctl);
732 }
733 }
734
735 /* Install ACPI notify handler. */
736 (void)acpi_register_notify(osc->sc_node, acpidisp_out_notify_handler);
737
738 /* Setup sysctl. */
739 acpidisp_out_sysctl_setup(osc);
740
741 /* Power management. */
742 if (!pmf_device_register(self, acpidisp_out_suspend,
743 acpidisp_out_resume))
744 aprint_error_dev(self, "couldn't establish power handler\n");
745 }
746
747 static int
acpidisp_out_detach(device_t self,int flags)748 acpidisp_out_detach(device_t self, int flags)
749 {
750 struct acpidisp_out_softc *osc = device_private(self);
751 struct acpidisp_brctl *bc = osc->sc_brctl;
752
753 pmf_device_deregister(self);
754
755 if (osc->sc_log != NULL)
756 sysctl_teardown(&osc->sc_log);
757
758 acpi_deregister_notify(osc->sc_node);
759
760 if (bc != NULL) {
761 kmem_free(bc->bc_level,
762 bc->bc_level_count * sizeof(*bc->bc_level));
763 kmem_free(bc, sizeof(*bc));
764 }
765
766 return 0;
767 }
768
769 /*
770 * Power management.
771 */
772
773 static bool
acpidisp_vga_resume(device_t self,const pmf_qual_t * qual)774 acpidisp_vga_resume(device_t self, const pmf_qual_t *qual)
775 {
776 struct acpidisp_vga_softc *asc = device_private(self);
777
778 mutex_enter(&asc->sc_mtx);
779 (void)acpidisp_set_policy(asc, asc->sc_policy.raw);
780 mutex_exit(&asc->sc_mtx);
781
782 return true;
783 }
784
785 static bool
acpidisp_out_suspend(device_t self,const pmf_qual_t * qual)786 acpidisp_out_suspend(device_t self, const pmf_qual_t *qual)
787 {
788 struct acpidisp_out_softc *osc = device_private(self);
789
790 mutex_enter(osc->sc_mtx);
791 if (osc->sc_brctl != NULL)
792 (void)acpidisp_get_brightness(osc, &osc->sc_brctl->bc_current);
793 mutex_exit(osc->sc_mtx);
794
795 return true;
796 }
797
798 static bool
acpidisp_out_resume(device_t self,const pmf_qual_t * qual)799 acpidisp_out_resume(device_t self, const pmf_qual_t *qual)
800 {
801 struct acpidisp_out_softc *osc = device_private(self);
802
803 mutex_enter(osc->sc_mtx);
804 if (osc->sc_brctl != NULL)
805 (void)acpidisp_set_brightness(osc, osc->sc_brctl->bc_current);
806 mutex_exit(osc->sc_mtx);
807
808 return true;
809 }
810
811 /*
812 * Capabilities (available methods).
813 */
814
815 static uint16_t
acpidisp_vga_capabilities(const struct acpi_devnode * ad)816 acpidisp_vga_capabilities(const struct acpi_devnode *ad)
817 {
818 uint16_t cap;
819
820 cap = 0;
821
822 if (acpidisp_has_method(ad->ad_handle, "_DOS", ACPI_TYPE_METHOD))
823 cap |= ACPI_DISP_VGA_CAP__DOS;
824
825 if (acpidisp_has_method(ad->ad_handle, "_DOD", ACPI_TYPE_PACKAGE))
826 cap |= ACPI_DISP_VGA_CAP__DOD;
827
828 if (acpidisp_has_method(ad->ad_handle, "_ROM", ACPI_TYPE_BUFFER))
829 cap |= ACPI_DISP_VGA_CAP__ROM;
830
831 if (acpidisp_has_method(ad->ad_handle, "_GPD", ACPI_TYPE_INTEGER))
832 cap |= ACPI_DISP_VGA_CAP__GPD;
833
834 if (acpidisp_has_method(ad->ad_handle, "_SPD", ACPI_TYPE_METHOD))
835 cap |= ACPI_DISP_VGA_CAP__SPD;
836
837 if (acpidisp_has_method(ad->ad_handle, "_VPO", ACPI_TYPE_INTEGER))
838 cap |= ACPI_DISP_VGA_CAP__VPO;
839
840 return cap;
841 }
842
843 static void
acpidisp_vga_print_capabilities(device_t self,uint16_t cap)844 acpidisp_vga_print_capabilities(device_t self, uint16_t cap)
845 {
846 aprint_debug_dev(self, "capabilities:%s%s%s%s%s%s\n",
847 (cap & ACPI_DISP_VGA_CAP__DOS) ? " _DOS" : "",
848 (cap & ACPI_DISP_VGA_CAP__DOD) ? " _DOD" : "",
849 (cap & ACPI_DISP_VGA_CAP__ROM) ? " _ROM" : "",
850 (cap & ACPI_DISP_VGA_CAP__GPD) ? " _GPD" : "",
851 (cap & ACPI_DISP_VGA_CAP__SPD) ? " _SPD" : "",
852 (cap & ACPI_DISP_VGA_CAP__VPO) ? " _VPO" : "");
853 }
854
855 static uint16_t
acpidisp_out_capabilities(const struct acpi_devnode * ad)856 acpidisp_out_capabilities(const struct acpi_devnode *ad)
857 {
858 uint16_t cap;
859
860 cap = 0;
861
862 /* List of Brightness levels */
863 if (acpidisp_has_method(ad->ad_handle, "_BCL", ACPI_TYPE_PACKAGE))
864 cap |= ACPI_DISP_OUT_CAP__BCL;
865
866 /* Set brightness level */
867 if (acpidisp_has_method(ad->ad_handle, "_BCM", ACPI_TYPE_METHOD))
868 cap |= ACPI_DISP_OUT_CAP__BCM;
869
870 /* Get brightless level */
871 if (acpidisp_has_method(ad->ad_handle, "_BQC", ACPI_TYPE_INTEGER))
872 cap |= ACPI_DISP_OUT_CAP__BQC;
873
874 /* Return EDID */
875 if (acpidisp_has_method(ad->ad_handle, "_DDC", ACPI_TYPE_METHOD))
876 cap |= ACPI_DISP_OUT_CAP__DDC;
877
878 /* Get Status */
879 if (acpidisp_has_method(ad->ad_handle, "_DCS", ACPI_TYPE_INTEGER))
880 cap |= ACPI_DISP_OUT_CAP__DCS;
881
882 /* Get Graphics State */
883 if (acpidisp_has_method(ad->ad_handle, "_DGS", ACPI_TYPE_INTEGER))
884 cap |= ACPI_DISP_OUT_CAP__DGS;
885
886 /* Set Graphics State */
887 if (acpidisp_has_method(ad->ad_handle, "_DSS", ACPI_TYPE_METHOD))
888 cap |= ACPI_DISP_OUT_CAP__DSS;
889
890 return cap;
891 }
892
893 static void
acpidisp_out_print_capabilities(device_t self,uint16_t cap)894 acpidisp_out_print_capabilities(device_t self, uint16_t cap)
895 {
896 aprint_debug_dev(self, "capabilities:%s%s%s%s%s%s%s\n",
897 (cap & ACPI_DISP_OUT_CAP__BCL) ? " _BCL" : "",
898 (cap & ACPI_DISP_OUT_CAP__BCM) ? " _BCM" : "",
899 (cap & ACPI_DISP_OUT_CAP__BQC) ? " _BQC" : "",
900 (cap & ACPI_DISP_OUT_CAP__DDC) ? " _DDC" : "",
901 (cap & ACPI_DISP_OUT_CAP__DCS) ? " _DCS" : "",
902 (cap & ACPI_DISP_OUT_CAP__DGS) ? " _DGS" : "",
903 (cap & ACPI_DISP_OUT_CAP__DSS) ? " _DSS" : "");
904 }
905
906 /*
907 * ACPI notify handlers.
908 */
909
910 static void
acpidisp_vga_notify_handler(ACPI_HANDLE handle,uint32_t notify,void * context)911 acpidisp_vga_notify_handler(ACPI_HANDLE handle, uint32_t notify,
912 void *context)
913 {
914 struct acpidisp_vga_softc *asc = device_private(context);
915 ACPI_OSD_EXEC_CALLBACK callback;
916
917 callback = NULL;
918
919 switch (notify) {
920 case ACPI_NOTIFY_CycleOutputDevice:
921 callback = acpidisp_vga_cycle_output_device_callback;
922 break;
923 case ACPI_NOTIFY_OutputDeviceStatusChange:
924 callback = acpidisp_vga_output_device_change_callback;
925 break;
926 case ACPI_NOTIFY_CycleDisplayOutputHotkeyPressed:
927 case ACPI_NOTIFY_NextDisplayOutputHotkeyPressed:
928 case ACPI_NOTIFY_PreviousDisplayOutputHotkeyPressed:
929 aprint_debug_dev(asc->sc_dev,
930 "unhandled notify: 0x%"PRIx32"\n", notify);
931 return;
932 default:
933 aprint_error_dev(asc->sc_dev,
934 "unknown notify: 0x%"PRIx32"\n", notify);
935 return;
936 }
937
938 KASSERT(callback != NULL);
939 (void)AcpiOsExecute(OSL_NOTIFY_HANDLER, callback, asc);
940
941 acpidisp_notify(handle, notify);
942 }
943
944 static void
acpidisp_out_notify_handler(ACPI_HANDLE handle,uint32_t notify,void * context)945 acpidisp_out_notify_handler(ACPI_HANDLE handle, uint32_t notify,
946 void *context)
947 {
948 struct acpidisp_out_softc *osc = device_private(context);
949 ACPI_OSD_EXEC_CALLBACK callback;
950
951 callback = NULL;
952
953 switch (notify) {
954 case ACPI_NOTIFY_IncreaseBrightness:
955 callback = acpidisp_out_increase_brightness_callback;
956 break;
957 case ACPI_NOTIFY_DecreaseBrightness:
958 callback = acpidisp_out_decrease_brightness_callback;
959 break;
960 case ACPI_NOTIFY_CycleBrightness:
961 callback = acpidisp_out_cycle_brightness_callback;
962 break;
963 case ACPI_NOTIFY_ZeroBrightness:
964 callback = acpidisp_out_zero_brightness_callback;
965 break;
966 case ACPI_NOTIFY_DisplayDeviceOff:
967 aprint_debug_dev(osc->sc_dev,
968 "unhandled notify: 0x%"PRIx32"\n", notify);
969 return;
970 default:
971 aprint_error_dev(osc->sc_dev,
972 "unknown notify: 0x%"PRIx32"\n", notify);
973 return;
974 }
975
976 KASSERT(callback != NULL);
977 (void)AcpiOsExecute(OSL_NOTIFY_HANDLER, callback, osc);
978 }
979
980 /*
981 * ACPI notify callbacks.
982 *
983 * Exclusive access to the sc_odinfo field of struct acpidisp_vga_softc is
984 * guaranteed since:
985 *
986 * (a) this field is only used in ACPI display notify callbacks,
987 * (b) ACPI display notify callbacks are scheduled with AcpiOsExecute,
988 * (c) callbacks scheduled with AcpiOsExecute are executed sequentially.
989 */
990
991 static void
acpidisp_vga_cycle_output_device_callback(void * arg)992 acpidisp_vga_cycle_output_device_callback(void *arg)
993 {
994 struct acpidisp_vga_softc *asc = arg;
995 struct acpidisp_odinfo *oi = asc->sc_odinfo;
996 struct acpidisp_outdev *od;
997 struct acpidisp_out_softc *osc, *last_osc;
998 acpidisp_od_state_t state, last_state;
999 acpidisp_od_status_t status;
1000 acpidisp_bios_policy_t lock_policy;
1001 uint32_t i;
1002
1003 if (oi == NULL)
1004 return;
1005
1006 /* Mutual exclusion with callbacks of connected output devices. */
1007 mutex_enter(&asc->sc_mtx);
1008
1009 /* Lock the _DGS values. */
1010 lock_policy = asc->sc_policy;
1011 lock_policy.fmt.output = ACPI_DISP_POLICY_OUTPUT_LOCKED;
1012 (void)acpidisp_set_policy(asc, lock_policy.raw);
1013
1014 last_osc = NULL;
1015 for (i = 0, od = oi->oi_dev; i < oi->oi_dev_count; i++, od++) {
1016 if (od->od_device == NULL)
1017 continue;
1018 osc = device_private(od->od_device);
1019
1020 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__DSS))
1021 continue;
1022 if (acpidisp_get_state(osc, &state.raw))
1023 continue;
1024
1025 if (acpidisp_get_status(osc, &status.raw)) {
1026 state.fmt.no_switch = 0;
1027 } else {
1028 state.fmt.active &= status.fmt.ready;
1029
1030 if (state.fmt.active == status.fmt.activated)
1031 state.fmt.no_switch = 1;
1032 else
1033 state.fmt.no_switch = 0;
1034 }
1035
1036 state.fmt.commit = 0;
1037
1038 if (last_osc != NULL)
1039 (void)acpidisp_set_state(last_osc, last_state.raw);
1040
1041 last_osc = osc;
1042 last_state = state;
1043 }
1044
1045 if (last_osc != NULL) {
1046 last_state.fmt.commit = 1;
1047 (void)acpidisp_set_state(last_osc, last_state.raw);
1048 }
1049
1050 /* Restore the original BIOS policy. */
1051 (void)acpidisp_set_policy(asc, asc->sc_policy.raw);
1052
1053 mutex_exit(&asc->sc_mtx);
1054 }
1055
1056 static void
acpidisp_vga_output_device_change_callback(void * arg)1057 acpidisp_vga_output_device_change_callback(void *arg)
1058 {
1059 struct acpidisp_vga_softc *asc = arg;
1060 struct acpidisp_odinfo *oi = asc->sc_odinfo;
1061 bool switch_outputs;
1062
1063 if (oi != NULL) {
1064 kmem_free(oi->oi_dev,
1065 oi->oi_dev_count * sizeof(*oi->oi_dev));
1066 kmem_free(oi, sizeof(*oi));
1067 }
1068
1069 asc->sc_odinfo = acpidisp_init_odinfo(asc);
1070 if (asc->sc_odinfo != NULL) {
1071 acpidisp_vga_bind_outdevs(asc);
1072 acpidisp_print_odinfo(asc->sc_dev, asc->sc_odinfo);
1073 }
1074
1075 /* Perform display output switch if needed. */
1076 mutex_enter(&asc->sc_mtx);
1077 switch_outputs =
1078 (asc->sc_policy.fmt.output == ACPI_DISP_POLICY_OUTPUT_NORMAL);
1079 mutex_exit(&asc->sc_mtx);
1080 if (switch_outputs)
1081 acpidisp_vga_cycle_output_device_callback(arg);
1082 }
1083
1084 static void
acpidisp_out_increase_brightness_callback(void * arg)1085 acpidisp_out_increase_brightness_callback(void *arg)
1086 {
1087 struct acpidisp_out_softc *osc = arg;
1088 struct acpidisp_brctl *bc = osc->sc_brctl;
1089 uint8_t max, lo, up;
1090 int cur;
1091
1092 if (bc == NULL) {
1093 /* Fallback to pmf(9). */
1094 pmf_event_inject(NULL, PMFE_DISPLAY_BRIGHTNESS_UP);
1095 return;
1096 }
1097
1098 mutex_enter(osc->sc_mtx);
1099 max = bc->bc_level[bc->bc_level_count - 1];
1100 if (acpidisp_get_brightness(osc, &bc->bc_current))
1101 goto out;
1102 for (cur = bc->bc_current; (cur += ACPI_DISP_BRCTL_STEP) <= max;) {
1103 acpidisp_array_search(bc->bc_level, bc->bc_level_count, cur,
1104 &lo, &up);
1105 bc->bc_current = up;
1106 if (acpidisp_set_brightness(osc, bc->bc_current))
1107 goto out;
1108 if (acpidisp_get_brightness(osc, &bc->bc_current))
1109 goto out;
1110 if (bc->bc_current >= cur)
1111 break;
1112 }
1113 out: mutex_exit(osc->sc_mtx);
1114 }
1115
1116 static void
acpidisp_out_decrease_brightness_callback(void * arg)1117 acpidisp_out_decrease_brightness_callback(void *arg)
1118 {
1119 struct acpidisp_out_softc *osc = arg;
1120 struct acpidisp_brctl *bc = osc->sc_brctl;
1121 uint8_t min, lo, up;
1122 int cur;
1123
1124 if (bc == NULL) {
1125 /* Fallback to pmf(9). */
1126 pmf_event_inject(NULL, PMFE_DISPLAY_BRIGHTNESS_DOWN);
1127 return;
1128 }
1129
1130 mutex_enter(osc->sc_mtx);
1131 min = bc->bc_level[0];
1132 if (acpidisp_get_brightness(osc, &bc->bc_current))
1133 goto out;
1134 for (cur = bc->bc_current; (cur -= ACPI_DISP_BRCTL_STEP) >= min;) {
1135 acpidisp_array_search(bc->bc_level, bc->bc_level_count, cur,
1136 &lo, &up);
1137 bc->bc_current = lo;
1138 if (acpidisp_set_brightness(osc, bc->bc_current))
1139 goto out;
1140 if (acpidisp_get_brightness(osc, &bc->bc_current))
1141 goto out;
1142 if (bc->bc_current <= cur)
1143 break;
1144 }
1145 out: mutex_exit(osc->sc_mtx);
1146 }
1147
1148 static void
acpidisp_out_cycle_brightness_callback(void * arg)1149 acpidisp_out_cycle_brightness_callback(void *arg)
1150 {
1151 struct acpidisp_out_softc *osc = arg;
1152 struct acpidisp_brctl *bc = osc->sc_brctl;
1153 uint8_t lo, up;
1154
1155 if (bc == NULL) {
1156 /* No fallback. */
1157 return;
1158 }
1159
1160 mutex_enter(osc->sc_mtx);
1161
1162 (void)acpidisp_get_brightness(osc, &bc->bc_current);
1163
1164 if (bc->bc_current >= bc->bc_level[bc->bc_level_count - 1]) {
1165 bc->bc_current = bc->bc_level[0];
1166 } else {
1167 acpidisp_array_search(bc->bc_level, bc->bc_level_count,
1168 bc->bc_current + 1, &lo, &up);
1169 bc->bc_current = up;
1170 }
1171
1172 (void)acpidisp_set_brightness(osc, bc->bc_current);
1173
1174 mutex_exit(osc->sc_mtx);
1175 }
1176
1177 static void
acpidisp_out_zero_brightness_callback(void * arg)1178 acpidisp_out_zero_brightness_callback(void *arg)
1179 {
1180 struct acpidisp_out_softc *osc = arg;
1181 struct acpidisp_brctl *bc = osc->sc_brctl;
1182
1183 if (bc == NULL) {
1184 /* Fallback to pmf(9). */
1185 /* XXX Is this the intended meaning of PMFE_DISPLAY_REDUCED? */
1186 pmf_event_inject(NULL, PMFE_DISPLAY_REDUCED);
1187 return;
1188 }
1189
1190 mutex_enter(osc->sc_mtx);
1191
1192 bc->bc_current = bc->bc_level[0];
1193 (void)acpidisp_set_brightness(osc, bc->bc_current);
1194
1195 mutex_exit(osc->sc_mtx);
1196 }
1197
1198 /*
1199 * Sysctl setup.
1200 */
1201
1202 static void
acpidisp_vga_sysctl_setup(struct acpidisp_vga_softc * asc)1203 acpidisp_vga_sysctl_setup(struct acpidisp_vga_softc *asc)
1204 {
1205 const struct sysctlnode *rnode;
1206
1207 if (asc->sc_caps & ACPI_DISP_VGA_CAP__DOS) {
1208 if ((sysctl_createv(&asc->sc_log, 0, NULL, &rnode,
1209 0, CTLTYPE_NODE, "acpi", NULL,
1210 NULL, 0, NULL, 0,
1211 CTL_HW, CTL_CREATE, CTL_EOL)) != 0)
1212 goto fail;
1213
1214 if ((sysctl_createv(&asc->sc_log, 0, &rnode, &rnode,
1215 0, CTLTYPE_NODE, device_xname(asc->sc_dev),
1216 SYSCTL_DESCR("ACPI display adapter controls"),
1217 NULL, 0, NULL, 0,
1218 CTL_CREATE, CTL_EOL)) != 0)
1219 goto fail;
1220
1221 #ifdef ACPI_DEBUG
1222 (void)sysctl_createv(&asc->sc_log, 0, &rnode, NULL,
1223 CTLFLAG_READWRITE | CTLFLAG_HEX, CTLTYPE_INT, "bios_policy",
1224 SYSCTL_DESCR("Current BIOS switch policies (debug)"),
1225 acpidisp_vga_sysctl_policy, 0, (void *)asc, 0,
1226 CTL_CREATE, CTL_EOL);
1227 #endif
1228
1229 (void)sysctl_createv(&asc->sc_log, 0, &rnode, NULL,
1230 CTLFLAG_READWRITE, CTLTYPE_BOOL, "bios_switch",
1231 SYSCTL_DESCR("Current BIOS output switching policy"),
1232 acpidisp_vga_sysctl_policy_output, 0, (void *)asc, 0,
1233 CTL_CREATE, CTL_EOL);
1234 }
1235
1236 return;
1237
1238 fail:
1239 aprint_error_dev(asc->sc_dev, "couldn't add sysctl nodes\n");
1240 }
1241
1242 static void
acpidisp_out_sysctl_setup(struct acpidisp_out_softc * osc)1243 acpidisp_out_sysctl_setup(struct acpidisp_out_softc *osc)
1244 {
1245 const struct sysctlnode *rnode;
1246
1247 #ifdef ACPI_DISP_SWITCH_SYSCTLS
1248 if ((osc->sc_brctl != NULL) ||
1249 (osc->sc_caps & ACPI_DISP_OUT_CAP__DCS) ||
1250 (osc->sc_caps & ACPI_DISP_OUT_CAP__DGS)) {
1251 #else
1252 if (osc->sc_brctl != NULL) {
1253 #endif
1254 if ((sysctl_createv(&osc->sc_log, 0, NULL, &rnode,
1255 0, CTLTYPE_NODE, "acpi", NULL,
1256 NULL, 0, NULL, 0,
1257 CTL_HW, CTL_CREATE, CTL_EOL)) != 0)
1258 goto fail;
1259
1260 if ((sysctl_createv(&osc->sc_log, 0, &rnode, &rnode,
1261 0, CTLTYPE_NODE, device_xname(osc->sc_dev),
1262 SYSCTL_DESCR("ACPI display output device controls"),
1263 NULL, 0, NULL, 0,
1264 CTL_CREATE, CTL_EOL)) != 0)
1265 goto fail;
1266 }
1267
1268 if (osc->sc_brctl != NULL) {
1269 (void)sysctl_createv(&osc->sc_log, 0, &rnode, NULL,
1270 CTLFLAG_READWRITE, CTLTYPE_INT, "brightness",
1271 SYSCTL_DESCR("Current brightness level"),
1272 acpidisp_out_sysctl_brightness, 0, (void *)osc, 0,
1273 CTL_CREATE, CTL_EOL);
1274 }
1275
1276 #ifdef ACPI_DISP_SWITCH_SYSCTLS
1277 if (osc->sc_caps & ACPI_DISP_OUT_CAP__DCS) {
1278 (void)sysctl_createv(&osc->sc_log, 0, &rnode, NULL,
1279 CTLFLAG_READONLY | CTLFLAG_HEX, CTLTYPE_INT, "status",
1280 SYSCTL_DESCR("Current status"),
1281 acpidisp_out_sysctl_status, 0, (void *)osc, 0,
1282 CTL_CREATE, CTL_EOL);
1283 }
1284
1285 if (osc->sc_caps & ACPI_DISP_OUT_CAP__DGS) {
1286 int access;
1287
1288 if (osc->sc_caps & ACPI_DISP_OUT_CAP__DSS)
1289 access = CTLFLAG_READWRITE;
1290 else
1291 access = CTLFLAG_READONLY;
1292
1293 (void)sysctl_createv(&osc->sc_log, 0, &rnode, NULL,
1294 access | CTLFLAG_HEX, CTLTYPE_INT, "state",
1295 SYSCTL_DESCR("Next state (active or inactive)"),
1296 acpidisp_out_sysctl_state, 0, (void *)osc, 0,
1297 CTL_CREATE, CTL_EOL);
1298 }
1299 #endif
1300
1301 return;
1302
1303 fail:
1304 aprint_error_dev(osc->sc_dev, "couldn't add sysctl nodes\n");
1305 }
1306
1307 /*
1308 * Sysctl callbacks.
1309 */
1310
1311 #ifdef ACPI_DEBUG
1312 static int
1313 acpidisp_vga_sysctl_policy(SYSCTLFN_ARGS)
1314 {
1315 struct sysctlnode node;
1316 struct acpidisp_vga_softc *asc;
1317 uint32_t val;
1318 int error;
1319
1320 node = *rnode;
1321 asc = node.sysctl_data;
1322
1323 mutex_enter(&asc->sc_mtx);
1324 val = (uint32_t)asc->sc_policy.raw;
1325 mutex_exit(&asc->sc_mtx);
1326
1327 node.sysctl_data = &val;
1328 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1329 if (error || newp == NULL)
1330 return error;
1331
1332 if (val > 0x7)
1333 return EINVAL;
1334
1335 mutex_enter(&asc->sc_mtx);
1336 asc->sc_policy.raw = (uint8_t)val;
1337 error = acpidisp_set_policy(asc, asc->sc_policy.raw);
1338 mutex_exit(&asc->sc_mtx);
1339
1340 return error;
1341 }
1342 #endif
1343
1344 static int
1345 acpidisp_vga_sysctl_policy_output(SYSCTLFN_ARGS)
1346 {
1347 struct sysctlnode node;
1348 struct acpidisp_vga_softc *asc;
1349 bool val;
1350 int error;
1351
1352 node = *rnode;
1353 asc = node.sysctl_data;
1354
1355 mutex_enter(&asc->sc_mtx);
1356 val = (asc->sc_policy.fmt.output == ACPI_DISP_POLICY_OUTPUT_AUTO);
1357 mutex_exit(&asc->sc_mtx);
1358
1359 node.sysctl_data = &val;
1360 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1361 if (error || newp == NULL)
1362 return error;
1363
1364 mutex_enter(&asc->sc_mtx);
1365 if (val)
1366 asc->sc_policy.fmt.output = ACPI_DISP_POLICY_OUTPUT_AUTO;
1367 else
1368 asc->sc_policy.fmt.output = ACPI_DISP_POLICY_OUTPUT_NORMAL;
1369 error = acpidisp_set_policy(asc, asc->sc_policy.raw);
1370 mutex_exit(&asc->sc_mtx);
1371
1372 return error;
1373 }
1374
1375 #ifdef ACPI_DISP_SWITCH_SYSCTLS
1376 static int
1377 acpidisp_out_sysctl_status(SYSCTLFN_ARGS)
1378 {
1379 struct sysctlnode node;
1380 struct acpidisp_out_softc *osc;
1381 uint32_t val;
1382 int error;
1383
1384 node = *rnode;
1385 osc = node.sysctl_data;
1386
1387 mutex_enter(osc->sc_mtx);
1388 error = acpidisp_get_status(osc, &val);
1389 mutex_exit(osc->sc_mtx);
1390
1391 if (error)
1392 return error;
1393
1394 node.sysctl_data = &val;
1395 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1396 if (error || newp == NULL)
1397 return error;
1398
1399 return 0;
1400 }
1401
1402 static int
1403 acpidisp_out_sysctl_state(SYSCTLFN_ARGS)
1404 {
1405 struct sysctlnode node;
1406 struct acpidisp_out_softc *osc;
1407 uint32_t val;
1408 int error;
1409
1410 node = *rnode;
1411 osc = node.sysctl_data;
1412
1413 mutex_enter(osc->sc_mtx);
1414 error = acpidisp_get_state(osc, &val);
1415 mutex_exit(osc->sc_mtx);
1416
1417 if (error)
1418 return error;
1419
1420 node.sysctl_data = &val;
1421 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1422 if (error || newp == NULL)
1423 return error;
1424
1425 mutex_enter(osc->sc_mtx);
1426 error = acpidisp_set_state(osc, val);
1427 mutex_exit(osc->sc_mtx);
1428
1429 return error;
1430 }
1431 #endif
1432
1433 static int
1434 acpidisp_out_sysctl_brightness(SYSCTLFN_ARGS)
1435 {
1436 struct sysctlnode node;
1437 struct acpidisp_out_softc *osc;
1438 struct acpidisp_brctl *bc;
1439 int val, error;
1440 uint8_t lo, up, level;
1441
1442 node = *rnode;
1443 osc = node.sysctl_data;
1444 bc = osc->sc_brctl;
1445
1446 KASSERT(bc != NULL);
1447
1448 mutex_enter(osc->sc_mtx);
1449 (void)acpidisp_get_brightness(osc, &bc->bc_current);
1450 val = (int)bc->bc_current;
1451 mutex_exit(osc->sc_mtx);
1452
1453 node.sysctl_data = &val;
1454 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1455 if (error || newp == NULL)
1456 return error;
1457
1458 acpidisp_array_search(bc->bc_level, bc->bc_level_count, val, &lo, &up);
1459 if ((lo != up) && (val - lo) < (up - val))
1460 level = lo;
1461 else
1462 level = up;
1463
1464 mutex_enter(osc->sc_mtx);
1465 bc->bc_current = level;
1466 error = acpidisp_set_brightness(osc, bc->bc_current);
1467 mutex_exit(osc->sc_mtx);
1468
1469 return error;
1470 }
1471
1472 /*
1473 * Initialization of acpidisp_odinfo (_DOD) and acpidisp_brctl (_BCL).
1474 */
1475
1476 /*
1477 * Regarding _DOD (ACPI 4.0a, Sec. B.4.2):
1478 *
1479 * "The _DOD method returns a list of devices attached to the graphics adapter,
1480 * along with device-specific configuration information."
1481 *
1482 * "Every child device enumerated in the ACPI namespace under the graphics
1483 * adapter must be specified in this list of devices. Each display device
1484 * must have its own ID, which is unique with respect to any other attachable
1485 * devices enumerated."
1486 *
1487 * "Return value: a package containing a variable-length list of integers,
1488 * each of which contains the 32-bit device attribute of a child device."
1489 */
1490
1491 static struct acpidisp_odinfo *
1492 acpidisp_init_odinfo(const struct acpidisp_vga_softc *asc)
1493 {
1494 ACPI_HANDLE hdl = asc->sc_node->ad_handle;
1495 ACPI_STATUS rv;
1496 ACPI_OBJECT *pkg;
1497 struct acpidisp_odinfo *oi;
1498 struct acpidisp_outdev *devp;
1499 uint32_t count, i;
1500
1501 if (!(asc->sc_caps & ACPI_DISP_VGA_CAP__DOD))
1502 return NULL;
1503
1504 oi = NULL;
1505 pkg = NULL;
1506
1507 rv = acpidisp_eval_package(hdl, "_DOD", &pkg, 1);
1508 if (ACPI_FAILURE(rv))
1509 goto fail;
1510
1511 /*
1512 * Allocate and fill the struct acpidisp_odinfo to be returned.
1513 */
1514 oi = kmem_zalloc(sizeof(*oi), KM_SLEEP);
1515 oi->oi_dev_count = pkg->Package.Count;
1516 oi->oi_dev = kmem_zalloc(oi->oi_dev_count * sizeof(*oi->oi_dev),
1517 KM_SLEEP);
1518
1519 /*
1520 * Fill the array oi->oi_dev.
1521 */
1522 for (count = 0, i = 0; i < pkg->Package.Count; i++) {
1523 /* List of 32-bit integers (ACPI 4.0a, Sec. B.4.2). */
1524 if (pkg->Package.Elements[i].Type != ACPI_TYPE_INTEGER ||
1525 pkg->Package.Elements[i].Integer.Value > UINT32_MAX)
1526 continue;
1527
1528 oi->oi_dev[count].od_attrs.raw =
1529 (uint32_t)pkg->Package.Elements[i].Integer.Value;
1530 count++;
1531 }
1532
1533 if (count == 0) {
1534 rv = AE_BAD_DATA;
1535 goto fail;
1536 }
1537
1538 ACPI_FREE(pkg);
1539 pkg = NULL;
1540
1541 /*
1542 * Resize the array oi->oi_dev if needed.
1543 */
1544 if (count < oi->oi_dev_count) {
1545 devp = kmem_alloc(count * sizeof(*devp), KM_SLEEP);
1546 (void)memcpy(devp, oi->oi_dev, count * sizeof(*devp));
1547 kmem_free(oi->oi_dev, oi->oi_dev_count * sizeof(*oi->oi_dev));
1548 oi->oi_dev = devp;
1549 oi->oi_dev_count = count;
1550 }
1551
1552 return oi;
1553
1554 fail:
1555 aprint_error_dev(asc->sc_dev, "failed to evaluate %s.%s: %s\n",
1556 acpi_name(hdl), "_DOD", AcpiFormatException(rv));
1557 if (pkg != NULL)
1558 ACPI_FREE(pkg);
1559 if (oi != NULL) {
1560 if (oi->oi_dev != NULL)
1561 kmem_free(oi->oi_dev,
1562 oi->oi_dev_count * sizeof(*oi->oi_dev));
1563 kmem_free(oi, sizeof(*oi));
1564 }
1565 return NULL;
1566 }
1567
1568 /*
1569 * acpidisp_vga_bind_outdevs:
1570 *
1571 * Bind each acpiout device attached under an acpivga device to the
1572 * corresponding (_DOD enumerated) connected output device.
1573 */
1574 static void
1575 acpidisp_vga_bind_outdevs(struct acpidisp_vga_softc *asc)
1576 {
1577 struct acpidisp_odinfo *oi = asc->sc_odinfo;
1578 struct acpidisp_out_softc *osc;
1579 struct acpidisp_outdev *od;
1580 struct acpi_devnode *ad;
1581 ACPI_HANDLE hdl;
1582 ACPI_INTEGER val;
1583 ACPI_STATUS rv;
1584 uint16_t devid;
1585 uint32_t i;
1586
1587 KASSERT(oi != NULL);
1588
1589 /* Reset all bindings. */
1590 for (i = 0, od = oi->oi_dev; i < oi->oi_dev_count; i++, od++)
1591 od->od_device = NULL;
1592
1593 /*
1594 * Iterate over all ACPI children that have been attached under this
1595 * acpivga device (as acpiout devices).
1596 */
1597 SIMPLEQ_FOREACH(ad, &asc->sc_node->ad_child_head, ad_child_list) {
1598 if ((ad->ad_device == NULL) ||
1599 (device_parent(ad->ad_device) != asc->sc_dev))
1600 continue;
1601
1602 KASSERT(device_is_a(ad->ad_device, "acpiout"));
1603
1604 osc = device_private(ad->ad_device);
1605
1606 /*
1607 * For display output devices, the method _ADR returns
1608 * the device's ID (ACPI 4.0a, Sec. B.6.1). We do not
1609 * cache the result of _ADR since it may vary.
1610 */
1611 hdl = osc->sc_node->ad_handle;
1612 rv = acpi_eval_integer(hdl, "_ADR", &val);
1613 if (ACPI_FAILURE(rv)) {
1614 aprint_error_dev(asc->sc_dev,
1615 "failed to evaluate %s.%s: %s\n",
1616 acpi_name(hdl), "_ADR", AcpiFormatException(rv));
1617 continue;
1618 }
1619
1620 /* The device ID is a 16-bit integer (ACPI 4.0a, Table B-2). */
1621 devid = (uint16_t)val;
1622
1623 /*
1624 * The device ID must be unique (among output devices), and must
1625 * appear in the list returned by _DOD (ACPI 4.0a, Sec. B.6.1).
1626 */
1627 for (i = 0, od = oi->oi_dev; i < oi->oi_dev_count; i++, od++) {
1628 if (devid == od->od_attrs.device_id) {
1629 if (od->od_device != NULL)
1630 aprint_error_dev(asc->sc_dev,
1631 "%s has same device ID as %s\n",
1632 device_xname(osc->sc_dev),
1633 device_xname(od->od_device));
1634 else
1635 od->od_device = osc->sc_dev;
1636 break;
1637 }
1638 }
1639 if (i == oi->oi_dev_count)
1640 aprint_debug_dev(asc->sc_dev,
1641 "output device %s not connected\n",
1642 device_xname(osc->sc_dev));
1643 }
1644 }
1645
1646 /*
1647 * Regarding _BCL (ACPI 4.0a, Sec. B.6.2):
1648 *
1649 * "This method allows the OS to query a list of brightness levels supported by
1650 * built-in display output devices."
1651 *
1652 * "Return value: a variable-length package containing a list of integers
1653 * representing the supported brightness levels. Each integer has 8 bits of
1654 * significant data."
1655 */
1656
1657 static struct acpidisp_brctl *
1658 acpidisp_init_brctl(const struct acpidisp_out_softc *osc)
1659 {
1660 ACPI_HANDLE hdl = osc->sc_node->ad_handle;
1661 ACPI_STATUS rv;
1662 ACPI_OBJECT *pkg;
1663 struct acpidisp_brctl *bc;
1664 uint8_t *levelp;
1665 uint32_t i;
1666 int32_t j;
1667 uint16_t count, k;
1668 uint8_t level;
1669
1670 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__BCL))
1671 return NULL;
1672
1673 bc = NULL;
1674 pkg = NULL;
1675
1676 rv = acpidisp_eval_package(hdl, "_BCL", &pkg, 2);
1677 if (ACPI_FAILURE(rv))
1678 goto fail;
1679
1680 /*
1681 * Allocate and fill the struct acpidisp_brctl to be returned.
1682 */
1683 bc = kmem_zalloc(sizeof(*bc), KM_SLEEP);
1684
1685 /* At most 256 brightness levels (8-bit integers). */
1686 if (pkg->Package.Count > 256)
1687 bc->bc_level_count = 256;
1688 else
1689 bc->bc_level_count = (uint16_t)pkg->Package.Count;
1690
1691 bc->bc_level = kmem_zalloc(bc->bc_level_count * sizeof(*bc->bc_level),
1692 KM_SLEEP);
1693
1694 /*
1695 * Fill the array bc->bc_level with an insertion sort.
1696 */
1697 for (count = 0, i = 0; i < pkg->Package.Count; i++) {
1698 /* List of 8-bit integers (ACPI 4.0a, Sec. B.6.2). */
1699 if (pkg->Package.Elements[i].Type != ACPI_TYPE_INTEGER ||
1700 pkg->Package.Elements[i].Integer.Value > UINT8_MAX)
1701 continue;
1702
1703 level = (uint8_t)pkg->Package.Elements[i].Integer.Value;
1704
1705 /* Find the correct slot but do not modify the array yet. */
1706 for (j = count; --j >= 0 && bc->bc_level[j] > level; );
1707 if (j >= 0 && bc->bc_level[j] == level)
1708 continue;
1709 j++;
1710
1711 /* Make room for the new level. */
1712 for (k = count; k > j; k--)
1713 bc->bc_level[k] = bc->bc_level[k-1];
1714
1715 /* Insert the new level. */
1716 bc->bc_level[j] = level;
1717 count++;
1718 }
1719
1720 if (count == 0) {
1721 rv = AE_BAD_DATA;
1722 goto fail;
1723 }
1724
1725 ACPI_FREE(pkg);
1726 pkg = NULL;
1727
1728 /*
1729 * Resize the array bc->bc_level if needed.
1730 */
1731 if (count < bc->bc_level_count) {
1732 levelp = kmem_alloc(count * sizeof(*levelp), KM_SLEEP);
1733 (void)memcpy(levelp, bc->bc_level, count * sizeof(*levelp));
1734 kmem_free(bc->bc_level,
1735 bc->bc_level_count * sizeof(*bc->bc_level));
1736 bc->bc_level = levelp;
1737 bc->bc_level_count = count;
1738 }
1739
1740 return bc;
1741
1742 fail:
1743 aprint_error_dev(osc->sc_dev, "failed to evaluate %s.%s: %s\n",
1744 acpi_name(hdl), "_BCL", AcpiFormatException(rv));
1745 if (pkg != NULL)
1746 ACPI_FREE(pkg);
1747 if (bc != NULL) {
1748 if (bc->bc_level != NULL)
1749 kmem_free(bc->bc_level,
1750 bc->bc_level_count * sizeof(*bc->bc_level));
1751 kmem_free(bc, sizeof(*bc));
1752 }
1753 return NULL;
1754 }
1755
1756 /*
1757 * Evaluation of simple ACPI display methods.
1758 */
1759
1760 static int
1761 acpidisp_set_policy(const struct acpidisp_vga_softc *asc, uint8_t value)
1762 {
1763 ACPI_HANDLE hdl = asc->sc_node->ad_handle;
1764 ACPI_INTEGER val;
1765 ACPI_STATUS rv;
1766
1767 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: set %s: 0x%"PRIx8"\n",
1768 device_xname(asc->sc_dev), "policy", value));
1769
1770 if (!(asc->sc_caps & ACPI_DISP_VGA_CAP__DOS))
1771 return ENODEV;
1772
1773 val = (ACPI_INTEGER)value;
1774 rv = acpi_eval_set_integer(hdl, "_DOS", val);
1775 if (ACPI_FAILURE(rv)) {
1776 aprint_error_dev(asc->sc_dev, "failed to evaluate %s.%s: %s\n",
1777 acpi_name(hdl), "_DOS", AcpiFormatException(rv));
1778 return EIO;
1779 }
1780
1781 return 0;
1782 }
1783
1784 static int
1785 acpidisp_get_status(const struct acpidisp_out_softc *osc, uint32_t *valuep)
1786 {
1787 ACPI_HANDLE hdl = osc->sc_node->ad_handle;
1788 ACPI_INTEGER val;
1789 ACPI_STATUS rv;
1790
1791 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__DCS))
1792 return ENODEV;
1793
1794 rv = acpi_eval_integer(hdl, "_DCS", &val);
1795 if (ACPI_FAILURE(rv)) {
1796 aprint_error_dev(osc->sc_dev, "failed to evaluate %s.%s: %s\n",
1797 acpi_name(hdl), "_DCS", AcpiFormatException(rv));
1798 return EIO;
1799 }
1800
1801 if (val > UINT32_MAX)
1802 return ERANGE;
1803
1804 *valuep = (uint32_t)val;
1805
1806 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: get %s: 0x%"PRIx32"\n",
1807 device_xname(osc->sc_dev), "status", *valuep));
1808
1809 return 0;
1810 }
1811
1812 static int
1813 acpidisp_get_state(const struct acpidisp_out_softc *osc, uint32_t *valuep)
1814 {
1815 ACPI_HANDLE hdl = osc->sc_node->ad_handle;
1816 ACPI_INTEGER val;
1817 ACPI_STATUS rv;
1818
1819 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__DGS))
1820 return ENODEV;
1821
1822 rv = acpi_eval_integer(hdl, "_DGS", &val);
1823 if (ACPI_FAILURE(rv)) {
1824 aprint_error_dev(osc->sc_dev, "failed to evaluate %s.%s: %s\n",
1825 acpi_name(hdl), "_DGS", AcpiFormatException(rv));
1826 return EIO;
1827 }
1828
1829 if (val > UINT32_MAX)
1830 return ERANGE;
1831
1832 *valuep = (uint32_t)val;
1833
1834 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: get %s: 0x%"PRIx32"\n",
1835 device_xname(osc->sc_dev), "state", *valuep));
1836
1837 return 0;
1838 }
1839
1840 static int
1841 acpidisp_set_state(const struct acpidisp_out_softc *osc, uint32_t value)
1842 {
1843 ACPI_HANDLE hdl = osc->sc_node->ad_handle;
1844 ACPI_INTEGER val;
1845 ACPI_STATUS rv;
1846
1847 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: set %s: 0x%"PRIx32"\n",
1848 device_xname(osc->sc_dev), "state", value));
1849
1850 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__DSS))
1851 return ENODEV;
1852
1853 val = (ACPI_INTEGER)value;
1854 rv = acpi_eval_set_integer(hdl, "_DSS", val);
1855 if (ACPI_FAILURE(rv)) {
1856 aprint_error_dev(osc->sc_dev, "failed to evaluate %s.%s: %s\n",
1857 acpi_name(hdl), "_DSS", AcpiFormatException(rv));
1858 return EIO;
1859 }
1860
1861 return 0;
1862 }
1863
1864 static int
1865 acpidisp_get_brightness(const struct acpidisp_out_softc *osc, uint8_t *valuep)
1866 {
1867 ACPI_HANDLE hdl = osc->sc_node->ad_handle;
1868 ACPI_INTEGER val;
1869 ACPI_STATUS rv;
1870
1871 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__BQC))
1872 return ENODEV;
1873
1874 if (osc->sc_brctl->bc_bqc_broken) {
1875 *valuep = osc->sc_brctl->bc_current;
1876 return 0;
1877 }
1878
1879 rv = acpi_eval_integer(hdl, "_BQC", &val);
1880 if (ACPI_FAILURE(rv)) {
1881 aprint_error_dev(osc->sc_dev, "failed to evaluate %s.%s: %s\n",
1882 acpi_name(hdl), "_BQC", AcpiFormatException(rv));
1883 return EIO;
1884 }
1885
1886 if (val > UINT8_MAX)
1887 return ERANGE;
1888
1889 *valuep = (uint8_t)val;
1890
1891 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: get %s: %"PRIu8"\n",
1892 device_xname(osc->sc_dev), "brightness", *valuep));
1893
1894 return 0;
1895 }
1896
1897 /*
1898 * Quirk for when getting the brightness value always returns the same
1899 * result, which breaks brightness controls which try to lower the
1900 * brightness by a specific value and then check if it worked.
1901 */
1902 static int
1903 acpidisp_quirk_get_brightness(const struct acpidisp_out_softc *osc)
1904 {
1905 struct acpidisp_brctl *bc;
1906 uint8_t original_brightness, test_brightness;
1907 int error;
1908
1909 bc = osc->sc_brctl;
1910
1911 /* Avoid false results if quirk already enabled */
1912 bc->bc_bqc_broken = false;
1913
1914 error = acpidisp_get_brightness(osc, &bc->bc_current);
1915 if (error)
1916 return error;
1917 original_brightness = bc->bc_current;
1918
1919 /* Find a different brightness value */
1920 test_brightness = bc->bc_level[bc->bc_level_count - 1];
1921 if (test_brightness == original_brightness)
1922 test_brightness = bc->bc_level[0];
1923
1924 if (test_brightness == original_brightness) {
1925 aprint_error_dev(osc->sc_dev,
1926 "couldn't find different brightness levels"
1927 " for _BQC quirk test\n");
1928 return 0;
1929 }
1930
1931 bc->bc_current = test_brightness;
1932 error = acpidisp_set_brightness(osc, bc->bc_current);
1933 if (error)
1934 return error;
1935
1936 error = acpidisp_get_brightness(osc, &bc->bc_current);
1937 if (error)
1938 return error;
1939
1940 /* We set a different value, but got the original value back */
1941 if (bc->bc_current == original_brightness) {
1942 aprint_normal_dev(osc->sc_dev, "_BQC broken, enabling quirk\n");
1943 bc->bc_bqc_broken = true;
1944 }
1945
1946 /* Restore original value */
1947 bc->bc_current = original_brightness;
1948 return acpidisp_set_brightness(osc, bc->bc_current);
1949 }
1950
1951 static int
1952 acpidisp_set_brightness(const struct acpidisp_out_softc *osc, uint8_t value)
1953 {
1954 ACPI_HANDLE hdl = osc->sc_node->ad_handle;
1955 ACPI_INTEGER val;
1956 ACPI_STATUS rv;
1957
1958 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: set %s: %"PRIu8"\n",
1959 device_xname(osc->sc_dev), "brightness", value));
1960
1961 if (!(osc->sc_caps & ACPI_DISP_OUT_CAP__BCM))
1962 return ENODEV;
1963
1964 val = (ACPI_INTEGER)value;
1965 rv = acpi_eval_set_integer(hdl, "_BCM", val);
1966 if (ACPI_FAILURE(rv)) {
1967 aprint_error_dev(osc->sc_dev, "failed to evaluate %s.%s: %s\n",
1968 acpi_name(hdl), "_BCM", AcpiFormatException(rv));
1969 return EIO;
1970 }
1971
1972 return 0;
1973 }
1974
1975 /*
1976 * Pretty printing.
1977 */
1978
1979 static void
1980 acpidisp_print_odinfo(device_t self, const struct acpidisp_odinfo *oi)
1981 {
1982 struct acpidisp_outdev *od;
1983 uint32_t i;
1984
1985 KASSERT(oi != NULL);
1986
1987 aprint_verbose_dev(self, "connected output devices:\n");
1988 for (i = 0, od = oi->oi_dev; i < oi->oi_dev_count; i++, od++) {
1989 aprint_verbose_dev(self, " 0x%04"PRIx16, od->od_attrs.device_id);
1990 if (od->od_device != NULL)
1991 aprint_verbose(" (%s)", device_xname(od->od_device));
1992 aprint_verbose(": ");
1993 acpidisp_print_od_attrs(od->od_attrs);
1994 aprint_verbose("\n");
1995 }
1996 }
1997
1998 /*
1999 * general purpose range printing function
2000 * 1 -> 1
2001 * 1 2 4 6 7-> [1-2,4,6-7]
2002 */
2003 static void
2004 ranger(uint8_t *a, size_t l, void (*pr)(const char *, ...) __printflike(1, 2))
2005 {
2006 uint8_t b, e;
2007
2008 if (l > 1)
2009 (*pr)("[");
2010
2011 for (size_t i = 0; i < l; i++) {
2012 for (b = e = a[i]; i + 1 < l && a[i + 1] == e + 1; i++, e++)
2013 continue;
2014 (*pr)("%"PRIu8, b);
2015 if (b != e)
2016 (*pr)("-%"PRIu8, e);
2017 if (i < l - 1)
2018 (*pr)(",");
2019 }
2020
2021 if (l > 1)
2022 (*pr)("]");
2023 }
2024
2025 static void
2026 acpidisp_print_brctl(device_t self, const struct acpidisp_brctl *bc)
2027 {
2028 KASSERT(bc != NULL);
2029
2030 aprint_verbose_dev(self, "brightness levels: ");
2031 ranger(bc->bc_level, bc->bc_level_count, aprint_verbose);
2032 aprint_verbose("\n");
2033 }
2034
2035 static void
2036 acpidisp_print_od_attrs(acpidisp_od_attrs_t oda)
2037 {
2038 const char *type;
2039
2040 if (oda.fmt.device_id_scheme == 1) {
2041 /* Uses the device ID scheme introduced in ACPI 3.0. */
2042 switch (oda.fmt.type) {
2043 case ACPI_DISP_OUT_ATTR_TYPE_OTHER:
2044 type = "Other";
2045 break;
2046 case ACPI_DISP_OUT_ATTR_TYPE_VGA:
2047 type = "VGA Analog Monitor";
2048 break;
2049 case ACPI_DISP_OUT_ATTR_TYPE_TV:
2050 type = "TV/HDTV Monitor";
2051 break;
2052 case ACPI_DISP_OUT_ATTR_TYPE_EXTDIG:
2053 type = "Ext. Digital Monitor";
2054 break;
2055 case ACPI_DISP_OUT_ATTR_TYPE_INTDFP:
2056 type = "Int. Digital Flat Panel";
2057 break;
2058 default:
2059 type = "Invalid";
2060 break;
2061 }
2062
2063 aprint_verbose("%s, index %d, port %d",
2064 type, oda.fmt.index, oda.fmt.port);
2065 } else {
2066 /* Uses vendor-specific device IDs. */
2067 switch (oda.device_id) {
2068 case ACPI_DISP_OUT_LEGACY_DEVID_MONITOR:
2069 type = "Ext. Monitor";
2070 break;
2071 case ACPI_DISP_OUT_LEGACY_DEVID_PANEL:
2072 type = "LCD Panel";
2073 break;
2074 case ACPI_DISP_OUT_LEGACY_DEVID_TV:
2075 type = "TV";
2076 break;
2077 default:
2078 type = "Unknown Output Device";
2079 break;
2080 }
2081
2082 aprint_verbose("%s", type);
2083 }
2084
2085 aprint_verbose(", head %d", oda.fmt.head_id);
2086 if (oda.fmt.bios_detect)
2087 aprint_verbose(", bios detect");
2088 if (oda.fmt.non_vga)
2089 aprint_verbose(", non vga");
2090 }
2091
2092 /*
2093 * General-purpose utility functions.
2094 */
2095
2096 /*
2097 * acpidisp_has_method:
2098 *
2099 * Returns true if and only if (a) the object handle.path exists and
2100 * (b) this object is a method or has the given type.
2101 */
2102 static bool
2103 acpidisp_has_method(ACPI_HANDLE handle, const char *path, ACPI_OBJECT_TYPE type)
2104 {
2105 ACPI_HANDLE hdl;
2106 ACPI_OBJECT_TYPE typ;
2107
2108 KASSERT(handle != NULL);
2109
2110 if (ACPI_FAILURE(AcpiGetHandle(handle, path, &hdl)))
2111 return false;
2112
2113 if (ACPI_FAILURE(AcpiGetType(hdl, &typ)))
2114 return false;
2115
2116 if (typ != ACPI_TYPE_METHOD && typ != type)
2117 return false;
2118
2119 return true;
2120 }
2121
2122 /*
2123 * acpidisp_eval_package:
2124 *
2125 * Evaluate a package (with an expected minimum number of elements).
2126 * Caller must free *pkg by ACPI_FREE().
2127 */
2128 static ACPI_STATUS
2129 acpidisp_eval_package(ACPI_HANDLE handle, const char *path, ACPI_OBJECT **pkg,
2130 unsigned int mincount)
2131 {
2132 ACPI_BUFFER buf;
2133 ACPI_OBJECT *obj;
2134 ACPI_STATUS rv;
2135
2136 rv = acpi_eval_struct(handle, path, &buf);
2137 if (ACPI_FAILURE(rv))
2138 return rv;
2139
2140 if (buf.Length == 0 || buf.Pointer == NULL)
2141 return AE_NULL_OBJECT;
2142
2143 obj = buf.Pointer;
2144
2145 if (obj->Type != ACPI_TYPE_PACKAGE) {
2146 ACPI_FREE(obj);
2147 return AE_TYPE;
2148 }
2149
2150 if (obj->Package.Count < mincount) {
2151 ACPI_FREE(obj);
2152 return AE_BAD_DATA;
2153 }
2154
2155 *pkg = obj;
2156 return rv;
2157 }
2158
2159 /*
2160 * acpidisp_array_search:
2161 *
2162 * Look for a value v in a sorted array a of n integers (n > 0). Fill *l
2163 * and *u as follows:
2164 *
2165 * *l = Max {a[i] | a[i] <= v or i = 0}
2166 * *u = Min {a[i] | a[i] >= v or i = n-1}
2167 */
2168 static void
2169 acpidisp_array_search(const uint8_t *a, uint16_t n, int v, uint8_t *l, uint8_t *u)
2170 {
2171 uint16_t i, j, m;
2172
2173 if (v <= a[0]) {
2174 *l = a[0];
2175 *u = a[0];
2176 return;
2177 }
2178 if (v >= a[n-1]) {
2179 *l = a[n-1];
2180 *u = a[n-1];
2181 return;
2182 }
2183
2184 for (i = 0, j = n - 1; j - i > 1; ) {
2185 m = (i + j) / 2;
2186
2187 if (a[m] == v) {
2188 *l = v;
2189 *u = v;
2190 return;
2191 }
2192
2193 if (a[m] < v)
2194 i = m;
2195 else
2196 j = m;
2197 }
2198
2199 /* Here a[i] < v < a[j] and j = i + 1. */
2200 *l = a[i];
2201 *u = a[j];
2202 return;
2203 }
2204
2205 MODULE(MODULE_CLASS_DRIVER, acpivga, NULL);
2206
2207 #ifdef _MODULE
2208 #include "ioconf.c"
2209 #endif
2210
2211 static int
2212 acpivga_modcmd(modcmd_t cmd, void *aux)
2213 {
2214 int rv = 0;
2215
2216 switch (cmd) {
2217
2218 case MODULE_CMD_INIT:
2219 KASSERT(PSLIST_READER_FIRST(&acpidisp_notifiers.list,
2220 struct acpidisp_notifier, adn_entry) == NULL);
2221 mutex_init(&acpidisp_notifiers.lock, MUTEX_DEFAULT, IPL_NONE);
2222 #ifdef _MODULE
2223 rv = config_init_component(cfdriver_ioconf_acpivga,
2224 cfattach_ioconf_acpivga, cfdata_ioconf_acpivga);
2225 #endif
2226 break;
2227
2228 case MODULE_CMD_FINI:
2229
2230 #ifdef _MODULE
2231 rv = config_fini_component(cfdriver_ioconf_acpivga,
2232 cfattach_ioconf_acpivga, cfdata_ioconf_acpivga);
2233 if (rv)
2234 break;
2235 #endif
2236 mutex_destroy(&acpidisp_notifiers.lock);
2237 break;
2238
2239 default:
2240 rv = ENOTTY;
2241 }
2242
2243 return rv;
2244 }
2245