Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 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 |
Thadeu Lima de Souza Cascardo | 94e2bd6 | 2009-10-16 15:20:49 +0200 | [diff] [blame] | 10 | * assigned |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 11 | * |
| 12 | * After PCI devices are glued with ACPI devices |
Alexander Chiang | 1e4cffe | 2009-06-10 19:56:00 +0000 | [diff] [blame] | 13 | * acpi_get_pci_dev() can be called to identify ACPI graphics |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 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> |
Alexander Chiang | 1e4cffe | 2009-06-10 19:56:00 +0000 | [diff] [blame] | 39 | #include <linux/pci.h> |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 40 | |
Len Brown | a192a95 | 2009-07-28 16:45:54 -0400 | [diff] [blame] | 41 | #define PREFIX "ACPI: " |
| 42 | |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 43 | ACPI_MODULE_NAME("video"); |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 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, |
| 51 | void **retyurn_value) |
| 52 | { |
| 53 | long *cap = context; |
| 54 | acpi_handle h_dummy; |
| 55 | |
| 56 | if (ACPI_SUCCESS(acpi_get_handle(handle, "_BCM", &h_dummy)) && |
| 57 | ACPI_SUCCESS(acpi_get_handle(handle, "_BCL", &h_dummy))) { |
| 58 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight " |
| 59 | "support\n")); |
| 60 | *cap |= ACPI_VIDEO_BACKLIGHT; |
Zhang Rui | 98758fa | 2009-03-12 16:57:11 +0800 | [diff] [blame] | 61 | if (ACPI_FAILURE(acpi_get_handle(handle, "_BQC", &h_dummy))) |
Zhang Rui | e9f74c4 | 2010-09-03 10:08:50 +0800 | [diff] [blame] | 62 | printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, " |
| 63 | "cannot determine initial brightness\n"); |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 64 | /* We have backlight support, no need to scan further */ |
| 65 | return AE_CTRL_TERMINATE; |
| 66 | } |
| 67 | return 0; |
| 68 | } |
| 69 | |
| 70 | /* Returns true if the device is a video device which can be handled by |
| 71 | * video.ko. |
| 72 | * The device will get a Linux specific CID added in scan.c to |
| 73 | * identify the device as an ACPI graphics device |
| 74 | * Be aware that the graphics device may not be physically present |
| 75 | * Use acpi_video_get_capabilities() to detect general ACPI video |
| 76 | * capabilities of present cards |
| 77 | */ |
| 78 | long acpi_is_video_device(struct acpi_device *device) |
| 79 | { |
| 80 | acpi_handle h_dummy; |
| 81 | long video_caps = 0; |
| 82 | |
| 83 | if (!device) |
| 84 | return 0; |
| 85 | |
Thadeu Lima de Souza Cascardo | 94e2bd6 | 2009-10-16 15:20:49 +0200 | [diff] [blame] | 86 | /* Is this device able to support video switching ? */ |
Stefan Bader | 3a1151e | 2009-08-21 11:03:05 +0200 | [diff] [blame] | 87 | if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy)) || |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 88 | ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy))) |
| 89 | video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING; |
| 90 | |
Thadeu Lima de Souza Cascardo | 94e2bd6 | 2009-10-16 15:20:49 +0200 | [diff] [blame] | 91 | /* Is this device able to retrieve a video ROM ? */ |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 92 | if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy))) |
| 93 | video_caps |= ACPI_VIDEO_ROM_AVAILABLE; |
| 94 | |
Thadeu Lima de Souza Cascardo | 94e2bd6 | 2009-10-16 15:20:49 +0200 | [diff] [blame] | 95 | /* Is this device able to configure which video head to be POSTed ? */ |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 96 | if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy)) && |
| 97 | ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy)) && |
| 98 | ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy))) |
| 99 | video_caps |= ACPI_VIDEO_DEVICE_POSTING; |
| 100 | |
| 101 | /* Only check for backlight functionality if one of the above hit. */ |
| 102 | if (video_caps) |
| 103 | acpi_walk_namespace(ACPI_TYPE_DEVICE, device->handle, |
Lin Ming | 2263576 | 2009-11-13 10:06:08 +0800 | [diff] [blame] | 104 | ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL, |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 105 | &video_caps, NULL); |
| 106 | |
| 107 | return video_caps; |
| 108 | } |
| 109 | EXPORT_SYMBOL(acpi_is_video_device); |
| 110 | |
| 111 | static acpi_status |
| 112 | find_video(acpi_handle handle, u32 lvl, void *context, void **rv) |
| 113 | { |
| 114 | long *cap = context; |
Alexander Chiang | 1e4cffe | 2009-06-10 19:56:00 +0000 | [diff] [blame] | 115 | struct pci_dev *dev; |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 116 | struct acpi_device *acpi_dev; |
| 117 | |
| 118 | const struct acpi_device_id video_ids[] = { |
| 119 | {ACPI_VIDEO_HID, 0}, |
| 120 | {"", 0}, |
| 121 | }; |
| 122 | if (acpi_bus_get_device(handle, &acpi_dev)) |
| 123 | return AE_OK; |
| 124 | |
| 125 | if (!acpi_match_device_ids(acpi_dev, video_ids)) { |
Alexander Chiang | 1e4cffe | 2009-06-10 19:56:00 +0000 | [diff] [blame] | 126 | dev = acpi_get_pci_dev(handle); |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 127 | if (!dev) |
| 128 | return AE_OK; |
Alexander Chiang | 1e4cffe | 2009-06-10 19:56:00 +0000 | [diff] [blame] | 129 | pci_dev_put(dev); |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 130 | *cap |= acpi_is_video_device(acpi_dev); |
| 131 | } |
| 132 | return AE_OK; |
| 133 | } |
| 134 | |
| 135 | /* |
| 136 | * Returns the video capabilities of a specific ACPI graphics device |
| 137 | * |
| 138 | * if NULL is passed as argument all ACPI devices are enumerated and |
| 139 | * all graphics capabilities of physically present devices are |
Thadeu Lima de Souza Cascardo | 94e2bd6 | 2009-10-16 15:20:49 +0200 | [diff] [blame] | 140 | * summarized and returned. This is cached and done only once. |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 141 | */ |
| 142 | long acpi_video_get_capabilities(acpi_handle graphics_handle) |
| 143 | { |
| 144 | long caps = 0; |
| 145 | struct acpi_device *tmp_dev; |
| 146 | acpi_status status; |
| 147 | |
| 148 | if (acpi_video_caps_checked && graphics_handle == NULL) |
| 149 | return acpi_video_support; |
| 150 | |
| 151 | if (!graphics_handle) { |
| 152 | /* Only do the global walk through all graphics devices once */ |
| 153 | acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, |
Lin Ming | 2263576 | 2009-11-13 10:06:08 +0800 | [diff] [blame] | 154 | ACPI_UINT32_MAX, find_video, NULL, |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 155 | &caps, NULL); |
| 156 | /* There might be boot param flags set already... */ |
| 157 | acpi_video_support |= caps; |
| 158 | acpi_video_caps_checked = 1; |
| 159 | /* Add blacklists here. Be careful to use the right *DMI* bits |
| 160 | * to still be able to override logic via boot params, e.g.: |
| 161 | * |
| 162 | * if (dmi_name_in_vendors("XY")) { |
| 163 | * acpi_video_support |= |
| 164 | * ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR; |
| 165 | * acpi_video_support |= |
| 166 | * ACPI_VIDEO_BACKLIGHT_DMI_VENDOR; |
| 167 | *} |
| 168 | */ |
| 169 | } else { |
| 170 | status = acpi_bus_get_device(graphics_handle, &tmp_dev); |
| 171 | if (ACPI_FAILURE(status)) { |
| 172 | ACPI_EXCEPTION((AE_INFO, status, "Invalid device")); |
| 173 | return 0; |
| 174 | } |
| 175 | acpi_walk_namespace(ACPI_TYPE_DEVICE, graphics_handle, |
Lin Ming | 2263576 | 2009-11-13 10:06:08 +0800 | [diff] [blame] | 176 | ACPI_UINT32_MAX, find_video, NULL, |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 177 | &caps, NULL); |
| 178 | } |
| 179 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "We have 0x%lX video support %s %s\n", |
| 180 | graphics_handle ? caps : acpi_video_support, |
| 181 | graphics_handle ? "on device " : "in general", |
| 182 | graphics_handle ? acpi_device_bid(tmp_dev) : "")); |
| 183 | return caps; |
| 184 | } |
| 185 | EXPORT_SYMBOL(acpi_video_get_capabilities); |
| 186 | |
| 187 | /* Returns true if video.ko can do backlight switching */ |
| 188 | int acpi_video_backlight_support(void) |
| 189 | { |
| 190 | /* |
| 191 | * We must check whether the ACPI graphics device is physically plugged |
| 192 | * in. Therefore this must be called after binding PCI and ACPI devices |
| 193 | */ |
| 194 | if (!acpi_video_caps_checked) |
| 195 | acpi_video_get_capabilities(NULL); |
| 196 | |
| 197 | /* First check for boot param -> highest prio */ |
| 198 | if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR) |
| 199 | return 0; |
| 200 | else if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO) |
| 201 | return 1; |
| 202 | |
| 203 | /* Then check for DMI blacklist -> second highest prio */ |
| 204 | if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_DMI_VENDOR) |
| 205 | return 0; |
| 206 | else if (acpi_video_support & ACPI_VIDEO_BACKLIGHT_DMI_VIDEO) |
| 207 | return 1; |
| 208 | |
| 209 | /* Then go the default way */ |
| 210 | return acpi_video_support & ACPI_VIDEO_BACKLIGHT; |
| 211 | } |
| 212 | EXPORT_SYMBOL(acpi_video_backlight_support); |
| 213 | |
| 214 | /* |
| 215 | * Returns true if video.ko can do display output switching. |
| 216 | * This does not work well/at all with binary graphics drivers |
| 217 | * which disable system io ranges and do it on their own. |
| 218 | */ |
| 219 | int acpi_video_display_switch_support(void) |
| 220 | { |
| 221 | if (!acpi_video_caps_checked) |
| 222 | acpi_video_get_capabilities(NULL); |
| 223 | |
| 224 | if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR) |
| 225 | return 0; |
| 226 | else if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO) |
| 227 | return 1; |
| 228 | |
| 229 | if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR) |
| 230 | return 0; |
| 231 | else if (acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO) |
| 232 | return 1; |
| 233 | |
| 234 | return acpi_video_support & ACPI_VIDEO_OUTPUT_SWITCHING; |
| 235 | } |
| 236 | EXPORT_SYMBOL(acpi_video_display_switch_support); |
| 237 | |
| 238 | /* |
| 239 | * Use acpi_display_output=vendor/video or acpi_backlight=vendor/video |
| 240 | * To force that backlight or display output switching is processed by vendor |
| 241 | * specific acpi drivers or video.ko driver. |
| 242 | */ |
Roel Kluin | 8a383ef | 2008-12-09 20:45:30 +0100 | [diff] [blame] | 243 | static int __init acpi_backlight(char *str) |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 244 | { |
| 245 | if (str == NULL || *str == '\0') |
| 246 | return 1; |
| 247 | else { |
| 248 | if (!strcmp("vendor", str)) |
| 249 | acpi_video_support |= |
| 250 | ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR; |
| 251 | if (!strcmp("video", str)) |
| 252 | acpi_video_support |= |
Kamal Mostafa | eeb4bcb | 2010-05-01 12:09:49 -0700 | [diff] [blame] | 253 | ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO; |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 254 | } |
| 255 | return 1; |
| 256 | } |
| 257 | __setup("acpi_backlight=", acpi_backlight); |
| 258 | |
Roel Kluin | 8a383ef | 2008-12-09 20:45:30 +0100 | [diff] [blame] | 259 | static int __init acpi_display_output(char *str) |
Thomas Renninger | c3d6de6 | 2008-08-01 17:37:55 +0200 | [diff] [blame] | 260 | { |
| 261 | if (str == NULL || *str == '\0') |
| 262 | return 1; |
| 263 | else { |
| 264 | if (!strcmp("vendor", str)) |
| 265 | acpi_video_support |= |
| 266 | ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR; |
| 267 | if (!strcmp("video", str)) |
| 268 | acpi_video_support |= |
| 269 | ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO; |
| 270 | } |
| 271 | return 1; |
| 272 | } |
| 273 | __setup("acpi_display_output=", acpi_display_output); |