Commit | Line | Data |
---|---|---|
c3d6de69 TR |
1 | /* |
2 | * Copyright (C) 2008 SuSE Linux Products GmbH | |
3 | * Thomas Renninger <trenn@suse.de> | |
4 | * | |
5 | * May be copied or modified under the terms of the GNU General Public License | |
6 | * | |
7 | * video_detect.c: | |
8 | * Provides acpi_is_video_device() for early scanning of ACPI devices in scan.c | |
9 | * There a Linux specific (Spec does not provide a HID for video devices) is | |
10 | * assinged | |
11 | * | |
12 | * After PCI devices are glued with ACPI devices | |
1e4cffe7 | 13 | * acpi_get_pci_dev() can be called to identify ACPI graphics |
c3d6de69 TR |
14 | * devices for which a real graphics card is plugged in |
15 | * | |
16 | * Now acpi_video_get_capabilities() can be called to check which | |
17 | * capabilities the graphics cards plugged in support. The check for general | |
18 | * video capabilities will be triggered by the first caller of | |
19 | * acpi_video_get_capabilities(NULL); which will happen when the first | |
20 | * backlight (or display output) switching supporting driver calls: | |
21 | * acpi_video_backlight_support(); | |
22 | * | |
23 | * Depending on whether ACPI graphics extensions (cmp. ACPI spec Appendix B) | |
24 | * are available, video.ko should be used to handle the device. | |
25 | * | |
26 | * Otherwise vendor specific drivers like thinkpad_acpi, asus_acpi, | |
27 | * sony_acpi,... can take care about backlight brightness and display output | |
28 | * switching. | |
29 | * | |
30 | * If CONFIG_ACPI_VIDEO is neither set as "compiled in" (y) nor as a module (m) | |
31 | * this file will not be compiled, acpi_video_get_capabilities() and | |
32 | * acpi_video_backlight_support() will always return 0 and vendor specific | |
33 | * drivers always can handle backlight. | |
34 | * | |
35 | */ | |
36 | ||
37 | #include <linux/acpi.h> | |
38 | #include <linux/dmi.h> | |
1e4cffe7 | 39 | #include <linux/pci.h> |
c3d6de69 TR |
40 | |
41 | ACPI_MODULE_NAME("video"); | |
c3d6de69 TR |
42 | #define _COMPONENT ACPI_VIDEO_COMPONENT |
43 | ||
44 | static long acpi_video_support; | |
45 | static bool acpi_video_caps_checked; | |
46 | ||
47 | static acpi_status | |
48 | acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context, | |
49 | void **retyurn_value) | |
50 | { | |
51 | long *cap = context; | |
52 | acpi_handle h_dummy; | |
53 | ||
54 | if (ACPI_SUCCESS(acpi_get_handle(handle, "_BCM", &h_dummy)) && | |
55 | ACPI_SUCCESS(acpi_get_handle(handle, "_BCL", &h_dummy))) { | |
56 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight " | |
57 | "support\n")); | |
58 | *cap |= ACPI_VIDEO_BACKLIGHT; | |
98758faf ZR |
59 | if (ACPI_FAILURE(acpi_get_handle(handle, "_BQC", &h_dummy))) |
60 | printk(KERN_WARNING FW_BUG PREFIX "ACPI brightness " | |
61 | "control misses _BQC function\n"); | |
c3d6de69 TR |
62 | /* We have backlight support, no need to scan further */ |
63 | return AE_CTRL_TERMINATE; | |
64 | } | |
65 | return 0; | |
66 | } | |
67 | ||
68 | /* Returns true if the device is a video device which can be handled by | |
69 | * video.ko. | |
70 | * The device will get a Linux specific CID added in scan.c to | |
71 | * identify the device as an ACPI graphics device | |
72 | * Be aware that the graphics device may not be physically present | |
73 | * Use acpi_video_get_capabilities() to detect general ACPI video | |
74 | * capabilities of present cards | |
75 | */ | |
76 | long acpi_is_video_device(struct acpi_device *device) | |
77 | { | |
78 | acpi_handle h_dummy; | |
79 | long video_caps = 0; | |
80 | ||
81 | if (!device) | |
82 | return 0; | |
83 | ||
84 | /* Does this device able to support video switching ? */ | |
85 | if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy)) && | |
86 | ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy))) | |
87 | video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING; | |
88 | ||
89 | /* Does this device able to retrieve a video ROM ? */ | |
90 | if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy))) | |
91 | video_caps |= ACPI_VIDEO_ROM_AVAILABLE; | |
92 | ||
93 | /* Does this device able to configure which video head to be POSTed ? */ | |
94 | if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy)) && | |
95 | ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy)) && | |
96 | ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy))) | |
97 | video_caps |= ACPI_VIDEO_DEVICE_POSTING; | |
98 | ||
99 | /* Only check for backlight functionality if one of the above hit. */ | |
100 | if (video_caps) | |
101 | acpi_walk_namespace(ACPI_TYPE_DEVICE, device->handle, | |
102 | ACPI_UINT32_MAX, acpi_backlight_cap_match, | |
103 | &video_caps, NULL); | |
104 | ||
105 | return video_caps; | |
106 | } | |
107 | EXPORT_SYMBOL(acpi_is_video_device); | |
108 | ||
109 | static acpi_status | |
110 | find_video(acpi_handle handle, u32 lvl, void *context, void **rv) | |
111 | { | |
112 | long *cap = context; | |
1e4cffe7 | 113 | struct pci_dev *dev; |
c3d6de69 TR |
114 | struct acpi_device *acpi_dev; |
115 | ||
116 | const struct acpi_device_id video_ids[] = { | |
117 | {ACPI_VIDEO_HID, 0}, | |
118 | {"", 0}, | |
119 | }; | |
120 | if (acpi_bus_get_device(handle, &acpi_dev)) | |
121 | return AE_OK; | |
122 | ||
123 | if (!acpi_match_device_ids(acpi_dev, video_ids)) { | |
1e4cffe7 | 124 | dev = acpi_get_pci_dev(handle); |
c3d6de69 TR |
125 | if (!dev) |
126 | return AE_OK; | |
1e4cffe7 | 127 | pci_dev_put(dev); |
c3d6de69 TR |
128 | *cap |= acpi_is_video_device(acpi_dev); |
129 | } | |
130 | return AE_OK; | |
131 | } | |
132 | ||
133 | /* | |
134 | * Returns the video capabilities of a specific ACPI graphics device | |
135 | * | |
136 | * if NULL is passed as argument all ACPI devices are enumerated and | |
137 | * all graphics capabilities of physically present devices are | |
138 | * summerized and returned. This is cached and done only once. | |
139 | */ | |
140 | long acpi_video_get_capabilities(acpi_handle graphics_handle) | |
141 | { | |
142 | long caps = 0; | |
143 | struct acpi_device *tmp_dev; | |
144 | acpi_status status; | |
145 | ||
146 | if (acpi_video_caps_checked && graphics_handle == NULL) | |
147 | return acpi_video_support; | |
148 | ||
149 | if (!graphics_handle) { | |
150 | /* Only do the global walk through all graphics devices once */ | |
151 | acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, | |
152 | ACPI_UINT32_MAX, find_video, | |
153 | &caps, NULL); | |
154 | /* There might be boot param flags set already... */ | |
155 | acpi_video_support |= caps; | |
156 | acpi_video_caps_checked = 1; | |
157 | /* Add blacklists here. Be careful to use the right *DMI* bits | |
158 | * to still be able to override logic via boot params, e.g.: | |
159 | * | |
160 | * if (dmi_name_in_vendors("XY")) { | |
161 | * acpi_video_support |= | |
162 | * ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR; | |
163 | * acpi_video_support |= | |
164 | * ACPI_VIDEO_BACKLIGHT_DMI_VENDOR; | |
165 | *} | |
166 | */ | |
167 | } else { | |
168 | status = acpi_bus_get_device(graphics_handle, &tmp_dev); | |
169 | if (ACPI_FAILURE(status)) { | |
170 | ACPI_EXCEPTION((AE_INFO, status, "Invalid device")); | |
171 | return 0; | |
172 | } | |
173 | acpi_walk_namespace(ACPI_TYPE_DEVICE, graphics_handle, | |
174 | ACPI_UINT32_MAX, find_video, | |
175 | &caps, NULL); | |
176 | } | |
177 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "We have 0x%lX video support %s %s\n", | |
178 | graphics_handle ? caps : acpi_video_support, | |
179 | graphics_handle ? "on device " : "in general", | |
180 | graphics_handle ? acpi_device_bid(tmp_dev) : "")); | |
181 | return caps; | |
182 | } | |
183 | EXPORT_SYMBOL(acpi_video_get_capabilities); | |
184 | ||
185 | /* Returns true if video.ko can do backlight switching */ | |
186 | int acpi_video_backlight_support(void) | |
187 | { | |
188 | /* | |
189 | * We must check whether the ACPI graphics device is physically plugged | |
190 | * in. Therefore this must be called after binding PCI and ACPI devices | |
191 | */ | |
192 | if (!acpi_video_caps_checked) | |
193 | acpi_video_get_capabilities(NULL); | |
194 | ||
195 | /* First check for boot param -> highest prio */ | |
196 | if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR) | |
197 | return 0; | |
198 | else if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO) | |
199 | return 1; | |
200 | ||
201 | /* Then check for DMI blacklist -> second highest prio */ | |
202 | if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_DMI_VENDOR) | |
203 | return 0; | |
204 | else if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_DMI_VIDEO) | |
205 | return 1; | |
206 | ||
207 | /* Then go the default way */ | |
208 | return acpi_video_support & ACPI_VIDEO_BACKLIGHT; | |
209 | } | |
210 | EXPORT_SYMBOL(acpi_video_backlight_support); | |
211 | ||
212 | /* | |
213 | * Returns true if video.ko can do display output switching. | |
214 | * This does not work well/at all with binary graphics drivers | |
215 | * which disable system io ranges and do it on their own. | |
216 | */ | |
217 | int acpi_video_display_switch_support(void) | |
218 | { | |
219 | if (!acpi_video_caps_checked) | |
220 | acpi_video_get_capabilities(NULL); | |
221 | ||
222 | if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR) | |
223 | return 0; | |
224 | else if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO) | |
225 | return 1; | |
226 | ||
227 | if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR) | |
228 | return 0; | |
229 | else if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO) | |
230 | return 1; | |
231 | ||
232 | return acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING; | |
233 | } | |
234 | EXPORT_SYMBOL(acpi_video_display_switch_support); | |
235 | ||
236 | /* | |
237 | * Use acpi_display_output=vendor/video or acpi_backlight=vendor/video | |
238 | * To force that backlight or display output switching is processed by vendor | |
239 | * specific acpi drivers or video.ko driver. | |
240 | */ | |
8a383ef0 | 241 | static int __init acpi_backlight(char *str) |
c3d6de69 TR |
242 | { |
243 | if (str == NULL || *str == '\0') | |
244 | return 1; | |
245 | else { | |
246 | if (!strcmp("vendor", str)) | |
247 | acpi_video_support |= | |
248 | ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR; | |
249 | if (!strcmp("video", str)) | |
250 | acpi_video_support |= | |
251 | ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO; | |
252 | } | |
253 | return 1; | |
254 | } | |
255 | __setup("acpi_backlight=", acpi_backlight); | |
256 | ||
8a383ef0 | 257 | static int __init acpi_display_output(char *str) |
c3d6de69 TR |
258 | { |
259 | if (str == NULL || *str == '\0') | |
260 | return 1; | |
261 | else { | |
262 | if (!strcmp("vendor", str)) | |
263 | acpi_video_support |= | |
264 | ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR; | |
265 | if (!strcmp("video", str)) | |
266 | acpi_video_support |= | |
267 | ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO; | |
268 | } | |
269 | return 1; | |
270 | } | |
271 | __setup("acpi_display_output=", acpi_display_output); |