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 | |
94e2bd68 | 10 | * assigned |
c3d6de69 TR |
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 | |
677bd810 | 20 | * backlight switching supporting driver calls: |
c3d6de69 TR |
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 | * | |
7ec48ced | 26 | * Otherwise vendor specific drivers like thinkpad_acpi, asus-laptop, |
677bd810 | 27 | * sony_acpi,... can take care about backlight brightness. |
c3d6de69 TR |
28 | * |
29 | * If CONFIG_ACPI_VIDEO is neither set as "compiled in" (y) nor as a module (m) | |
30 | * this file will not be compiled, acpi_video_get_capabilities() and | |
31 | * acpi_video_backlight_support() will always return 0 and vendor specific | |
32 | * drivers always can handle backlight. | |
33 | * | |
34 | */ | |
35 | ||
214f2c90 | 36 | #include <linux/export.h> |
c3d6de69 TR |
37 | #include <linux/acpi.h> |
38 | #include <linux/dmi.h> | |
1e4cffe7 | 39 | #include <linux/pci.h> |
c3d6de69 | 40 | |
8c5bd7ad RW |
41 | #include "internal.h" |
42 | ||
c3d6de69 | 43 | ACPI_MODULE_NAME("video"); |
c3d6de69 TR |
44 | #define _COMPONENT ACPI_VIDEO_COMPONENT |
45 | ||
46 | static long acpi_video_support; | |
47 | static bool acpi_video_caps_checked; | |
48 | ||
49 | static acpi_status | |
50 | acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context, | |
0039735e | 51 | void **return_value) |
c3d6de69 TR |
52 | { |
53 | long *cap = context; | |
c3d6de69 | 54 | |
952c63e9 JL |
55 | if (acpi_has_method(handle, "_BCM") && |
56 | acpi_has_method(handle, "_BCL")) { | |
c3d6de69 TR |
57 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight " |
58 | "support\n")); | |
59 | *cap |= ACPI_VIDEO_BACKLIGHT; | |
952c63e9 | 60 | if (!acpi_has_method(handle, "_BQC")) |
e9f74c48 ZR |
61 | printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, " |
62 | "cannot determine initial brightness\n"); | |
c3d6de69 TR |
63 | /* We have backlight support, no need to scan further */ |
64 | return AE_CTRL_TERMINATE; | |
65 | } | |
66 | return 0; | |
67 | } | |
68 | ||
d4e1a692 TK |
69 | /* Returns true if the ACPI object is a video device which can be |
70 | * handled by video.ko. | |
c3d6de69 TR |
71 | * The device will get a Linux specific CID added in scan.c to |
72 | * identify the device as an ACPI graphics device | |
73 | * Be aware that the graphics device may not be physically present | |
74 | * Use acpi_video_get_capabilities() to detect general ACPI video | |
75 | * capabilities of present cards | |
76 | */ | |
d4e1a692 | 77 | long acpi_is_video_device(acpi_handle handle) |
c3d6de69 | 78 | { |
c3d6de69 TR |
79 | long video_caps = 0; |
80 | ||
ed764e7c | 81 | /* Is this device able to support video switching ? */ |
952c63e9 | 82 | if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS")) |
ed764e7c MK |
83 | video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING; |
84 | ||
94e2bd68 | 85 | /* Is this device able to retrieve a video ROM ? */ |
952c63e9 | 86 | if (acpi_has_method(handle, "_ROM")) |
c3d6de69 TR |
87 | video_caps |= ACPI_VIDEO_ROM_AVAILABLE; |
88 | ||
94e2bd68 | 89 | /* Is this device able to configure which video head to be POSTed ? */ |
952c63e9 JL |
90 | if (acpi_has_method(handle, "_VPO") && |
91 | acpi_has_method(handle, "_GPD") && | |
92 | acpi_has_method(handle, "_SPD")) | |
c3d6de69 TR |
93 | video_caps |= ACPI_VIDEO_DEVICE_POSTING; |
94 | ||
95 | /* Only check for backlight functionality if one of the above hit. */ | |
96 | if (video_caps) | |
d4e1a692 | 97 | acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, |
2263576c | 98 | ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL, |
c3d6de69 TR |
99 | &video_caps, NULL); |
100 | ||
101 | return video_caps; | |
102 | } | |
103 | EXPORT_SYMBOL(acpi_is_video_device); | |
104 | ||
105 | static acpi_status | |
106 | find_video(acpi_handle handle, u32 lvl, void *context, void **rv) | |
107 | { | |
108 | long *cap = context; | |
1e4cffe7 | 109 | struct pci_dev *dev; |
c3d6de69 TR |
110 | struct acpi_device *acpi_dev; |
111 | ||
112 | const struct acpi_device_id video_ids[] = { | |
113 | {ACPI_VIDEO_HID, 0}, | |
114 | {"", 0}, | |
115 | }; | |
116 | if (acpi_bus_get_device(handle, &acpi_dev)) | |
117 | return AE_OK; | |
118 | ||
119 | if (!acpi_match_device_ids(acpi_dev, video_ids)) { | |
1e4cffe7 | 120 | dev = acpi_get_pci_dev(handle); |
c3d6de69 TR |
121 | if (!dev) |
122 | return AE_OK; | |
1e4cffe7 | 123 | pci_dev_put(dev); |
d4e1a692 | 124 | *cap |= acpi_is_video_device(handle); |
c3d6de69 TR |
125 | } |
126 | return AE_OK; | |
127 | } | |
128 | ||
084940d5 CC |
129 | /* Force to use vendor driver when the ACPI device is known to be |
130 | * buggy */ | |
131 | static int video_detect_force_vendor(const struct dmi_system_id *d) | |
132 | { | |
133 | acpi_video_support |= ACPI_VIDEO_BACKLIGHT_DMI_VENDOR; | |
134 | return 0; | |
135 | } | |
136 | ||
137 | static struct dmi_system_id video_detect_dmi_table[] = { | |
138 | /* On Samsung X360, the BIOS will set a flag (VDRV) if generic | |
139 | * ACPI backlight device is used. This flag will definitively break | |
140 | * the backlight interface (even the vendor interface) untill next | |
141 | * reboot. It's why we should prevent video.ko from being used here | |
142 | * and we can't rely on a later call to acpi_video_unregister(). | |
143 | */ | |
144 | { | |
145 | .callback = video_detect_force_vendor, | |
146 | .ident = "X360", | |
147 | .matches = { | |
148 | DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), | |
149 | DMI_MATCH(DMI_PRODUCT_NAME, "X360"), | |
150 | DMI_MATCH(DMI_BOARD_NAME, "X360"), | |
151 | }, | |
152 | }, | |
d0c2ce16 LT |
153 | { |
154 | .callback = video_detect_force_vendor, | |
155 | .ident = "Asus UL30VT", | |
156 | .matches = { | |
157 | DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."), | |
158 | DMI_MATCH(DMI_PRODUCT_NAME, "UL30VT"), | |
159 | }, | |
160 | }, | |
c8f6d835 BT |
161 | { |
162 | .callback = video_detect_force_vendor, | |
163 | .ident = "Asus UL30A", | |
164 | .matches = { | |
165 | DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."), | |
166 | DMI_MATCH(DMI_PRODUCT_NAME, "UL30A"), | |
167 | }, | |
168 | }, | |
08a56226 EL |
169 | { |
170 | .callback = video_detect_force_vendor, | |
171 | .ident = "Dell Inspiron 5737", | |
172 | .matches = { | |
173 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
174 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5737"), | |
175 | }, | |
176 | }, | |
a11d342f SB |
177 | { |
178 | .callback = video_detect_force_vendor, | |
179 | .ident = "Lenovo IdeaPad Z570", | |
180 | .matches = { | |
181 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), | |
182 | DMI_MATCH(DMI_PRODUCT_VERSION, "Ideapad Z570"), | |
183 | }, | |
184 | }, | |
084940d5 CC |
185 | { }, |
186 | }; | |
187 | ||
c3d6de69 TR |
188 | /* |
189 | * Returns the video capabilities of a specific ACPI graphics device | |
190 | * | |
191 | * if NULL is passed as argument all ACPI devices are enumerated and | |
192 | * all graphics capabilities of physically present devices are | |
94e2bd68 | 193 | * summarized and returned. This is cached and done only once. |
c3d6de69 TR |
194 | */ |
195 | long acpi_video_get_capabilities(acpi_handle graphics_handle) | |
196 | { | |
197 | long caps = 0; | |
198 | struct acpi_device *tmp_dev; | |
199 | acpi_status status; | |
200 | ||
201 | if (acpi_video_caps_checked && graphics_handle == NULL) | |
202 | return acpi_video_support; | |
203 | ||
204 | if (!graphics_handle) { | |
205 | /* Only do the global walk through all graphics devices once */ | |
206 | acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, | |
2263576c | 207 | ACPI_UINT32_MAX, find_video, NULL, |
c3d6de69 TR |
208 | &caps, NULL); |
209 | /* There might be boot param flags set already... */ | |
210 | acpi_video_support |= caps; | |
211 | acpi_video_caps_checked = 1; | |
212 | /* Add blacklists here. Be careful to use the right *DMI* bits | |
213 | * to still be able to override logic via boot params, e.g.: | |
214 | * | |
215 | * if (dmi_name_in_vendors("XY")) { | |
216 | * acpi_video_support |= | |
c3d6de69 TR |
217 | * ACPI_VIDEO_BACKLIGHT_DMI_VENDOR; |
218 | *} | |
219 | */ | |
084940d5 CC |
220 | |
221 | dmi_check_system(video_detect_dmi_table); | |
c3d6de69 TR |
222 | } else { |
223 | status = acpi_bus_get_device(graphics_handle, &tmp_dev); | |
224 | if (ACPI_FAILURE(status)) { | |
225 | ACPI_EXCEPTION((AE_INFO, status, "Invalid device")); | |
226 | return 0; | |
227 | } | |
228 | acpi_walk_namespace(ACPI_TYPE_DEVICE, graphics_handle, | |
2263576c | 229 | ACPI_UINT32_MAX, find_video, NULL, |
c3d6de69 TR |
230 | &caps, NULL); |
231 | } | |
232 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "We have 0x%lX video support %s %s\n", | |
233 | graphics_handle ? caps : acpi_video_support, | |
234 | graphics_handle ? "on device " : "in general", | |
235 | graphics_handle ? acpi_device_bid(tmp_dev) : "")); | |
236 | return caps; | |
237 | } | |
238 | EXPORT_SYMBOL(acpi_video_get_capabilities); | |
239 | ||
f838eb5b | 240 | static void acpi_video_caps_check(void) |
c3d6de69 TR |
241 | { |
242 | /* | |
243 | * We must check whether the ACPI graphics device is physically plugged | |
244 | * in. Therefore this must be called after binding PCI and ACPI devices | |
245 | */ | |
246 | if (!acpi_video_caps_checked) | |
247 | acpi_video_get_capabilities(NULL); | |
f838eb5b CC |
248 | } |
249 | ||
fbc9fe1b | 250 | bool acpi_osi_is_win8(void) |
8c5bd7ad | 251 | { |
8e5c2b77 | 252 | return acpi_gbl_osi_data >= ACPI_OSI_WIN_8; |
8c5bd7ad | 253 | } |
fbc9fe1b | 254 | EXPORT_SYMBOL(acpi_osi_is_win8); |
8c5bd7ad | 255 | |
f838eb5b CC |
256 | /* Promote the vendor interface instead of the generic video module. |
257 | * This function allow DMI blacklists to be implemented by externals | |
258 | * platform drivers instead of putting a big blacklist in video_detect.c | |
259 | * After calling this function you will probably want to call | |
260 | * acpi_video_unregister() to make sure the video module is not loaded | |
261 | */ | |
262 | void acpi_video_dmi_promote_vendor(void) | |
263 | { | |
264 | acpi_video_caps_check(); | |
265 | acpi_video_support |= ACPI_VIDEO_BACKLIGHT_DMI_VENDOR; | |
266 | } | |
267 | EXPORT_SYMBOL(acpi_video_dmi_promote_vendor); | |
268 | ||
269 | /* To be called when a driver who previously promoted the vendor | |
270 | * interface */ | |
271 | void acpi_video_dmi_demote_vendor(void) | |
272 | { | |
273 | acpi_video_caps_check(); | |
274 | acpi_video_support &= ~ACPI_VIDEO_BACKLIGHT_DMI_VENDOR; | |
275 | } | |
276 | EXPORT_SYMBOL(acpi_video_dmi_demote_vendor); | |
277 | ||
278 | /* Returns true if video.ko can do backlight switching */ | |
279 | int acpi_video_backlight_support(void) | |
280 | { | |
281 | acpi_video_caps_check(); | |
c3d6de69 TR |
282 | |
283 | /* First check for boot param -> highest prio */ | |
284 | if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR) | |
285 | return 0; | |
286 | else if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO) | |
287 | return 1; | |
288 | ||
289 | /* Then check for DMI blacklist -> second highest prio */ | |
290 | if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_DMI_VENDOR) | |
291 | return 0; | |
292 | else if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_DMI_VIDEO) | |
293 | return 1; | |
294 | ||
295 | /* Then go the default way */ | |
296 | return acpi_video_support & ACPI_VIDEO_BACKLIGHT; | |
297 | } | |
298 | EXPORT_SYMBOL(acpi_video_backlight_support); | |
299 | ||
300 | /* | |
677bd810 ZR |
301 | * Use acpi_backlight=vendor/video to force that backlight switching |
302 | * is processed by vendor specific acpi drivers or video.ko driver. | |
c3d6de69 | 303 | */ |
8a383ef0 | 304 | static int __init acpi_backlight(char *str) |
c3d6de69 TR |
305 | { |
306 | if (str == NULL || *str == '\0') | |
307 | return 1; | |
308 | else { | |
309 | if (!strcmp("vendor", str)) | |
310 | acpi_video_support |= | |
311 | ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR; | |
312 | if (!strcmp("video", str)) | |
313 | acpi_video_support |= | |
eeb4bcb4 | 314 | ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO; |
c3d6de69 TR |
315 | } |
316 | return 1; | |
317 | } | |
318 | __setup("acpi_backlight=", acpi_backlight); |